list methods example

package com.concretepage;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

public class Listmethods{
public static void main(String[] args) {

LinkedList<String> list = new LinkedList<String>();
list.add("A");
list.add("B");

list.addFirst("D");
list.add(2,"E");
list.addLast("C");
list.add("F");
list.add("G");

System.out.println("Linked List " + list);
System.out.println(list.size());
String returns = list.get(2);
System.out.println(returns);

Collection<String> ref = new ArrayList<String>();
ref.add("H");
ref.add("I");
ref.add("J");
ref.add("K");
ref.add("L");
list.addAll(1,ref);
System.out.println(list);
}
}

Collections.addAll example

package com.concretepage;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class TestOneYes {
public static void main(String[] args) {

List<String> list = new ArrayList();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
list.add("F");
boolean b = Collections.addAll(list, "1", "2", "3");
System.out.println(b);
System.out.println("arrayList after Operation " + list);

}
}

Collectors.toList() example

package com.concretepage;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class TestOneTwo {
public static void main(String[] args) {

String a[] = new String[] {"A", "B", "C", "D", "E", "F", "G", "H", "B", "C"};
List<String> ref = Arrays.asList(a);
System.out.println(ref);

       // input list with duplicates
        List<Integer> list = new ArrayList<>(
            Arrays.asList(1, 10, 1, 2, 2, 3, 10, 3, 3, 4, 5, 5));
            // Print the Arraylist
        System.out.println("ArrayList with duplicates: "
                           + list);
 
        // Construct a new list from the set constucted from elements
        // of the original list
        List<Object> newList = list.stream().distinct().collect(Collectors.toList());
        // Print the ArrayList with duplicates removed
        System.out.println("ArrayList with duplicates removed: " + newList);
       
        System.out.println();System.out.println();System.out.println();
        Stack<String> reference = new Stack<>();
        reference.push("A");
        reference.push("B");
        reference.push("C");
        reference.push("D");
        reference.push("E");
       
        System.out.println("The elements at the top of stack is 1 " + reference.pop());
        System.out.println("The elements at the top of stack is 2 " + reference.peek());
        System.out.println("The elements at the top of stack is 3 " + reference.peek());
        System.out.println("The elements at the top of stack is 4 " + reference);

}
}

arraylist indexOf, lastIndexOf example

package com.concretepage;

import java.util.ArrayList;

public class TestOneFour {
public static void main(String[] args) {
    ArrayList<Object> ref = new ArrayList<>();
    ref.add(1);ref.add(2);ref.add("Three");ref.add(4);ref.add(5);
    ref.add(6);ref.add("Seven");ref.add("Three");ref.add("Three");ref.add(8);ref.add(9);
    System.out.println(ref.indexOf("Three"));
    System.out.println(ref.lastIndexOf("Three"));
    System.out.println(ref.indexOf("Seven"));
}
}

>> operator example

package com.concretepage;
public class Test {
public static void main(String args[])  {
   int a = 10;
   System.out.println(a+a>>1); 
}
}

subclass parent constructor protected example

package com.concretepage;
public class SubClassParentConstructorProtected {
public static void main(String[] args) {
SubClassParentConstructorProtected sub = new SubClassParentConstructorProtected();
ParentConstructorProtected pub = new ParentConstructorProtected();
}
}

subclass example

package com.concretepage;
class SuperClass {
void method1() {
System.out.println("i am method1 of superclass");
}
void method2() {
System.out.println("i am method2 of superclass");
}
void method3() {
System.out.println("i am method3 of superclass");
}
}
public class SubClass extends SuperClass {
void method1() {
System.out.println("i am method1 of subclass");
}
void method2() {
System.out.println("i am method2 of subclass");
}
void method3() {
System.out.println("i am method3 of subclass");
}
public static void main(String[] args) {
SuperClass superclass = new SuperClass();
superclass.method1();
superclass.method2();
superclass.method3();
}
}

subclass of abstract class example

package com.concretepage;

public abstract class SubAbstractClass extends Abstractclass {

@Override
void method3() {
// TODO Auto-generated method stub
super.method3();
}
public static void main(String[] args) {
// TODO Auto-generated method stub

}

@Override
void method2() {
// TODO Auto-generated method stub

}

}

package com.concretepage;

public abstract class Abstractclass {

abstract void method1();

abstract void method2();

void method3() {

System.out.println("hi i am from method3");

}

}

reducing the visibility of the overriddenmethod subclass

package com.concretepage;
public class ReducingtheVisibilityOftheOverriddenMethod {

public void method1() {
System.out.println("I am inside method1");
}

}


package com.concretepage;
public class ReducingtheVisibilityOftheOverriddenMethodSubClass extends ReducingtheVisibilityOftheOverriddenMethod {
private void method1() {
}
}

overriding static methods example

