![The regex pattern [^a-z] finds all the occurrences of a character that is not in
a lowercase letter.
The regex pattern [^a-z] finds all the occurrences of a character that is not in a lowercase letter.](https://image.slidesharecdn.com/unit-5duplicate-241214045305-1a60381b/85/22CS307-ADAVANCE-JAVA-PROGRAMMING-UNIT-5-4-320.jpg)
22CS307-ADAVANCE JAVA PROGRAMMING UNIT 5
- 1. Importance and Use Cases of Advanced Stream Features Creating Custom Streams Stream Generators(Stream.generate,Stream.iterate) InfiniteStream-Using Spliterators Advanced Stream Operations - FlatMapping - Chaining Stream Operations Stream Peeking (peek) - Advanced Filtering Techniques (seminar) Introduction to Regular Expressions: Character Classes - Quantifiers - Pattern Matching - Groups and Capturing Regex in Java - java.util.regex Package Pattern Class - Matcher Class – StringManipulation with Regex - Splitting Strings – Replacing Text (replaceAll, replaceFirst) Replacing with Backreferences. Unit 5
- 4. The regex pattern [^a-z] finds all the occurrences of a character that is not in a lowercase letter. The regex pattern [^a-z] finds all the occurrences of a character that is not in a lowercase letter.
- 9. Quantifiers • In regular expressions, quantifiers are metacharacters that specify how many times the previous character or group should be matched. • Quantifiers allow you to specify the number of occurrences of a character or group, making it easier to match patterns of varying lengths. • Quantifiers can be used to specify the number or length that part of a pattern should match or repeat.
- 11. Regular Expressions in Java are provided under java.util.regex package. This consists of 3 classes and 1 interface. The java.util.regex package primarily consists of the following three classes as depicted below in tabular format as follows:
- 14. Pattern Matching : Pattern Class: Java Pattern Matching allows you to write more concise and readable code when working with complex data structures. It simplifies extracting data from data structures and performing operations on them. The pattern() method of the Pattern class in Java is used to get the regular expression which is compiled to create this pattern. We use a regular expression to create the pattern and this method used to get the same source expression.
- 16. Groups and Capturing Regex in Java: Regular Expression in Java Capturing groups is used to treat multiple characters as a single unit. You can create a group using (). Capturing groups are an extremely useful feature of regular expression matching that allow us to query the Matcher to find out what the part of the string was that matched against a particular part of the regular expression. The portion of input String that matches the capturing group is saved into memory and can be recalled using Backreference. Backreference in the regular expression with a backslash () and then the number of the group to be recalled
- 17. » An important feature of Regular Expressions is the ability to group sections of a pattern, and provide alternate matches. » The following two meta-characters are core parts of flexible Regular Expressions > | Alternation ('or' statement) > () Grouping » Consider if we know exactly subjects we are studying, and we want to find only those subjects but nothing else. Following is the pattern: » "I study (Java|English|Programming|Math|Islamic|HTML)"
- 18. Group can also be applied to pre-define a list of items that users are required to select from, such as: String pattern = (music|sport|book|movie) With the above-defined group, users must select one of the items: music, sport, book, or movie. The main purpose of using groups and subgroups is that we can separate the input string into sections and extract those sections if they are matched with the defined pattern. In java regular expressions, every pattern can have groups. And groups are indexed like in array’s elements. The first group index starts at 0 just like array indexes. There are two types of groups: explicit and implicit groups: - Characters placed in brackets (()) are called explicit groups. Those that we have used in the previous example. - Characters NOT placed in brackets (()) are called implicit groups.
- 20. Extract the individual date month and year: Suppose now I want to extract: •The day part •The month part •The year part
- 21. StringManipulation with Regex - Splitting Strings: To split a string in Java using regular expressions. We will be using the split(String regex) method of the String class to split this string around matches of the given regular expression. This method works in the same way as invoking the method i.e. split(String regex, int limit) with the given expression and a limit argument of zero. Therefore, trailing empty strings are not included in the resulting array. Steps to split string in Java using regular expression Following are the steps to split strings in Java using regular expression − • Import the classes from the java.lang package. • Create a string that contains text with various delimiters. • Define the regular expression pattern to identify the delimiters (spaces, commas, periods). • Use the split() method to break the string into tokens based on the defined delimiters. • Display the number of tokens and each token.
- 23. Explanation:
- 24. Replacing Text (replaceAll, replaceFirst) using regex replaceAll:
- 25. Replace first:
- 26. Replacing with Backreferences: • A backreference is a way to match the same text as previously matched by a capturing group. • Capturing groups count from 1, so the first capturing group's result can be referenced with 1, • the second with 2, and so on. 0 is a character escape for the NUL character.