Title Map

Collection Framework Map in Java

01

Map provides three collection views:

1. Key set
2. Value set
3. Key-Value Mapping Set

public String getWeek(int num){
 if(num<0 || num>7){
  throw new NoWeekException(num+"No corresponding week");
  String[] weeks = {"","Monday"...."Sunday"};
  return weeks[num];
 }
}

Sunday (Sunday), Monday (Monday), Tuesday (Tuesday), Wednesday (Wednesday), Thursday (Thursday), Friday (Friday), Saturday (Saturday)

java.util
 Interface Map<K,V>
Parameters:
K is the key for this mapping
 The value of V for this mapping

Knowing subinterfaces:

Bindings,ConcurrentMap<K,V>,ConcurrentNavigableMap<K,V>,LogicalMessageContext,MessageContext,NavigableMap<K,V>,SOAPMessageContext,SorteMap<K,V>

Knowing the implementation class:

AbstractMap,Attributes,AuthProvider,ConcurrentHashMap,ConcurrentSkipListMap,EnumMap,HashMap,Hashtable,IdentityHashMap,LinkedHashMap,PrinterStateReasons,Properties,Provider,RenderingHints,SimpleBindings,TabularDataSupport,TreeMap,UIDefaults,WeakHashMap

Implemented interfaces:

public interface Map<K,V>

Characteristics in Map Sets:

1. Internal storage mode is in the form of key-value pairs
2. Keys in Map s should be unique

Nested classes (internal):

Map method:

put

V put (E key, V value)

The corresponding key and value are mapped, and the method of adding the mapping relationship is established. If the mapping relationship existed before, the specified value will be replaced by the old value.

Parameters:

Errors that will be thrown:

Unsupported OperationException: put operation is not supported
 ClassCastException: Mapping relationships are not allowed
 NullPointerException: The specified key or value is null, and this mapping is not allowed to store
 Illegal ArgumentException: The specified key or value is not allowed to be stored in the map

General implementation classes:

HashMap

java.util
//Class HashMap < K, V >
java.lang.Object
 -> java.util.AbstractMap<K,V>
  -> java.util.HashMap<K,V>

Parameters:

K-is the corresponding key
 V-is the corresponding value

Implemented interfaces:

Serializable,Cloneable,Map<K,V>

Known subclasses:

LinkedHashMap，PrinterStateReasons

So:

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

02