package com.concretepage;
public class OverridingStaticMethods {
public static void method1() {
System.out.println("I am inside method1");
}
public static void method1(String a) {
    System.out.println("I am inside method1 of String2 " + a);
}
void method2() {
System.out.println("I am inside method2");
}
public static void main(String[] args) {
method1();
method1("Additional Comments");
}
}

overriding static methods subclass example

package com.concretepage;

public class OverridingStaticMethodsSubClass extends OverridingStaticMethods {
public void method1() {
}
@Override
void method2() {
// TODO Auto-generated method stub
super.method2();
}
}


package com.concretepage;
public class OverridingStaticMethods {
public static void method1() {
System.out.println("I am inside method1");
}
public static void method1(String a) {
    System.out.println("I am inside method1 of String2 " + a);
}
void method2() {
System.out.println("I am inside method2");
}
public static void main(String[] args) {
method1();
method1("Additional Comments");
}
}

parent constructor protected example

package com.concretepage;
public class ParentConstructorProtected {
protected ParentConstructorProtected() {
}
}

overloaded constructor compilation error

package com.concretepage;

public class OverloadConstructor {
/*
public OverloadConstructor() {
}*/
public OverloadConstructor(String a) {
System.out.println("Overloaded Constructors Value is " + a);
}
public static void main(String[] args) {
OverloadConstructor overloadConstructor1  = new OverloadConstructor("String");
OverloadConstructor overloadConstructor2  = new OverloadConstructor();
}
}

vector elementAt, hashtable.get example

package com.concretepage;

import java.util.Hashtable;
import java.util.Vector;

public class NewTest {

public static void main(String[] args) {

int arr[] = new int[] {1,2,3,4};
Vector<Integer> vector = new Vector();
Hashtable<Integer,String> hashtable = new Hashtable();
vector.addElement(1);
vector.addElement(2);
hashtable.put(1,"GODS");
hashtable.put(2, "OF");
hashtable.put(3, "I WILL");

System.out.println(arr[0]);
System.out.println(vector.elementAt(0));
System.out.println(vector.size());
System.out.println(hashtable.get(2));

}

}

System.arraycopy example

package com.concretepage;
import java.lang.*;
public class NewClass
{
 public static void main(String[] args)
 {
     int s[] = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
     int d[] = { 15, 25, 35, 45, 55, 65, 75, 85, 95, 105};

     int source_arr[], sourcePos, dest_arr[], destPos, len;
     source_arr = s;
     sourcePos = 3;
     dest_arr = d;
     destPos = 5;
     len = 3;
   

     // Print elements of source
     System.out.print("source_array : ");
     for (int i = 0; i < s.length; i++)
         System.out.print(s[i] + " ");
     System.out.println("");

     System.out.println("sourcePos : " + sourcePos);
     
     // Print elements of source
     System.out.print("dest_array : ");
     for (int i = 0; i < d.length; i++)
         System.out.print(d[i] + " ");
     System.out.println("");
     
     System.out.println("destPos : " + destPos);
     
     System.out.println("len : " + len);
     
     // Use of arraycopy() method
     System.arraycopy(source_arr, sourcePos, dest_arr, 
                                         destPos, len);
     
     // Print elements of destination after
     System.out.print("final dest_array : ");
     for (int i = 0; i < d.length; i++)
         System.out.print(d[i] + " ");
 }
}

Multiple ArrayList of ArrayLists example

package com.concretepage;
import java.util.*;
public class MultipleArrayListOfArrayListsJava {
public static void main(String[] args) {

ArrayList<ArrayList<String>> arrayListBasicExample = new ArrayList<ArrayList<String>>();

ArrayList<ArrayList<ArrayList<String>>> arrayListMain = new ArrayList<ArrayList<ArrayList<String>>>();
ArrayList<ArrayList<String>> arrayList1 = new ArrayList<ArrayList<String>>();

ArrayList<String> arrayList1Sub1 = new ArrayList<String>();
arrayList1Sub1.add("Balaji"); arrayList1Sub1.add("Padma");
arrayList1Sub1.add("Appa"); arrayList1Sub1.add("Amma");
arrayList1.add(arrayList1Sub1);
arrayListMain.add(arrayList1);
ArrayList<String> arrayList1Sub2 = new ArrayList<String>();
arrayList1Sub2.add("BALAJI");   arrayList1Sub2.add("PADMA");
arrayList1Sub2.add("APPA");     arrayList1Sub2.add("AMMA");
arrayList1.add(arrayList1Sub2);
arrayListMain.add(arrayList1);

for(int i=0;i<arrayListMain.size();i++) {
System.out.println("arrayListMain Size is " + arrayListMain.size());
for(int j=0;j<arrayList1.get(i).size();j++) {
System.out.println("arrayList1.get(i).size is " + arrayList1.get(i).size());
System.out.println("arrayList1.get(i).get(j) is " + arrayList1.get(i).get(j));
}
}

}
}

