CodeByAkram

What are the rules of writing regular expressions in Java?

What are the rules of writing regular expressions?

There are some rules for writing a regular expression or regex in java. Lets discuss about those rule. But first have a look on What are regular expressions or regex?

Common matching symbols that used in regex

Regular Expression	Description
`.`	Matches any character
`^regex`	Finds regex that must match at the beginning of the line.
`regex$`	Finds regex that must match at the end of the line.
`[abc]`	Set definition, can match the letter a or b or c.
`[abc][vz]`	Set definition, can match a or b or c followed by either v or z.
`[^abc]`	When a caret appears as the first character inside square brackets, it negates the pattern. This pattern matches any character except a or b or c.
`[a-d1-7]`	Ranges: matches a letter between a and d and figures from 1 to 7, but not d1.
`X\|Z`	Finds X or Z.
`XZ`	Finds X directly followed by Z.
`$`	Checks if a line end follows.

Meta characters

There are some pre-defined meta characters that are used to make certain common patterns easier to use. Let’s have a look on these characters.

Regular Expression	Description
`\d`	Any digit, short for `[0-9]`
`\D`	A non-digit, short for `[^0-9]`
`\s`	A whitespace character, short for `[ \t\n\x0b\r\f]`
`\S`	A non-whitespace character, short for
`\w`	A word character, short for `[a-zA-Z_0-9]`
`\W`	A non-word character `[^\w]`
`\S+`	Several non-whitespace characters
`\b`	Matches a word boundary where a word character is `[a-zA-Z0-9_]`

Quantifier

Quantifier defines how often an element can occur. The symbols ?, *, + and {} are qualifiers.

Regular Expression	Description	Examples
`*`	Occurs zero or more times, is short for `{0,}`	`X` finds no or several letter X, <sbr /> `.` finds any character sequence
`+`	Occurs one or more times, is short for `{1,}`	`X+`- Finds one or several letter X
`?`	Occurs no or one times, `?` is short for `{0,1}`.	`X?` finds no or exactly one letter X
`{X}`	Occurs X number of times, `{}` describes the order of the preceding liberal	`\d{3}` searches for three digits, `.{10}` for any character sequence of length 10.
`{X,Y}`	Occurs between X and Y times,	`\d{1,4}` means `\d` must occur at least once and at a maximum of four.
`*?`	`?` after a quantifier makes it a reluctant quantifier. It tries to find the smallest match. This makes the regular expression stop at the first match.

Grouping and back reference

We can group parts of regular expression. In pattern we group elements with round brackets, e.g., (). This allows us to assign a repetition operator to a complete group.

In addition, these groups also create a back reference to the part of the regular expression. This captures the group. A back reference stores the part of the String which matched the group. This allows you to use this part in the replacement.

Via the $ you can refer to a group. $1 is the first group, $2 the second, etc.

Let’s, for example, assume we want to replace all whitespace between a letter followed by a point or a comma. This would involve that the point or the comma is part of the pattern. Still it should be included in the result.

// Removes whitespace between a word character and . or ,String pattern = "(\\w)(\\s+)([\\.,])";System.out.println(DATA.replaceAll(pattern, "$1$3"));

This example extracts the text between a title tag.

// Extract the text between the two title elementspattern = "(?i)(<title.*?>)(.+?)()";String updated = EXAMPLE_TEST.replaceAll(pattern, "$2");

Negative look ahead

It provides the possibility to exclude a pattern. With this we can say that a string should not be followed by another string.

Negative look ahead are defined via (?!pattern). For example, the following will match "a" if "a" is not followed by "b".

a(?!b)

Specifying modes inside the regular expression

We can add the mode modifiers to the start of the regex. To specify multiple modes, simply put them together as in (?ismx).

· (?i) makes the regex case insensitive.

· (?s) for "single line mode" makes the dot match all characters, including line breaks.

· (?m) for "multi-line mode" makes the caret and dollar match at the start and end of each line in the subject string.

Backslashes in Java

The backslash \ is an escape character in Java Strings. That means backslash has a predefined meaning in Java. You have to use double backslash \\ to define a single backslash. If you want to define \w, then you must be using \\w in your regex. If you want to use backslash as a literal, you have to type \\\\ as \ is also an escape character in regular expressions.

What are regular expressions or regex?

Akram Interview Questions , Java

What are regular expressions or regex in Java?

Regular expressions define a search pattern for strings in Java. The abbreviation for regular expression is called as regex. The search pattern, it can be anything from a simple character or a fixed string or a complex expression and it can contain special characters describing the pattern. The pattern defined by the regex may match one or several times or not at all for a given string.

Regular expressions can be used to search, edit and manipulate text.

