Welcome to Vertx (Era of reactive programming)

Working on Article...

Two Spring Boot application communicate over single ActiveMQ(embedded/external) broker

Two spring boot application over single Active-MQ broker  

How can use HashSet to solve Array related Problems

Today I was solving some array related problems on GeeksForGeeks,

Came across with solution How Hashset helped me to solve these problems for large amount of input within given time complexity.

Here is the problem statements I have solved:-

Problem Statement:- Pair with given sum in a sorted array

Solution :-

import java.util.*;
import java.lang.*;
import java.io.*;

class GFG {
    public static void main (String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        while(T --> 0){
            int N = Integer.parseInt(br.readLine());
           
            String str = br.readLine();
            String[] inputArr = str.trim().split("\\s+");
            int A[] = new int[N];
            for(int i=0;i<N;i++){
                A[i] = Integer.parseInt(inputArr[i]);
            }
            int K = Integer.parseInt(br.readLine());
           
            int low = 0;
            int high = N-1;
            boolean flag = true;
            while(low<high){
                if(A[low]+A[high] > K){
                    high--;
                }else if(A[low]+A[high] < K){
                    low++;
                }else{
                    System.out.println(A[low]+" "+A[high] + " "+ K);
                    low++;
                    flag = false;
                }
            }
            if(flag){
                System.out.println(-1);
            }           
        }
    }
}

Problem Statement:- Triplet Sum in Array

Solution :-

import java.util.*;
import java.lang.*;
import java.io.*;

class GFG {
    public static void main (String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        while(T --> 0){
            String input = br.readLine();
            String[] inputArry = input.trim().split("\\s+");
            int N = Integer.parseInt(inputArry[0]);
            int X = Integer.parseInt(inputArry[1]);
            String arrInp = br.readLine();
            String[] arr = arrInp.trim().split("\\s+");
            int[] A = new int[N];
            for(int i=0;i<N;i++){
                A[i] = Integer.parseInt(arr[i]);
            }
            Set<Integer> sumSet = new HashSet<>();
            boolean flag= true;
            for(int i=0;i<N;i++){
                if(sumSet.contains(X-A[i])){
                    System.out.println("1");
                    flag = false;
                    break;
                }else{
                    for(int j=0;j<=i;j++){
                        sumSet.add(A[i]+A[j]);
                    }
                }
            }
            if(flag){
                System.out.println("0");
            }
        }
    }
}

First non repeating word in string.

public String firstNonRepeatingword(String string) {
        if(string == null || string.isEmpty()) {
            return "No unique word found";
        }else {
            StringTokenizer tokens = new StringTokenizer(string);
            LinkedList<String> list = new LinkedList<>();
            while(tokens.hasMoreTokens()) {
                list.add(tokens.nextToken());
            }
            for(int i=0;i<list.size();i++) {
                if (Collections.frequency(list,list.get(i)) == 1) {
                    return list.get(i);
                }
            }
        }
        return "No unique word found";
    }

It's up to you how are you spliting the string there are many ways, If you have small string tokenizer is fast.

Performance of StringTokenizer class vs. String.split method vs indexOf 

Difference between final and effectively final

final variable: A variable or parameter is declared as final and whose value is never changed after it is initialized is final.

effectively final variable: A variable or parameter is not declared as final and still the whose value is never changed after it is initialized is effectively final.

public class Demo {
 public static void main(String[] args) {
 int count = 0;
 List list = new ArrayList() {{
    add("employee1"); 
    add("employee2"); 
    add("employee3"); 
    add("employee4"); 
 }}; 
 list.stream().forEach(str -> { count++; });
 } 
}

here the error on count++ :-

Local variable count defined in an enclosing scope must be final or effectively final.

here the variable count is not declared as final but it is still a final variable and its value will not be changed, the count varibale here is effectively final variable

Prefer to return empty Object instead of null

There are many cases in which we can return an empty object instead of null. This is usually preferable since it helps to eliminate one of the most common problem: NullPointerException

Following qualify as empty object :

• Empty String
• zero-length Array
• empty collection

Examples for empty object:-

• String str = "";
• int[] values = new int[0];
• List<Integer> list = new ArrayList<>();

Collections class contains several type-safe methods which return an empty collection

Collections.emptyList();

Collections.emptySet();

Collections.emptyMap();

by default, these methods are also immutable and serializable.

Double Brace initialization

It creates an anonymous class derived from the specified class (the outer braces), and provide an initializer block within that class (the inner braces). e.g.

new ArrayList() { { 
   add("you"); 
   add("me"); 
} }