Lambda example

package com.concretepage;
import java.util.HashMap;
import java.util.Map;
public class MapLamdaTest {
    public static void main(String[] args) {
        Map<String, Boolean> booleanMap = new HashMap<String, Boolean>(2);
        booleanMap.put("A", Boolean.valueOf("true"));booleanMap.put("B", Boolean.FALSE);booleanMap.put("C", Boolean.TRUE);
        booleanMap.put("D", true);booleanMap.put("E", Boolean.valueOf("true"));booleanMap.put("F", Boolean.valueOf("false"));
        System.out.println("Hashmap created, here are the values");
        // Print out the map
        booleanMap.forEach((m, l) -> System.out.println(m + " " + l));
        booleanMap.replaceAll((m,l) -> Boolean.FALSE);
        System.out.println("Hashmap replaceAll, here are the values");
        long startTime = System.currentTimeMillis();
        // Print out the modified values
        booleanMap.forEach((m,l) -> System.out.println(m + " " + l));
        long stopTime = System.currentTimeMillis();
        System.out.println("Replace took time " + (stopTime-startTime));
    }
}

Complex example, he he he :)

package com.concretepage;
public class Main {
public static void main(String[] args) {
Complex complex1 = new Complex(10, 15);
Complex complex2 = new Complex(complex1);
Complex complex3 = complex2;
System.out.println(complex2);
}
}
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
package com.concretepage;
public class Complex {
private double re, im;
public Complex(double re, double im) {
this.re = re;
this.im = im;
}
    Complex(Complex c){
    System.out.println("Copy Constructor called");
    re = c.re;
    im = c.im;
    }
    @Override
    public String toString() {
    return "(" + re + " + " + im + "i)";
    } 
}

list of arrays example

package com.concretepage;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map.Entry;
import java.util.Set;

public class ListOfArrays {
public static void main(String[] args) {

List<String[]> list = new ArrayList<String[]>();
String[] s1 = {"A","B","C"};
String[] s2 = {"D","E","F"};
list.add(s1);
list.add(s2);
for(String ref[] : list) {
System.out.println(Arrays.toString(ref));
}    
String[] s1ArrayObject = new String[]{"a","b","c"};
String[] s2ArrayObject = new String[]{"d","e","f"};
HashMap<String[],String[]> hmap = new HashMap();
hmap.put(s1ArrayObject,s2ArrayObject);
Set<Entry<String[], String[]>> ref = hmap.entrySet();
ArrayList<Entry<String[], String[]>> arrayListReference = new ArrayList<>(ref);
Iterator<Entry<String[], String[]>> refIterator = arrayListReference.iterator();
while(refIterator.hasNext()) {
Entry<String[],String[]> refIteratorAgain = refIterator.next();
String[] keyValue = refIteratorAgain.getKey();
String[] valueIs  = refIteratorAgain.getValue();
System.out.println("keyValue is " + Arrays.toString(keyValue));
System.out.println("value is    " + Arrays.toString(valueIs));
}

HashMap<String[], String[]> hmapReferenceAgain = new HashMap<>();
hmapReferenceAgain.put(new String[]{"a","b","c"}, new String[]{"d","e","f"});
hmapReferenceAgain.put(new String[]{"g","h","i"}, new String[]{"j","k","l"});
hmapReferenceAgain.put(new String[]{"m","n","o"}, new String[]{"p","q","r"});
hmapReferenceAgain.put(new String[] {"s","t","u"}, new String[] {"v","w","x"});

Collection<String[]> StringArrayReferece  = hmapReferenceAgain.values();
ArrayList<String[]> arrayList = new ArrayList<String[]>(StringArrayReferece);
Iterator<String[]> referenceAgain = arrayList.iterator();
while(referenceAgain.hasNext()) {
System.out.println(Arrays.toString(referenceAgain.next()));
}
ArrayList<String[]> arrayListReferenceAgain = new ArrayList<String[]>(StringArrayReferece);
ListIterator<String[]> referenceAgainNow = arrayListReferenceAgain.listIterator();
while(referenceAgainNow.hasNext()) {
System.out.println(Arrays.toString(referenceAgainNow.next()));
}
System.out.println();
List<Integer> listNow = new ArrayList<Integer>();
listNow.add(1);
listNow.add(2);
listNow.add(3);
listNow.add(4);
listNow.add(5);
Object[] referenceArrayList = listNow.toArray();
    for(Object obj : referenceArrayList) {
    System.out.println(obj);
    }
    System.out.println();   
    /*
    Integer[] array = new Integer[listNow.size()];
    array = listNow.toArray(array);
    for(Integer i : array) {
    System.out.println(i);
    }*/    
    Integer[] referenceList = new Integer[listNow.size()];
    for(int k=0;k<referenceList.length;k++) {
    System.out.println(referenceList[k]);
    }
   
    referenceList = listNow.toArray(referenceList);
    for(Integer i : referenceList) {
    System.out.println("i Value is " + i);
    }
}
}

