So implementieren Sie eine Java-Hash-Tabelle und eine geordnete Liste

Hash-Tabelle (HashMap)

Die zeitliche Komplexität der Hash-Abfrage beträgt O(1)O(1)

按值传递

Character，Short,Integer,Long， Float，Double，String，Boolean，在java当中哈希表内部以值的形式传递，而不是一地址的形式传递。

例如：

HashMap<Integer, String> intMap = new HashMap<>();
intMap.put(1234567, "111");
Integer a = 1234567;
Integer b = 1234567;
System.out.println("a==b = " + (a == b));
System.out.println("a.equals(b) = " + a.equals(b));
System.out.println("intMap.get(a) = " + intMap.get(a));
System.out.println("intMap.get(b) = " + intMap.get(b));

// 输出结果
// a==b = false
// a.equals(b) = true
// intMap.get(a) = 111
// intMap.get(b) = 111

由上边的案例中 a!= b,但是intMap.get(a) == intMap.get(b).我们可以看出，在我们从hashmap里面查询或者操作某些值的话，是以值的形式去传递和匹配的，而不是以内存地址的形式去匹配。

按址传递

如果是非原生的类型的话，以内存地址的形式传递。例如：

public static class Node {
    private int value;
    public Node(int value) {
        this.value = value;
    }
}
HashMap<Node, String> map = new HashMap<>();
Node node1 = new Node(1);
Node node2 = new Node(1);
map.put(node1, "ziop");
System.out.println("map.containsKey(node1) = " + map.containsKey(node1));
System.out.println("map.containsKey(node2) = " + map.containsKey(node2));

//输出结果
//map.containsKey(node1) = true
//map.containsKey(node2) = false

内存大小比较

基础类型，一条记录的内存大小是Key的大小加上Value的大小。

非基础类型， 一条记录的内存大小是 两个地址的大小， 一个地址8字节，key和value 共16字节

如果是 基础类型和非基础类型的混合类型的话，就是各自按照各自的方式计算

有序表（TreeMap）

• 有序表会根据key的大小进行 升序排列 ，我们可以用他来做hashmap中的所有操作，并且扩展出了，查找第一个key或者最后一个key的操作，也扩展出了查找小于某个区间的最大值和大于某个区间的最小值

• 所有操作时间复杂度都是O(logn)

  Übergabe nach Wert

  Zeichen, Kurz, Ganzzahl, Long, Float, Double, String, Boolean, in java wird die Hash-Tabelle intern in Form eines Werts und nicht in Form einer Adresse übergeben.
• Zum Beispiel:

  TreeMap<Integer, String> treeMap = new TreeMap<>();
  treeMap.put(3,"我是3 ");
  treeMap.put(0,"我是3 ");
  treeMap.put(7,"我是3 ");
  treeMap.put(2,"我是3 ");
  treeMap.put(5,"我是3 ");
  treeMap.put(9,"我是3 ");
  treeMap.put(1,"我是3 ");
  System.out.println("treeMap.containsKey(3) = "+treeMap.containsKey(3));
  System.out.println("treeMap.containsKey(6) = "+treeMap.containsKey(6));
  System.out.println("treeMap.get(3) = "+treeMap.get(3));
  treeMap.put(3,"他是3");
  System.out.println("treeMap.get(3) = "+treeMap.get(3));
  treeMap.remove(3);
  System.out.println("treeMap.get(3) = "+treeMap.get(3));
  treeMap.remove(3);
  System.out.println("treeMap.firstKey() = "+treeMap.firstKey());
  System.out.println("treeMap.lastKey() = "+treeMap.lastKey());
  //        返回 小于等于五 并且最近的 key
  System.out.println("treeMap.floorKey(5) = "+treeMap.floorKey(5));
  System.out.println("treeMap.floorKey(6) = "+treeMap.floorKey(6));
  //        返回 大于等于 4 并且最靠近的值
  System.out.println("treeMap.ceilingKey(4) = "+treeMap.ceilingKey(4));

// Ausgabeergebnis

// a==b = false

// a.equals(b) = true

// intMap.get(a) = 111

// intMap.get (b) = 111

Im obigen Fall ist a! = b, aber intMap.get(a) == intMap.get(b) siehe Es stellt sich heraus, dass, wenn wir bestimmte Werte aus der Hashmap abfragen oder bearbeiten, diese in Form von Werten und nicht in Form von Speicheradressen übergeben und abgeglichen werden.

Übergabe nach Adresse

Wenn es sich um einen nicht nativen Typ handelt, wird er in Form einer Speicheradresse übergeben. Zum Beispiel:

//        存放非基础类型
public static void main(String[] args) {
TreeMap<Node, Integer> treeMap1 = new TreeMap<>();
Node node3 = new Node(3);
Node node4 = new Node(4);
treeMap1.put(node3, 3);
treeMap1.put(node4, 4);
System.out.println("treeMap1.firstEntry().getValue() = " + treeMap1.firstEntry().getValue());
System.out.println("treeMap1.lastEntry().getValue() = " + treeMap1.lastEntry().getValue());
}
public static class Node implements Comparable<Node> {
private int value;
    public Node(int value) {
    this.value = value;
}
        @Override
    public int compareTo(Node node) {
        return this.value - node.value; 
    }
}

//Ausgabeergebnis
//map.containsKey(node1) = true
//map.containsKey(node2) = false

Speichergrößenvergleich

Grundtyp, eins Datensatz Die Speichergröße ist die Größe des Schlüssels plus der Größe des Werts.

Bei Nicht-Basistypen beträgt die Speichergröße eines Datensatzes die Größe von zwei Adressen, eine Adresse beträgt 8 Bytes und der Schlüssel und der Wert betragen insgesamt 16 Bytes. Die Methode zur Berechnung der 🎜🎜Geordnete Liste (TreeMap)🎜

🎜🎜Die geordnete Liste wird in aufsteigender Reihenfolge entsprechend der Größe des Schlüssels angeordnet. Wir können damit hashmap Alle Operationen im Code> erstellen wurden auf die Operation zum Finden des ersten Schlüssels oder des letzten Schlüssels sowie auf die Operation zum Finden des Maximalwerts kleiner als ein bestimmtes Intervall und des Minimalwerts größer als ein bestimmtes Intervall erweitert🎜🎜🎜🎜Alle Operationen Die zeitliche Komplexität ist alles auf <code>O(logn)-Niveau. 🎜🎜🎜🎜Wenn der Schlüssel jedoch kein Basistyp ist, kann er nicht direkt sortiert werden. Der Typ muss eine Sortierschnittstelle implementieren und über eine sortierbare Funktion verfügen. Oder übergeben Sie die Vergleichsmethode bei neuen TreeMap🎜🎜🎜🎜Grundlegende Speichertypoperationen🎜rrreee🎜🎜//Die Ausgabeergebnisse lauten wie folgt🎜//treeMap.containsKey(3) = true 🎜//treeMap.containsKey(6) = false 🎜 //treeMap.get(3) = Ich bin 3 🎜//treeMap.get(3) = Er ist 3🎜//treeMap.get(3) = null🎜//treeMap.firstKey() = 0🎜/ /treeMap .lastKey() = 9🎜//treeMap.floorKey(5) = 5🎜//treeMap.floorKey(6) = 5🎜//treeMap.ceilingKey(4) = 5🎜🎜🎜Speichern nicht grundlegender Typen für Operationen🎜rrreee

Das obige ist der detaillierte Inhalt vonSo implementieren Sie eine Java-Hash-Tabelle und eine geordnete Liste. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!