Difference between List, Set, and Map in Java

Java's java.util package provides the Collection interface, which branches into several sub-interfaces and classes, including List, Set, and Map. This article clarifies the distinctions between these three core data structures.

Understanding the List Interface

List, a sub-interface of Collection, offers methods for inserting, updating, deleting, and searching elements. Importantly, List allows duplicate elements and maintains insertion order. Null elements are also permitted.

List Interface Example:

import java.util.*;
public class ListExample {
   public static void main (String args[]) {
      List<String> mylist = new ArrayList<>();
      mylist.add("James Bond");
      mylist.add("Superman");
      mylist.add("Spiderman");
      for(String superhero : mylist)
         System.out.println(superhero);
   }
}

Output:

<code>James Bond
Superman
Spiderman</code>

Understanding the Set Interface

Set, another Collection sub-interface, resides within the java.util package. A defining characteristic of Set is its rejection of duplicate elements; only unique values are stored. Insertion order is not guaranteed.

Set Interface Example:

import java.util.*;
public class MySet {
   public static void main (String args[]) {
      Set<String> setmyalp = new HashSet<>();
      setmyalp.add("A");
      setmyalp.add("B");
      setmyalp.add("C");
      setmyalp.add("D");
      setmyalp.add("E");
      System.out.println(setmyalp);
   }
}

Output:

<code>[A, B, C, D, E]  (Order may vary)</code>

Understanding the Map Interface

The Map interface, also found in java.util, stores data in key-value pairs. Each key is unique, and it's used to retrieve its associated value. Duplicate keys are not allowed. Insertion order is not guaranteed.

Map Interface Example:

import java.util.*;
public class MyMap {
   public static void main (String args[]) {
      Map<String, String> mapvalue = new HashMap<>();
      mapvalue.put("Fruit", "Apple");
      mapvalue.put("Vegetable", "Potato");
      mapvalue.put("Nut", "Groundnut");
      for(Map.Entry<String, String> me : mapvalue.entrySet()) {
         System.out.println(me.getKey() + " " + me.getValue());
      }
   }
}

Output:

<code>Fruit Apple
Vegetable Potato
Nut Groundnut (Order may vary)</code>

Key Differences between List, Set, and Map Interfaces

Feature	List	Set	Map
Duplicates	Allowed	Not Allowed	Not Allowed (for keys)
Insertion Order	Maintained	Not Guaranteed	Not Guaranteed
Null Values	Multiple allowed	Only one allowed	One null key allowed, multiple null values
Implementing Classes	ArrayList, LinkedList, etc.	HashSet, LinkedHashSet, TreeSet, etc.	HashMap, LinkedHashMap, TreeMap, etc.
Element Access	By index using get() method	No direct index access	By key using get() method
Use Case	Ordered collections, sequences	Unique elements, membership testing	Key-value associations, lookups
Iteration	ListIterator	Iterator	keySet(), values(), entrySet()

Conclusion

List, Set, and Map are fundamental Java interfaces offering distinct ways to manage collections of data. The choice depends entirely on the specific needs of your application, considering factors like the need for ordered elements, duplicate allowance, and the nature of data access required.

Frequently Asked Questions (FAQs)

1. Package: List, Set, and Map belong to the java.util package.

2. Null Values: List allows multiple nulls; Set allows only one; Map allows one null key and multiple null values.

3. List Implementations: ArrayList and LinkedList are common implementations.

4. Duplicate Values: Only List permits duplicate values.

5. get() Method: Only List and Map (for values via keys) provide direct element access by index or key.

The above is the detailed content of Difference between List, Set, and Map in Java. For more information, please follow other related articles on the PHP Chinese website!