List SplitIterator example

package com.concretepage;
import java.lang.ref.Reference;
import java.util.ArrayList;
import java.util.List;
import java.util.Spliterator;

public class ListNowSplitIterator {
public static void main(String[] args) {

List l1 = new ArrayList();
l1.add(1);
l1.add(2);
l1.add(3);
l1.add(4);

Spliterator<String> reference = l1.spliterator();
System.out.println(reference.estimateSize());
System.out.println(reference.getExactSizeIfKnown());

}
}

List as array java

package com.concretepage;
import java.util.ArrayList;
import java.util.List;

public class ListArrayJava {
public static void main(String[] args) {

List<String> l1 = new ArrayList<>();
l1.add("One"); l1.add("Two");
l1.add("Three"); l1.add("Four");

List<String> l2 = new ArrayList<>();
l2.add("OneAgain"); l2.add("TwoAgain");
l2.add("ThreeAgain"); l2.add("FourAgain");

List<String>[] listArray = new List[2];
listArray[0] = l1;
listArray[1] = l2;

for(int i = 0; i<listArray.length; i++) {
System.out.println(listArray[i]);
}
}
}

interface methods as private

package com.concretepage;
public interface InterfaceMethodsAsPrivate {
abstract void method1();
}

What will happen if you import a package twice ?

package com.concretepage;
import java.lang.*;
import java.lang.*;

public class ImportingTheJavaLangPackageTwice {
public static void main(String[] args) {
       System.out.println("I have exploded Out of this Package");
}
}

Answer :
-----------
Well nothing will happen

HashMap to CharArray example

package com.concretepage;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Iterator;
import java.util.LinkedHashMap;
public class HashMaptoCharArray {
public static void main(String[] args) {
HashMap hmap = new LinkedHashMap<>();
hmap.put("One", "1");hmap.put("Two", "2");
hmap.put("Three", "3");hmap.put("Four","4");
hmap.remove("One", "1");
Set<Entry<String, String>> reference = hmap.entrySet();
Iterator<Entry<String, String>> iterator1 = reference.iterator();
while(iterator1.hasNext()) {
Entry<String, String> entry1 = iterator1.next();
System.out.print(entry1.getValue());System.out.print(" ");System.out.print(entry1.getKey());
System.out.println();
}
System.out.println("************************************************************************");

//hmap.remove("Two");
//hmap.remove("Two","2");
//hmap.replace("Two", "22");
//hmap.replace("Two", "2", "22000rs");
Set<Entry<String, String>> referenceAgain = hmap.entrySet();
Iterator<Entry<String, String>> iterator2 = referenceAgain.iterator();
while(iterator2.hasNext()) {
Entry<String, String> entry2 = iterator2.next();
System.out.print(entry2.getValue());System.out.print(" ");System.out.print(entry2.getKey());
System.out.println();
}
System.out.println("************************************************************************");
}
}

HashMap to ArrayList Example

package com.concretepage;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapToArrayListExample {

public static void main(String[] args) {

        HashMap<String, String> studentPerformanceMap = new HashMap<String, String>();
        //Adding elements to HashMap
        studentPerformanceMap.put("John Kevin", "Average");
        studentPerformanceMap.put("Rakesh Sharma", "Good");
        studentPerformanceMap.put("Prachi D", "Very Good");       
        studentPerformanceMap.put("Ivan Jose", "Very Bad");
        studentPerformanceMap.put("Smith Jacob", "Very Good");
        studentPerformanceMap.put("Anjali N", "Bad");
       
        //Getting Set of keys
       
        Set<String> keySet = studentPerformanceMap.keySet();
ArrayList<String> listOfKeyValues = new ArrayList<String>(keySet);
for(String keys : listOfKeyValues) {
//System.out.println(keys);
}

Collection<String> ref = studentPerformanceMap.values();
    ArrayList<String> values1 = new ArrayList<String>(ref);
    for(String values2 : values1) {
    System.out.println(values2);
    }

Set<Entry<String,String>> home = studentPerformanceMap.entrySet();
ArrayList<Entry<String, String>> homeRef = new ArrayList<Entry<String,String>>(home);

for(Entry<String, String> reference : homeRef) {
System.out.println("reference.getKey " +reference.getKey() + "--" + reference.getValue());
}

}


}

HashMap putIfAbsent example

