Scribd
Upload
132 views

Java Collections: // Declare The List Concrete Type Is Arraylist

A Java collection is a data structure that contains a set of data in a dynamic size. Common collections include lists, stacks, queues, and trees. Collections allow parameterized types for type-safety. The document demonstrates creating an ArrayList of Strings and using collection methods like add(), get(), sorting with Collections.sort(), and defining a custom comparator.

Uploaded by

Anand Dhanalakota
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
132 views

Java Collections: // Declare The List Concrete Type Is Arraylist

A Java collection is a data structure that contains a set of data in a dynamic size. Common collections include lists, stacks, queues, and trees. Collections allow parameterized types for type-safety. The document demonstrates creating an ArrayList of Strings and using collection methods like add(), get(), sorting with Collections.sort(), and defining a custom comparator.

Uploaded by

Anand Dhanalakota
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Java Collections

A Java collection is a data structure which contains and processes a set of data. The data stored in the collection is encapsulated and the access to the data is only possible via predefined methods. For example if your application saves data in an object of type People, you can store several People objects in a collection. While arrays are of a fixed size, collections have a dynamic size, e.g. a collection can contain a flexible number of objects. Typical collections are: stacks, queues, deques, lists and trees. As of Java 5 collections should get parameterized with an object declaration to enable the compiler to check if objects which are added to the collection have the correct type. This is based on Generics. Generics allow a type or method to operate on objects of various types while providing compile-time type safety. The following code shows an example how to create a Collection of type List which is parameterized with <String> to indicate to the Java compiler that only Strings are allowed in this list. .
package collections; import java.util.ArrayList; public class MyArrayList { public static void main(String[] args) { // Declare the List concrete type is ArrayList List<String> var = new ArrayList<String>(); // add a few Strings to it var.add("Lars"); var.add("Tom"); // Loop over it and print the result to the console for (String s : var) { System.out.println(s); } } }

If you try to put a non String into this list, you would receive a compiler error.
List

is only an interface, a common implementation is the ArrayList class, hence you need to call new ArrayList().

2. Important implementations

2.1. Map and HashMap


The Map interface defines an object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value. The HashMap class is an efficient implementation of the Map interface. The following code demonstrates its usage.
import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class MapTester { public static void main(String[] args) { // Keys are Strings // Objects are also Strings Map<String, String> mMap = new HashMap<String, String>(); mMap.put("Android", "Mobile"); mMap.put("Eclipse", "IDE"); mMap.put("Git", "Version control system"); // Output for (String key : mMap.keySet()) { System.out.println(key +" "+ mMap.get(key)); } System.out.println("Changing the data"); // adding to the map mMap.put("iPhone", "Created by Apple"); // Delete from map mMap.remove("Android"); System.out.println("New output:"); // Output for (String key : mMap.keySet()) { System.out.println(key +" "+ mMap.get(key)); } } }

2.2. List, ArrayList and LinkedList


List

is the interface which allows to store objects in a resizable container.

ArrayList

is implemented as a resizable array. If more elements are added to ArrayList than its initial size, its size is increased dynamically. The elements in an ArrayList can be accessed directly and efficiently by using the get() and get() methods, since ArrayList is implemented based on an array.
LinkedList

is implemented as a double linked list. Its performance on add() and remove() is better than the performance of Arraylist. The get() and get() methods have worse performance than the ArrayList, as the LinkedList does not provide direct access.

The following code demonstrates the usage of List and ArrayList.


import java.util.ArrayList; import java.util.List; public class ListExample { public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(3); list.add(2); list.add(1); list.add(4); list.add(5); list.add(6); list.add(6); for (Integer integer : list) { System.out.println(integer); } } }

3. Useful collection methods


The java.util.Collections class provides useful functionalities for working with collections. Table 1. Collections Method Collections.reverse(list) Collections.shuffle(list) Collections.sort(list) Description Reverse the order of the list Shuffle the list Sort the list

Collections.copy(list, list) Copy a collection to another

4. Using Collections.sort and Comparator in Java


Sorting a collection in Java is easy, just use the Collections.sort(Collection) to sort your values. The following code shows an example for this.
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Simple { public static void main(String[] args) { List list = new ArrayList(); list.add(5); list.add(4); list.add(3);

list.add(7); list.add(2); list.add(1); Collections.sort(list); for (Integer integer : list) { System.out.println(integer); } } }

This is possible because Integer implements the Comparable interface. This interface defines the method compare which performs pairwise comparison of the elements and returns -1 if the element is smaller then the compared element, 0 if it is equal and 1 if it is larger. If what to sort differently you can define your own implementation based on the Comparator interface.
import java.util.Comparator; public class MyIntComparable implements Comparator<Integer>{ @Override public int compare(Integer o1, Integer o2) { return (o1>o2 ? -1 : (o1==o2 ? 0 : 1)); } } import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Simple2 { public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(5); list.add(4); list.add(3); list.add(7); list.add(2); list.add(1); Collections.sort(list, new MyIntComparable()); for (Integer integer : list) { System.out.println(integer); } } }

Note
For the above you could also have used the Collection.reverse() method call. This approach is that you then sort any object by any attribute or even a combination of attributes. For example if you have objects of type Person with an attribute income and dataOfBirth you could define different implementations of Comparator and sort the objects according to your needs.

You might also like