A set is a collection that can quickly find existing elements. However, to view an element, you need to have an exact copy of the element you are looking for. This is not a very general way of finding, since finding an element in a collection always involves traversing the collection. Often, we know information about some key and want to find the element corresponding to it. The map data structure is designed for this purpose. Maps are used to store key/value pairs. If the key is provided, the value can be looked up. There is a one-to-one correspondence between them.

Basic mapping operations:

The Java class library provides two general implementations for mapping: HashMap and TreeMap, both of which implement the Map interface

HashMap hashes the keys, and TreeMap sorts the elements in the overall order of the keys and organizes them into a search tree.

Hash or comparison functions can only act on keys. Values ??associated with keys cannot be hashed or compared

Like sets, hash maps are slightly faster than tree maps, so it is best to use hash maps when the keys do not need to be accessed in sorted order.

OP->>To perform key-value storage, you must use the put method

OP->>To perform key-value access, you must use the get method, and only through keys To access the value

OP->>If the value cannot be found but you do not want to return an empty object, use getOrDefault(var1,var2). If the value cannot be found, return var2.

Keys must be unique. If the put method is called twice on a pair of mappings, the latter call will overwrite the previous call. And return the result of the first call

OP->>To remove the key-value pair, use the remove(key) method

OP->> To get the number of key-value pairs, use the size() method

OP->>To iterate through each key and value, it is best to use the forEach method. You can provide a Lambda expression, used to process each element in the map in turn

Similar to scores.forEach((k,v)->System.out.println("key=" k ",value=" v));

The following example program demonstrates the mapping operation process. First, key/value pairs are added to the mapping. Then a key is deleted from the map, and its corresponding value is also deleted. Next, modify the value corresponding to a certain key and call the get method to view this value. Finally, the set of entries is processed iteratively.

Code:

package Collection.Map;
 
import java.util.*;
 
public class MapTest {
public static void main(String[] args) {
Map<String,Employee> staff=new HashMap<>();
staff.put("144-25-5464", new Employee("Amy Lee"));
staff.put("567-24-2546", new Employee("Harry Hacker"));
staff.put("157-62-7935", new Employee("Gary Cooper"));
staff.put("456-62-5527", new Employee("Francesca Cruz"));
//打印所有成員
System.out.println(staff);
//刪除某一成員
staff.remove("567-24-2546");
//替代一個成員
staff.put("456-62-5527", new Employee("Francesca Miller"));
//查看一個成員
System.out.println(staff.get("157-62-7935"));
//遍歷映射
staff.forEach((k,v)->System.out.println("key="+k+",value="+v));
}
}
 
class Employee{
String name;
 
public Employee(String name) {
this.name = name;
}
 
public String toString() {
return "[name="+name+"]";
}
}

Running results:

The following are several commonly used methods in the interface Map and their explanations:

V get(Object key)

Get the value corresponding to the key; return the object corresponding to the key, or return if there is no such object in the mapping null. Key can be null.

default V getOrDefault(Object key,V defaultValue)

Get the value associated with the key; returns the object associated with the key, or if this is not found in the map key, returns defaultValue.

V put(K key,V value)

Insert the relationship between the key and the corresponding value into the map. If the key already exists, the new object will replace the old object corresponding to the key. This method will return the old value corresponding to the key. Returns null if this key has not appeared before. Keys can be null, but values ??cannot.

void putAll(Map extends K,? extends V> entries)

Adds all entries in the given map to this map.

boolean containsKey(Object key)

Returns true if this key already exists in the map.

boolean containsValue(Object value)

If this value already exists in the mapping, return true.

default void forEach(BiConsumer super K,? super V> action)

Apply this action to all keys/values ??in this map.

The following are commonly used methods in the HashMap class:

HashMap()

HashMap(int initialCapacity)

HashMap(int initialCapacity, float loadFactor)

Construct an empty hash map with the given capacity and fill factor (the fill factor is a value between 0.0 and 1.0. This value determines the hash table fill percentage. Once this is reached ratio, it needs to be hashed into a larger table). The default reload factor is 0.75.

The following are commonly used methods in the TreeMap class:

TreeMap()

Construct a key that implements the Comparable interface Empty tree map.

TreeMap(Comparator super K> c)

Constructs a tree map and uses a specified comparator to sort the keys.

TreeMap(Map extends K,? extends V> entries)

Construct a tree map and add all entries in a map to the tree map middle.

TreeMap(SortedMap extends K,? extends V> entries)

Construct a tree map that adds all entries in a certain ordered map to the tree map, using the same comparator as the given ordered map.

The following are some important methods of the SortedMap interface:

##Comparator super K> comparator()

Return Comparator for sorting keys. If the keys are compared using the comparaTo method of the Comparable interface, null is returned.

K firstKey()

K lastKey()

Returns the minimum element and the maximum element in the map.

php Chinese website, a large number of free

Java introductory tutorials, welcome to learn online!

The above is the detailed content of What is mapping in java. For more information, please follow other related articles on the PHP Chinese website!