package com.concretepage;
import java.util.HashMap;
public class HashMapPutIfAbsentExample {
public static void main(String[] args) {
HashMap<Integer, String> map = test();
String mapAgain = map.putIfAbsent(4,"Five");
System.out.println(mapAgain);
String result = map.putIfAbsent(73654,"Darwin Bocalbos");
System.out.println(result);
}
private static HashMap<Integer, String> test(){
HashMap<Integer,String> hmapAgain = new HashMap();
hmapAgain.put(1,"One");
hmapAgain.put(2,"Two");
hmapAgain.put(3,"Three");
hmapAgain.put(4,"Four");
hmapAgain.put(73654,"Shyras Travels");
return hmapAgain;
}
}

HashMapofHashMapValue example

package com.concretepage;
import java.util.*;
import java.util.Map.Entry;

public class HashMapofHashMapValue {
public static void main(String[] args) {
HashMap hmap = new HashMap();
hmap.put("One", "ABCD"); hmap.put("Two", "EFGH");
hmap.put("Three", "IJKL");  hmap.put("Four", "MNOP");
HashMap<String, HashMap> hmapObject = new HashMap<>();
hmapObject.put("One-One", hmap);
System.out.println(hmapObject.get("One-One"));
Set<Entry<String, HashMap>> reference = hmapObject.entrySet();
Iterator<Entry<String, HashMap>> referenceIterator = reference.iterator();
while(referenceIterator.hasNext()) {
Entry<String, HashMap> entry = referenceIterator.next();
System.out.println(entry.getKey());
System.out.println(entry.getValue());
HashMap hmapObjectValue = entry.getValue();
System.out.print(hmapObjectValue.get("One")+" ");
System.out.print(hmapObjectValue.get("Two")+" ");
System.out.print(hmapObjectValue.get("Three")+" ");
System.out.print(hmapObjectValue.get("Four")+" ");
}
System.out.println();
HashMap hmapSecondObject = new HashMap();
hmapSecondObject.put("One", "ABCD");
hmapSecondObject.put("Two", "EFGH");
hmapSecondObject.put("Three","IJKL");
hmapSecondObject.put("Four", "MNOP");
HashMap<String, HashMap<String, ArrayList>> hmapObjectsSecondObject = new HashMap<>();
hmapObjectsSecondObject.put("One-One", hmapSecondObject);
System.out.println("hmapObjectsSecondObject Value is " + hmapObjectsSecondObject.get("One-One"));

HashMap hmapThirdObject = new LinkedHashMap<>();
List a1 = new ArrayList();
a1.add("ABCD");a1.add("EFGH");a1.add("IJKL");a1.add("MNOP");
hmapThirdObject.put("One", a1);hmapThirdObject.put("Two", a1);
hmapThirdObject.put("Three", a1);hmapThirdObject.put("Four", a1);
HashMap<String, HashMap<String, ArrayList>> hmapObjectsThirdObject = new HashMap<>();
hmapObjectsThirdObject.put("One-One", hmapThirdObject);
System.out.println("hmapObjectsThirdObject Value is " + hmapObjectsThirdObject.get("One-One"));
HashMap hmapObjectsThirdObjectReference = hmapObjectsThirdObject.get("One-One");
Set<Entry<String, ArrayList>> set = hmapObjectsThirdObjectReference.entrySet();
Iterator<Entry<String, ArrayList>> itr = set.iterator();
while(itr.hasNext()) {
Entry<String, ArrayList> itrReference = itr.next();
System.out.println(itrReference.getKey());
System.out.println(itrReference.getValue());
Iterator objectValue = itrReference.getValue().iterator();
while(objectValue.hasNext()) {
System.out.println(objectValue.next());
}
}
}
}

HashMap NullKey example

package com.concretepage;
import java.util.HashMap;
public class HashMapNullKey {
public static void main(String[] args) {
HashMap hmap = new HashMap();
hmap.put(null, "1");
System.out.println(hmap.get(null));
}
}

HashMap into ArrayList example

package com.concretepage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapIntoArrayList {
public static void main(String[] args) {
HashMap<String, String> hmap = new HashMap<>();
hmap.put("One", "One");
hmap.put("Two", "Two");
hmap.put("Three", "Three");
hmap.put("Four", "Four");
Set<Entry<String,String>> ref = hmap.entrySet();
ArrayList<Entry<String, String>> refAgainArrayList = new ArrayList<Entry<String, String>>(ref);
Iterator<Entry<String, String>> refIterator = refAgainArrayList.iterator();
while(refIterator.hasNext()) {
     System.out.println("refIterator.next() " + refIterator.next());
}
}
}

HashMap CollectionValues example

package com.concretepage;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
public class HashMapCollectionValues {
public static void main(String[] args) {
HashMap<String, String> hmap = new HashMap<>();
hmap.put("One", "One");
hmap.put("Two", "Two");
Collection<String> ref = hmap.values();
ArrayList<String> arrayListAgain = new ArrayList<>(ref);
Iterator<String> refAgain = arrayListAgain.iterator();
while(refAgain.hasNext()) {
System.out.println(refAgain.next());
}
}
}

HashMap to ArrayList example