import java.util.HashMap;
public class MapDemo {
 public static void main(String[] args){
  // Building map
  Map<String,String> map = new HashMap<String,String>();
 // Additive elements
  map.put("Monday", "Monday");
  mpa.put( ...// Add it on your own.
  map.put("Sunday", "Sunday");
  // When adding an element, if the key is the same, the value overrides
  map.put("Sunday", "SundayDemo");  // The value is covered.
 // Get value
 String value = map.get("Sunday"); // The key exists, the return value is null, and vice versa.
 // Delete elements
 String s = map.remove("Sunday"); // Delete the corresponding key-value pairs so that they are missing in the Map set
 }
}

Map<String,String> map = new HashMap<String,String>();
map.put("Monday", "Monday");
map.put("Sunday", "Sunday");

Using keySet

Set<String> keySet = map.keySet();
for(Iterator<String> it = keySet.iterator(); it.hasNext(); ){
 String key = it.next();
 String value = map.get(key);
 System.out.println(key + " : " + value);
}

You can use the foreach loop

for(String key : keySet){
 System.out.println(key + " = " + map.get(key));
}

entrySet

Set<Map.Entry<K,V>> entrySet()

To return the view of the mapping relation Set contained in this mapping, the mapping relation in the map set is stored in the set set.

Mapping relationship: the relationship between keys and values, the type of data type Map.Entry (internal) relationship

Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator< Map.Entry<String,String> > it = entrySet.iterator();
while(it.hasNext(K,V)){
 Map.Entry<String,String> m = it.next();
 // Get key
 String key = m.getKey();
 // Get value
 String value = m.getValue();
 System.out.println(key + " : " + value);
}

Map.Entry<K,V>

java.util
//Interface Map.Entry<K,V>

Interface implementation class:

AbstractMap.SimpleEntry , AbstractMap.SimpleImmutableEntry

Interface:

public static interface Map.Entry<K,V>
// For mapping item-key-value pairs

Map.Entry<K,V>Method

Method:

for(Map.Entry<String,String> m : map.entrySet()){
 String key = m.getKey();
 String value = m.getValue();
 System.out.println(key + " : " + value);
}

interface Map{
 public static interface Entry();
}

values()

The return type is Collection < V>, returning the Collection view of the values contained in this mapping

Collection<String> values = map.values();
for(String value : values){
 System.out.println("value:"+value);
}

03

Collection Framework Map.png

Hashmap

public class HashMapDemo {
 public static void main(String[] args){
  Map<Student,String> map = new HashMap<Student,String>();
 // Additive elements
 map.put(new Student("da",12), "1");
 map.put(new Student("shu",13), "2");
 map.put(new Student("dashu",14), "3");
 // Remove data
 // Set<Student> keySet = map.keySet();
 // for(Student key : keySet){}
 for(Student key : map.keySet() ){
  String value = map.get(key);
  System.out.println(key.toString() + " : " + value);
 }
 }
}

public class Student implements Comparable<Student>{
 private String name;
 private int age;
 public Student(){
  super();
 }
 public Student(String name, int age){
  super();
  this.name = name;
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name; 
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age){
  this.age = age;
 }
 @Override 
 public String toString() {
  return "Student [name = " + name +"，age = " + age + "]";
 }
 @Override
 public int hasCode() {
  final int prime = 31;
  int result = 1;
  result = prime + result + age;
  result = prime + result + ((name == null) ? 0 : name.hashCode());
  return result;
 }
 @Override
 public boolean equals(Object obj){
  if(this == obj)
   return true;
  if(obj == null)
   return false;
  if(getClass() != obj.getClass() )
   return false;
  Student other = (Student) obj;
  if(age != other.age)
   return false;
  if(name == null){
   if(other.name != null)
    return false;
  }else if(!name.equals(other.name))
    return false;
  return true;
 }
 @Override
 public int  compareTo(Student o){
  int temp = this.age - o.age;
  
  return temp == 0? this.name.compareTo(o.name) : temp;
 }
}

TreeMap

public class TreeMapDemo{
 public static void main(String[] args){
   Map<Student, String> map = new TreeMap<Student, String>(new ComparatorByName());
 // Additive elements
 map.put(new Student("da",12), "1");
 map.put(new Student("shu",13), "2");
 map.put(new Student("dashu",14), "3");
 // Remove data
 for(Map.Entry<String,String> m : map.entrySet()){
  Student key = m.getKey();
  String value = m.getValue();
  System.out.println(key + " : " + value);
 }
 }
}

public class ComparatorByName implements Comparator<Student>{
 @Override
 public int compare(Student o1, Student o2){
  int temp = o1.getName().compareTo(o2.getName());
  return temp == 0 ? o1.getAge() - o2.getAge() : temp;
 }
}

04

Example:

public class CollectionsDemo {
   public static void main(String[] args) {
      Map m = new HashMap(); 
      m.put("da", "8");
      m.put("shu", "9");
      m.put("dashu", "10");
      m.put("dashucoding", "12");
      System.out.println(m);
   }
}

The most commonly used collection classes are List and Map. The implementation classes of List include ArrayList and Vector. List can be changed in size, suitable for building, storing, and manipulating lists of any type of object elements.

Map is more general. Map collection classes are used to store element pairs. They are key-value pairs. Each key maps to a value. Understandably, List can be regarded as Map of numeric keys, but they have nothing to do with each other.

Iterator keyValues = map.entrySet().iterator();
Iterator keys = map.keySet().iterator();
Iterator values = map.values().iterator();

entrySet(): Returns the Set view of the mapping contained in the Map.
keySet(): Returns the Set view of the key contained in the Map.
values(): Returns the Collection view of the values contained in the Map.

epilogue

• Next, I will continue to explain other knowledge in depth. I am interested in continuing to pay attention to it.
• A little gift or a little compliment