The process of analyzing or modifying a text with a regex is called: The regular expression is applied to the text/string. The pattern defined by the regex is applied on the text from left to right. Once a source character has been used in a match, it cannot be reused. For example, the regex aba will match ababababa only two times (aba_aba__).

Regex examples

A simple example for a regular expression is a (literal) string. For example, the Hello World regex matches the "Hello World" string. . (dot) is another example for a regular expression. A dot matches any single character; it would match, for example, "a" or "1".

The following tables lists several regular expressions and describes which pattern they would match.

Table 1. Regex example
Regex	Matches
this is text	Matches exactly "this is text"
this\s+is\s+text	Matches the word "this" followed by one or more whitespace characters followed by the word "is" followed by one or more whitespace characters followed by the word "text".
^\d+(\.\d+)?	^ defines that the patter must start at beginning of a new line. \d+ matches one or several digits. The ? makes the statement in brackets optional. \. matches ".", parentheses are used for grouping. Matches for example "5", "1.5" and "2.21".

How to disable Spring banner

Akram Interview Questions , SpringBoot

How to disable Spring banner?

You can disable the spring boot banner by adding the below mentioned code in your main method.

app.setBannerMode(Banner.Mode.OFF);

Just add the above mentioned code in main method and spring banner will be disabled.

What is @SpringBootApplication in Spring Boot

Akram Interview Questions , Java

What is @SpringBootApplication in Spring Boot?

"Indicates a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. This is a convenience annotation that is equivalent to declaring @Configuration, @EnableAutoConfiguration and @ComponentScan."

If you are using spring boot version below 1.2 than you need to add the below annotation in your application.

@Configuration to enable Java-based configuration and mark your class a Configuration class.
@ComponentScan to enable component scanning so that controllers and other components will automatically discovered and registered as bean in Spring's Application Context.
@EnableAutoConfiguration to enable Spring Boot's auto-configuration feature.

But if you using spring boot 1.2 or above version, you just need to add the @SpringBootApplication annotation in your main class and your main class should be in your base package.

@SpringBootApplication = @Configuration + @ComponentScan + @EnableAutoConfiguration

Selection Sort in Java

Akram Interview Questions , Sorting Algorithm

Selection Sort in Java

The selection sort is the improvement over bubble sort by making only one exchange for every pass through the list.

In this algorithm, find the smallest element from an unsorted list in each iteration and place that element at beginning of the list.

Or find the largest element from an unsorted list in each iteration and place that element at the end of the list.

How Selection Sort Works?

1. Lets take and list as mentioned below and take the first element as minimum

2. Compare first element with the second element is the second element is smaller than first then assign second element to minimum. Compare minimum with the third element and if the third element is smaller than minimum then assign thirst variable to minimum. The process goes on until the last element.

3. After each iteration, minimum placed at the beginning of unsorted list by swapping.

4. For each iteration, indexing start from the first unsorted element. Step 1 and 3 are repeated until all the elements are placed at their correct positions.

5. And the selection is sort all the elements by using above steps in recursive method.

 // Selection sort in Java
import java.util.Scanner;
class SelectionSort {
  void selectionSort(int array[]) {
    int size = array.length;
    for (int step = 0; step < size - 1; step++) {
      int min_idx = step;
      for (int i = step + 1; i < size; i++) {
        if (array[i] < array[min_idx]) {
          min_idx = i;
        }
      }
      int temp = array[step];
      array[step] = array[min_idx];
      array[min_idx] = temp;
    }
  }
  void printArray(int array[]) {
    int size = array.length;
    for (int i = 0; i < size; ++i)
      System.out.print(array[i] + " ");
    System.out.println();
  }
  public static void main(String args[]) {
    int[] data = { 20, 12, 10, 15, 2 };
    SelectionSort ss = new SelectionSort();
    ss.selectionSort(data);
    System.out.println("Sorted Array in Ascending Order: ");
    ss.printArray(data);
  }
}

Complexity

Now lets talk about the complexity of selection sort.

Complexity = O(n2)

Also, we can analyze the complexity by simply observing the number of loops. There are 2 loops so the complexity is O(n*n) = O(n²). So the complexity of this algorithm is O(n*n) = O(n2 ). This is the worst case complexity.

Where we can use bubble sort?

The selection sort is used when:

1. small list is to be sorted

2. cost of swapping does not matter

3. checking of all the elements is compulsory

4. cost of writing to a memory matters like in flash memory (number of writes/swaps is O(n) as compared to O(n2) of bubble sort)

What are the rules of writing regular expressions in Java?

What are the rules of writing regular expressions?

Meta characters

What are regular expressions or regex?

How to disable Spring banner

What is @SpringBootApplication in Spring Boot

Selection Sort in Java

How Selection Sort Works?

Search This Blog

Popular

Categories

Blog Archive

Tags

Popular Posts