package com.concretepage;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapArrayListAgain {

public static void main(String[] args) {
    HashMap<String, String> map = new HashMap<String, String>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
//Getting the Set of entries
Set<Entry<String, String>> entrySet = map.entrySet();
//Creating an ArrayList Of Entry objects
ArrayList<Entry<String, String>> listOfEntry = new ArrayList<Entry<String,String>>(entrySet);


HashMap<String, String> map1 = new HashMap<String, String>();
map1.put("1", "1");
map1.put("2", "2");
map1.put("3", "3");
map1.put("4", "4");
//Getting the Set of entries
Set<Entry<String, String>> entrySet1 = map.entrySet();
//Creating an ArrayList Of Entry objects
ArrayList<Entry<String, String>> listOfEntry1 = new ArrayList<Entry<String,String>>(entrySet);
Iterator itr = listOfEntry1.iterator();
while(itr.hasNext()) {
Object ref = itr.next();
    System.out.println(ref);


}

}

}

HashMap to ArrayList

package com.concretepage;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;

public class HashMapArrayList {

public static void main(String[] args) {


HashMap<String, String> map = new HashMap<String, String>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
//Getting Collection of values from HashMap
       
Collection<String> values = map.values();
       
//Creating an ArrayList of values
       
ArrayList<String> listOfValues = new ArrayList<String>(values);


Iterator itr = listOfValues.iterator();

while(itr.hasNext()) {
System.out.println(itr.next());
}



}


}

vector.subList example

package com.concretepage;

import java.util.*;

public class VectorSubList{
    public static void main(String[] args)
    {
    Vector<String> vector = new Vector<String>();
    vector.add("Welcome");
    vector.add("to");
    vector.add("House");
   
    List<String> list = new ArrayList<String>();
    list = vector.subList(2, 3);
    System.out.println(list);
    }
}

final value into parameter

package com.concretepage;

public class finalValueIntoParameter {

void method1(String j) {
j = j + "1";
System.out.println(j);
}
void method2(final StringBuffer sb) {
StringBuffer sb2 = sb.append("100 again");
//sb2 = sb.append("100 again");
System.out.println(sb);
System.out.println(sb2);
}

public static void main(String[] args) {
    /*
        String str = "journaldev";

//string to char array
char[] chars = str.toCharArray();
System.out.println(chars.length);

//char at specific index
char c = str.charAt(2);
System.out.println(c);

//Copy string characters to char array
char[] chars1 = new char[7];
str.getChars(0, 3, chars1, 0);
System.out.println(chars1);
*/


     
        String s1 = "Welcome to Javatpoint"; 
        char[] ch = s1.toCharArray(); 
        int len = ch.length; 
        System.out.println("Char Array length: " + len); 
        System.out.println("Char Array elements: "); 
        for (int i = 0; i < len; i++) { 
            System.out.println(ch[i]); 
        }
 
/*
finalValueIntoParameter f = new finalValueIntoParameter();
    f.method1("100");
    f.method2(new StringBuffer("121"));
*/




}

}

final method in int

package com.concretepage;
public class finalMethodInInt {
public static void main(String[] args) {
System.out.println(riskyAction(1));
System.out.println("-----------");
System.out.println(riskyAction(2));
}
public static int riskyAction(int greeting){
try{
if(greeting==1) {
System.out.println(greeting + " from try block");
}else{
throw new Exception();
}
System.exit(100);
return 0;
}
catch(Exception e){
System.out.println(greeting + " from catch block");
return 2;
}
finally{
System.out.println("I am fially block");
System.exit(0);
return 3;
}
//return 4;
    }
}

final Method

package com.concretepage;

public class finalMethod {

public static void main(String[] args) {
System.out.println(riskyAction("hello"));
System.out.println("-----------");
System.out.println(riskyAction("howdy"));
}
public static String riskyAction(String greeting){
try{
if(greeting.equals("hello")){
System.out.println(greeting + " from try block");
}else{
throw new Exception();
}
return "returning from try block";
}catch(Exception e){
System.out.println(greeting + " from catch block");
return "returning from catch block";
}finally{
return "returning from finally block";
}
}
}

Copy Constructor example

package com.concretepage;
public class Complex {
private double re, im;
public Complex(double re, double im) {
this.re = re;
this.im = im;
}
    Complex(Complex c){
    System.out.println("Copy Constructor called");
    re = c.re;
    im = c.im;
    }
    @Override
    public String toString() {
    return "(" + re + " + " + im + "i)";
    } 
}

Character to String example

package com.concretepage;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.mapping.Value;

