The ArrayList class implements the List interface and allows storing and accessing elements similarly to an array. It uses a dynamic array under the hood to store elements without a size limit like a regular array. The ArrayList allows duplicates, maintains insertion order, and supports random access.
The ArrayList class implements the List interface and allows storing and accessing elements similarly to an array. It uses a dynamic array under the hood to store elements without a size limit like a regular array. The ArrayList allows duplicates, maintains insertion order, and supports random access.
The ArrayList class implements the List interface and allows storing and accessing elements similarly to an array. It uses a dynamic array under the hood to store elements without a size limit like a regular array. The ArrayList allows duplicates, maintains insertion order, and supports random access.
The ArrayList class implements the List interface and allows storing and accessing elements similarly to an array. It uses a dynamic array under the hood to store elements without a size limit like a regular array. The ArrayList allows duplicates, maintains insertion order, and supports random access.
List interface extends Collection interface. Array List(Cont..) • Array List is a generic class that has this declaration • Class ArrayList<E> • Here E Specifies the type of objects that the list will hold. • Java ArrayList is a part of the Java collection framework and it is a class of java.util package. • Java ArrayList class uses a dynamic array for storing the elements. It is like an array, but there is no size limit. • Syntax • ArrayList<Type> arrayList= new ArrayList<>(); • Example • ArrayList<Integer> arrayList = new ArrayList<>();
• // create String type arraylist
• ArrayList<String> arrayList = new ArrayList<>(); Points to be Remembered
• Java ArrayList class can contain duplicate
elements. • Java ArrayList class maintains insertion order. • Java ArrayList class is non synchronized. • Java ArrayList allows random access because the array works on an index basis. import java.util.ArrayList;
public class Main {
public static void main(String[] args) { ArrayList<String> cars = new ArrayList<String>(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); for (String i : cars) { System.out.println(i); } } } import java.util.ArrayList; import java.util.Collections; public class Main { public static void main(String[] args) { ArrayList<String> cars = new ArrayList<String>(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); Collections.sort(cars); for (String i : cars) { System.out.println(i); } } } import java.util.*;
public class Main {
public static void main(String[] args) { ArrayList cars = new ArrayList(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); cars.add(1); cars.add(5.8); for (int i = 0; i < cars.size(); i++) { System.out.println(cars.get(i)); } } } Linked List • The LinkedList class of the Java collections framework provides the functionality of the linked list data structure. • However, while the ArrayList class and the LinkedList class can be used in the same way, they are built very differently. • Use an ArrayList for storing and accessing data, and LinkedList to manipulate data. import java.util.LinkedList;
class Main { public static void main(String[] args){
// create linkedlist LinkedList<String> animals = new LinkedList<>();
// Add elements to LinkedList
animals.add("Dog"); animals.add("Cat"); animals.add("Cow"); System.out.println("LinkedList: " + animals); } } SET • The set is an unordered collection of objects in which duplicate values cannot be stored. • It is an interface that implements the mathematical set. • This interface contains the methods inherited from the Collection interface and adds a feature that restricts the insertion of the duplicate elements. • In the above diagram, the NavigableSet and SortedSet are both the interfaces. The NavigableSet extends the SortedSet, so it will not retain the insertion order and store the data in a sorted way HashSet • A HashSet is a collection of items where every item is unique. • The HashSet class extends AbstractSet class which implements Set interface. • Syntax: • class HashSet<E> Methods of Set
• add() - adds the specified element to the set
• addAll() - adds all the elements of the specified collection to the set • iterator() - returns an iterator that can be used to access elements of the set sequentially • remove() - removes the specified element from the set • removeAll() - removes all the elements from the set that is present in another specified set • retainAll() - retains all the elements in the set that are also present in another specified set • clear() - removes all the elements from the set • size() - returns the length (number of elements) of the set • toArray() - returns an array containing all the elements of the set • contains() - returns true if the set contains the specified element • containsAll() - returns true if the set contains all the elements of the specified collection • hashCode() - returns a hash code value (address of the element in the set) Set Operations
• Union - to get the union of two sets x and y,
we can use x.addAll(y) • Intersection - to get the intersection of two sets x and y, we can use x.retainAll(y) • Subset - to check if x is a subset of y, we can use y.containsAll(x) • Difference: The difference operation deletes the values from the set which are present in another set removeAll() Tree Set • Java TreeSet class implements the Set interface that uses a tree for storage. • It inherits AbstractSet class and implements the NavigableSet interface. • The objects of the TreeSet class are stored in ascending order. • Syntax Class TreeSet<E>