System.out.println("Null string: " + "".length());

for (type variableName : arrayName) {
  // code block to be executed
}

import java.util.SortedSet; 
import java.util.TreeSet; 

public class HelloWorld{
     public static void main(String []args){
        int[] a = {1, 2, 6};
        a[0] = 1;
        // Create a TreeSet and inserting elements 
        SortedSet<Integer> s = new TreeSet<>(); 
  
        // Adding Element to SortedSet 
        s.add(1); 
        s.add(5); 
        s.add(2); 
        s.add(3); 
        s.add(9); 
  
        // Returning the lowest element from set 
        System.out.print("Lowest element in set is : " + s + "\n");
                         
        System.out.println("Hello World " + a[0]);
        System.out.println("Hello World");
     }
}

Lowest element in set is : [1, 2, 3, 5, 9]
Hello World 1
Hello World

import java.util.SortedSet; 
import java.util.TreeSet; 
import java.util.Set;

public class HelloWorld{
     public static void main(String []args){
        int[] a = {1, 2, 6};
        a[0] = 1;
        
        Set<String> ts1 = new TreeSet<>();
 
        // Elements are added using add() method
        ts1.add("A");
        ts1.add("B");
        ts1.add("C");
 
        // Duplicates will not get insert
        ts1.add("C");
 
        // Elements get stored in default natural
        // Sorting Order(Ascending)
        System.out.println(ts1);
     }
}

// [A, B, C]

package com.codebyhan2;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public int[] twoSum(int[] numbers, int target) {
        int[] result = new int[2];
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < numbers.length; i++) {
            if (map.containsKey(target - numbers[i])) {
                result[1] = i;
                result[0] = map.get(target - numbers[i]);
                return result;
            }
            map.put(numbers[i], i);
        }
        return result;
    }

    public static void main(String[] args) {
        /* initialize the value */
        Main m = new Main();
        System.out.println(m.sum(10, 20));

        int[] result = new int[2];
        result = m.twoSum(new int[]{1, 2, 3, 6, 10}, 16);
        System.out.println("What is the result: " + Arrays.toString(result));
    }
}

30
What is the result: [3, 4]

public class Solution {
    public int reverse(int x) {
        long result =0;
        while(x != 0)
        {
            result = (result*10) + (x%10);
            if(result > Integer.MAX_VALUE) return 0;
            if(result < Integer.MIN_VALUE) return 0;
            x = x/10;
        }
        return (int)result;
        
        
    }
}

public int reverse(int x) {
  	if (x == Integer.MIN_VALUE)
  		return 0;
  	boolean minus = false;
  	if (x < 0){
  		x = Math.abs(x);
  		minus = true;
  	}
    long temp = 0;
    while(x != 0){
    	temp *= 10;
    	if (temp > Integer.MAX_VALUE || temp < Integer.MIN_VALUE)
    		return 0;
    	temp +=  x%10;
    	x /= 10;
    }
    if (minus)
    	return (int)(-temp);
    return (int)temp;
}

public class Solution {
    public int titleToNumber(String s) {
        if (s == null) return -1;
        int sum = 0;
        // for each loop so we don't need to mess with index values.
        for (char c : s.toUpperCase().toCharArray()) {
            sum *= 26;
            sum += c - 'A' + 1;
        }
        return sum;
    }
}

class Solution 
{
    public int fib(int N)
    {
        if(N <= 1)
            return N;
        
		int a = 0, b = 1;
		
		while(N-- > 1) {
			int sum = a + b;
			a = b;
			b = sum;
		}
        return b;
    }
}

class Solution 
{
    public int fib(int N)
    {
        if(N <= 1)
            return N;
        else
            return fib(N - 1) + fib(N - 2);
    }
}

class Solution 
{
    public int fib(int N) {
      return (N <= 1) ? N : fib(N - 1) + fib(N - 2);
    }
}

class Solution 
{
    int[] fib_cache = new int[31];
	
	public int fib(int N)
    {
        if(N <= 1)
            return N;
        else if(fib_cache[N] != 0)
            return fib_cache[N];
		    else 
            return fib_cache[N] = fib(N - 1) + fib(N - 2);
    }
}

class Solution 
{
    public int fib(int N)
    {
        if(N <= 1)
            return N;

		    int[] fib_cache = new int[N + 1];
		    fib_cache[1] = 1;
    
		    for(int i = 2; i <= N; i++)
		    {
		    	fib_cache[i] = fib_cache[i - 1] + fib_cache[i - 2];
		    }
		    return fib_cache[N];
    }
}

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s.length()==0) return 0;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int max=0;
        for (int i=0, j=0; i<s.length(); ++i){
            if (map.containsKey(s.charAt(i))){
                j = Math.max(j,map.get(s.charAt(i))+1);
            }
            map.put(s.charAt(i),i);
            max = Math.max(max,i-j+1);
        }
        return max;
    }
}