public class CharactertoString {
public static void main(String[] args) {
char[] character = new char[10];
character[0] = 0;  character[1] = 1;
character[2] = 2;  character[3] = 3;
character[4] = 4;  character[5] = 5;
character[6] = 6;  character[7] = 7;
character[8] = 8;  character[9] = 9;
//character[10] = 10;

System.out.println(character.length);

char c = 'S';
System.out.println(String.valueOf(c));
char m = 'M';
System.out.println(Character.toString(m));

for(int k=0;k<character.length;k++) {
System.out.print(character[k]+" ");
}

HashMap<Character, Character> hmap = new HashMap<>();
hmap.put('M', 'N');
hmap.put('O', 'P');

System.out.println();
System.out.println(hmap.get('M'));
System.out.println(hmap.get('O'));


HashMap<String, ArrayList<String>> hmap1 = new LinkedHashMap<>();
ArrayList<String> a1 = new ArrayList<>();
a1.add("1");
a1.add("2");
a1.add("3");
a1.add("4");
hmap1.put("One", a1);hmap1.put("Two", a1);hmap1.put("Three", a1);
hmap1.put("Four", a1);hmap1.put("Five", a1);hmap1.put("Six",  a1);
    System.out.println(hmap1.get("One"));
    System.out.println("hmap1.isEmpty() " + hmap1.isEmpty());
    hmap1.putAll(hmap1);
    System.out.println("hmap1 is " + hmap1);
 
 

}
}

Can static method access instance variables ?

package com.concretepage;
public class CanStaticMethodAccessInstanceVariables {
static void method1() {
CanStaticMethodAccessInstanceVariables can = new CanStaticMethodAccessInstanceVariables();
can.method2();
}
static void method2() {
System.out.println("Its Correct");
}
}

Arrays as List example

package com.concretepage;
import java.util.Arrays;
import java.util.List;

public class ArraysasList {
public static void main(String[] args) {

String a[] = new String[] {"A", "B", "C", "D"};
List<String> listString = Arrays.asList(a);
    System.out.println(listString);
   
    Integer b[] = new Integer[] {10, 20, 30, 40};
    List<Integer> listInteger = Arrays.asList(b);
    System.out.println(listInteger);
   
    //Long l[] = new Long[] {(long) 100, (long) 200, (long) 300, (long) 400};
    Long l[] = new Long[] {100L, 200L, 300L, 400L};
    List<Long> listLong = Arrays.asList(l);
    System.out.println(listLong);
   

}
}

Arrays.copyOf example

package com.concretepage;
import java.util.Arrays;
public class ArraysCopyOf {
public static void main(String[] args) {
int a[] = new int[] {1, 2, 3};
int b[] = Arrays.copyOf(a, 6);
b[3] = 33;
b[4] = 44;
b[5] = 55;
//b[6] = 66;
for(int j=0; j<b.length; j++) {
System.out.println(b[j]);
}

String s1[] = new String[] {"1","2","3"};

String s2[] = Arrays.copyOf(s1, 6);
s2[3] = "33";
s2[4] = "44";
s2[5] = "55";

for(int k=0; k<s2.length; k++) {
System.out.println(s2[k]);
}






}
}

ArrayListOfSubList example

package com.concretepage;
import java.util.*;
import java.util.Map.Entry;
public class ArrayListOfSubList {
public static void main(String[] args) {

List<String> list = new ArrayList();
list.add("1"); list.add("2"); list.add("3");
list.add("4"); list.add("5"); list.add("6");
System.out.println(list.subList(2, 5));
HashMap<String, List<String>> hmap = new HashMap<String, List<String>>();
List<String> listforHashMap = new ArrayList<String>();
listforHashMap.add("1"); listforHashMap.add("2");
listforHashMap.add("3"); listforHashMap.add("4");
listforHashMap.add("5");        listforHashMap.add("6");
hmap.put("One", listforHashMap);
hmap.put("Two", listforHashMap);
List<String> listforHashMapAgain = new ArrayList<String>();
listforHashMapAgain.add("6");   listforHashMapAgain.add("7");
hmap.put("Three",listforHashMapAgain);

Set<String> referenceKeySet = hmap.keySet();
for(String keySet : referenceKeySet) {
System.out.println("keySet Name is " + keySet);
System.out.println("ValueSet is [][][][][][][][][][][][][][][][][]   " + hmap.get(keySet));
}

Set<Entry<String, List<String>>> reference = hmap.entrySet();
Iterator<Entry<String, List<String>>> referenceAgain = reference.iterator();
System.out.println(referenceAgain.hasNext());
while(referenceAgain.hasNext()) {
Entry<String, List<String>> StringList = referenceAgain.next();
System.out.println("StringList.getValue     is " + StringList.getValue());
System.out.println("StringList.getKey Value is " + StringList.getKey());
Iterator<String> listReference = StringList.getValue().iterator();
while(listReference.hasNext()) {
System.out.println("AAA+ Rating is " + listReference.next());
}
Iterator<String> listReferenStringList = StringList.getValue().subList(0, 2).iterator();
while(listReferenStringList.hasNext()) {
System.out.println("BBB+ Rating is " + listReferenStringList.next());
}
}

}
}

