List

1. Array List :

                 Java ArrayList is the resizable array implementation of List interface that means it starts with default size and grows automatically when more data is added into array list. Some important points about Java ArrayList are: 

• Java ArrayList is almost similar to Vector except that it’s unsynchronized, so performance is better in single threaded environment. 
• Java ArrayList is not thread safe, so special care must be given when used in multithreaded environment. 
• Java ArrayList can contain duplicate values. 
• It also allows “null” value. 
• Objects in java ArrayList are added in insertion order.  
• Java ArrayList provides random access to its elements because it works on index. We can retrieve any element through its index.

                  package com.csi.collectionconcept; 

                           import java.util.ArrayList;

                           import java.util.Iterator;

                           public class ArrayListConcept {

                                    public static void main(String[] args) { 

                                                ArrayList a1 = new ArrayList<>(); 

                                                a1.add("IT"); al.add("COMP");

                                                a1.add("MECHANICAL"); 

                                                a1.add("CIVIL");

                                                a1.add("PRODUCTION");

                                                a1.add("CHEMICAL");

                                                a1.add("PETROLIUM");

                                                a1.add("IT");

                                                a1.add("ELECTRONICS");

                                                Iterator itr = al.iterator();

                                                while (itr.hasNext()) {

                                                               System.out.println(itr.next());

                                                }

                           }

         }

2. Linked List :

                    Java LinkedList is an implementation of the List and Deque interfaces. It extends AbstractSequentialList and implements List and Deque interfaces. 

Some important points about Java LinkedList are:

•  It supports adding null elements. 
• We can add any number of null elements. 
• It stores elements in Insertion order. 
• Internally, it is an implemented using Doubly Linked List Data Structure. 
• It supports duplicate elements. 
• It stores or maintains its elements in Insertion order. 
• It is not synchronized that means it is not thread safe. 
• We can create a synchronized LinkedList using Collections.synchronizedList() method. 
• It does not implement RandomAccess interface. So we can access elements in sequential order only. It does not support accessing elements randomly. 
• When we try to access an element from a LinkedList, searching that element starts from the beginning or end of the LinkedList based on where that elements is available. 
• We can use List Iterator to iterate LinkedList elements.

                       package com.csi.collectionconcept; 

                        import java.util.Iterator; 

                        import java.util.LinkedList; 

                        public class LinkedListConcept { 

                                    public static void main(String[] args) { 

                                                 LinkedList 1l = new LinkedList<>();

                                                  1l.add("IT"); ll.add("COMP"); 

                                                  1l.add("MECHANICAL"); 

                                                  1l.add("CIVIL"); 

                                                  1l.add("PRODUCTION"); 

                                                  1l.add("CHEMICAL"); 

                                                  1l.add("PETROLIUM"); 

                                                  1l.add("IT"); 

                                                  1l.add("ELECTRONICS"); 

                                                  Iterator itr = 1l.iterator(); 

                                                  while (itr.hasNext()) {

                                                                System.out.println(itr.next()); 

                                                   }

                                     }

                    }