列表與地圖界面 (List vs Map interface)
Here, we will see how List differs from Map interface in Java and we will see the points given below,
在這里，我們將看到List與Java中的Map接口有何不同，并且我們將看到以下幾點，
列表界面 (List interface)
List is an interface that is defined in java.util package.
List是在java.util包中定義的接口。
List is the data structure in Java.
List是Java中的數據結構。
List object is represented in the form of values.
列表對象以值的形式表示。
The performance of List interface is low as compare to Map interface.
List界面的性能比Map界面低。
The implementation class of List interface is ArrayList, LinkedList, and Vector and Stack, etc.
List接口的實現類是ArrayList，LinkedList和Vector and Stack等。
List is not different from Collection or in other words, there is?a relation between List and Collection (i.e. It is a child interface of Collection interface because List implements Collection interface).
List與Collection沒有區別，換句話說，List與Collection之間存在關系(即，它是Collection接口的子接口，因為List實現了Collection接口)。
List does not provide uniqueness (i.e. Duplicates are allowed for values or we can insert one object multiple times).
列表不提供唯一性(即值允許重復，或者我們可以多次插入一個對象)。
If we want to represent a group of individual objects where “insertion order is preserved” (i.e. the order of insertion is must be same as the order of retrieval).
如果我們要表示一組單獨的對象，其中“插入順序被保留”(即插入順序必須與檢索順序相同)。
We should go for List if we want to represent a group of the object as a single entity.
如果我們想將一組對象表示為單個實體，則應使用List。
List is meant for a group of the individual object.
列表用于一組單獨的對象。
Example:
例：
Let suppose we have a List with few elements. Here we are adding the elements in the order is [10,20,30,50, null,30]?and if we are retrieving the elements so the order of retrieving elements must be the same (i.e. it is needed to be the same insertion and retrieval order of the elements.) so the output will be the same and the order will be like [10,20,30, null,30].
假設我們有一個包含很少元素的列表。 在這里，我們按[10,20,30,50，null，30]的順序添加元素，如果我們要檢索元素，則檢索元素的順序必須相同(即，需要相同的插入以及元素的檢索順序。)因此輸出將是相同的，順序將類似于[10,20,30，null，30]。
// Java program to demonstrate the behavior of List interface
import java.util.*;
class ListInterface {
public static void main(String[] args) {
// Creating an instance
List list = new ArrayList();
// By using add() method to add an elements
list.add(10);
list.add(20);
list.add(30);
list.add(50);
list.add(null);
// if we add again 30 then we will not get any error
// because duplicate element is allowed
list.add(30);
// Display List elements
System.out.println("Retrieval order of the elements in List is :" + list);
}
}
Output
輸出量
E:\Programs>javac ListInterface.java
E:\Programs>java ListInterface
Retrieval order of the elements in List is :[10, 20, 30, 50, null, 30]
Now, we will see how Map differs from List interface in Java and we will see the points given below,
現在，我們將看到Map與Java中的List接口有何不同 ，我們將看到以下幾點，
地圖界面 (Map interface)
The Map is an interface that is defined in java.util package.
Map是在java.util包中定義的接口。
The Map is the data structure in Java.
Map是Java中的數據結構。
The Map is based on Hashing and The Map object is represented in the form of key-value pairs and the key-value pairs are called entry.
Map基于散列，并且Map對象以鍵值對的形式表示，而鍵值對稱為entry。
The performance of Map interface is high as compare to Set interface.
Map界面的性能比Set界面高。
In the case of Map interface, there is no collision concept if we know keys.
在Map接口的情況下，如果我們知道按鍵，則不會有沖突概念。
The implementation class of Map interface is HashMap, LinkedHashMap, and ConcurrentHashMap, etc.
Map接口的實現類是HashMap，LinkedHashMap和ConcurrentHashMap等。
The Map is different from Collection or in other words, there is no relation between Map and Collection (i.e. It is not a child interface of Collection interface because Map does not implement Collection interface).
Map與Collection不同，換句話說，Map與Collection之間沒有關系(即，它不是Collection接口的子接口，因為Map未實現Collection接口。
The Map does not provide uniqueness fully (i.e. Duplicates are not allowed for Keys and Duplicates are allowed for values).
映射不能完全提供唯一性(即，鍵不允許重復，值不允許重復)。
We should go for Map if we want to represent a group of the object as key-value pairs.
如果我們想將一組對象表示為鍵值對，則應該使用Map。
The Map is meant for a group of key-value pairs.
該映射用于一組鍵值對。
Example:
例：
Let suppose we have a Map with few elements. Here we are adding the elements in the order is {Java=1000, C=2000, C++=3000, Ruby=4000, Python=1000,null=null, Django=null, null=7000} and if we are retrieving the elements so the order of retrieving elements can be different (i.e. insertion order is not preserved and it is not needed to be the same insertion and retrieval order of the elements.) so the output will be different and the order will be like {Ruby=4000, C=2000, Django=null, Python=1000, C++=3000, null=7000, Java=1000}
假設我們有一個包含很少元素的Map。 在這里，我們按照{Java = 1000，C = 2000，C ++ = 3000，Ruby = 4000，Python = 1000，null = null，Django = null，null = 7000}的順序添加元素，如果我們要檢索元素因此檢索元素的順序可以不同(即不保留插入順序，也不必與元素的插入和檢索順序相同。)因此輸出將有所不同，順序將類似于{Ruby = 4000 ，C = 2000，Django = null，Python = 1000，C ++ = 3000，null = 7000，Java = 1000}
// Java program to demonstrate the behavior of Map
import java.util.Collection;
import java.util.Map;
import java.util.HashMap;
class MapClass {
public static void main(String[] args) {
// Creating an instance of HashMap
Map map = new HashMap();
//By using put() method to add some values in Map
map.put("Java", 1000);
map.put("C", 2000);
map.put("C++", 3000);
map.put("Ruby", 4000);
map.put("Python", 1000);
map.put("null", null);
map.put("Django", null);
/* Here we will not get any error but one null is accepted for keys*/
map.put("null", 7000);
// Display retrieval order of Map
System.out.println("Current Map list is :" + map);
// by using values() to find values of Map
Collection values = map.values();
// Display Values of Map
System.out.println("Current Map Key values is :" + values);
}
}
Output
輸出量
E:\Programs>javac MapClass.java
E:\Programs>java MapClass
Current Map list is :{Ruby=4000, C=2000, Django=null,
Python=1000, C++=3000, null=7000, Java=1000}
Current Map Key values is :[4000, 2000, null, 1000, 3000, 7000, 1000]
翻譯自: https://www.includehelp.com/java/differences-between-list-and-map-interface-in-java.aspx
 D)