ArrayListofArrayList example

package com.concretepage;
import java.util.ArrayList;
public class ArrayListofArrayList {
public static void main(String[] args) {

int a = 5;
ArrayList<ArrayList<Integer>> arrayListMain = new ArrayList<ArrayList<Integer>>(a);

ArrayList<Integer> aList1 = new ArrayList<Integer>();
aList1.add(1);aList1.add(2);aList1.add(3);aList1.add(4);
arrayListMain.add(aList1);

ArrayList<Integer> aList2 = new ArrayList<Integer>();
aList2.add(5);
arrayListMain.add(aList2);

for (int i = 0; i < arrayListMain.size(); i++) {
System.out.println("arrayListMain Size is " + arrayListMain.size() + " b ");
            for (int j = 0; j < arrayListMain.get(i).size(); j++) {
            System.out.print("arrayListMain.get(i).size is " + arrayListMain.get(i).size() + " b ");
                System.out.print(arrayListMain.get(i).get(j) + " a ");
            }
            System.out.println();
        }

}
}

Can private method be declared inside abstract class ?

package com.concretepage;
public abstract class AbstractMethodPrivateNotPossible {
abstract private void method1();
}

Abstractclass example having abstract as well as concrete methods

package com.concretepage;

public abstract class Abstractclass {

abstract void method1();
abstract void method2();

void method3() {
System.out.println("hi i am from method3");
}

}

HashMapofArrayList

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Map.Entry;

public class HashMapofArrayList {
public static void main(String[] args) {
ArrayList<HashMap<Object[],Object[]>> hashMapArrayList = new ArrayList<HashMap<Object[],Object[]>>();
HashMap<Object[], Object[]> hmap = new LinkedHashMap<Object[], Object[]>();
Object[] firstObject  = {"11","12","13","14"};Object[] secondObject = {"15","16","17","18"};
Object[] thirdobject  = {"19","20","21","22"};Object[] fourthobject = {"23","24","25","26"};
Object[] fifthobject  = new Object[]{"27","28","29","30"};
Object[] sixthobject  = new Object[]{"31","32","33","34"};
/*char[] seventhobject = new char[35];
char[] eightobject   = new char[36];*/
char seventhobject = 'S';
char eightobject   = 'E';
System.out.println("seventhobject[0] " + String.valueOf(seventhobject));
System.out.println("eightobject[0]   " +   String.valueOf(eightobject));
/*Object[] objectseventhobject = {seventhobject};
Object[] objecteightobject = {eightobject};*/
Object[] objectseventhobject = {String.valueOf(seventhobject)};
Object[] objecteightobject = {String.valueOf(eightobject)};
//System.out.println("objectseventhobject.toString() " + objectseventhobject[0]);
//System.out.println("objecteightobject.toString() " + objecteightobject[0]);

hmap.put(firstObject, thirdobject);
hmap.put(secondObject, fourthobject);
hmap.put(fifthobject, sixthobject);
hmap.put(objectseventhobject, objecteightobject);

HashMap<Object[], Object[]> hmapNew = new LinkedHashMap<Object[], Object[]>();
hmapNew.putAll(hmap);
hashMapArrayList.add(hmap);
hashMapArrayList.add(hmapNew);

Iterator<HashMap<Object[],Object[]>> iterator = hashMapArrayList.iterator();
while(iterator.hasNext()) {
HashMap<Object[], Object[]> iteratorNext = iterator.next();
Set<Entry<Object[], Object[]>> entryReference = iteratorNext.entrySet();
Iterator<Entry<Object[], Object[]>> itr_entryReference = entryReference.iterator();
while(itr_entryReference.hasNext()) {
Entry<Object[], Object[]> itrObject = itr_entryReference.next();
for(int i=0;i<itrObject.getKey().length;i++) {
System.out.println(itrObject.getKey()[i]+"&&&&&"+itrObject.getValue()[i]);
}
}
}
System.out.println("====================================");
for(int i=0;i<hashMapArrayList.size();i++) {
HashMap<Object[], Object[]> hm=hashMapArrayList.get(i);
for (Map.Entry<Object[],Object[]> entry : hm.entrySet())  {
for(int j=0;j<entry.getValue().length;j++) {
System.out.println(entry.getKey()[j]+"-----"+entry.getValue()[j]);
}
//or
Object[] key   = entry.getKey();
Object[] value = entry.getValue();
System.out.println("*********");
for(int j=0;j<key.length;j++) {
System.out.println(key[j]+"-----"+value[j]);
}
}
}
}
}

How to find out eclipse root path ?

import java.io.File;
public class EclipseRootPath {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new File("").getAbsolutePath());
System.out.println(new File(".").getAbsolutePath());
System.out.println(System.getProperty("user.dir"));
}
}