Comment implémenter une table de hachage Java et une liste ordonnée

Table de hachage (HashMap)

La complexité temporelle de la requête de hachage est 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)

  Passez par valeur

  Caractère, Court, Entier, Long, Float, Double, String, Boolean, en java la table de hachage est passée en interne sous la forme d'une valeur au lieu d'une adresse.
• Par exemple :

  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));

// Résultat de sortie

// a==b = false

// a.equals(b) = true

// intMap.get(a) = 111

// intMap.get ( b) = 111

Dans le cas ci-dessus, a = b, mais intMap.get(a) == intMap.get(b). voir Il s'avère que lorsque nous interrogeons ou exploitons certaines valeurs du hashmap, elles sont transmises et mises en correspondance sous forme de valeurs, et non sous forme d'adresses mémoire.

Passage par adresse

S'il s'agit d'un type non natif, il sera transmis sous forme d'adresse mémoire. Par exemple :

//        存放非基础类型
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; 
    }
}

//Résultat de sortie
//map.containsKey(node1) = true
//map.containsKey(node2) = false

Comparaison de la taille de la mémoire

Type de base, un record La taille de la mémoire est la taille de la clé plus la taille de la valeur.

Pour les types non basiques, la taille de la mémoire d'un enregistrement est la taille de deux adresses, une adresse fait 8 octets et la clé et la valeur font 16 octets au total. La façon de calculer 🎜🎜Liste ordonnée (TreeMap)🎜.

🎜🎜La liste ordonnée sera classée par ordre croissant en fonction de la taille de la clé Nous pouvons l'utiliser pour faire hashmap Toutes les opérations dans le code>, et ont été étendus à l'opération de recherche de la première clé ou de la dernière clé, et également étendus à l'opération de recherche de la valeur maximale inférieure à un certain intervalle et de la valeur minimale supérieure à un certain intervalle🎜🎜🎜🎜Toutes les opérations La complexité temporelle est tout le niveau <code>O(logn). 🎜🎜🎜🎜Mais si la clé est un type non basique, elle ne peut pas être triée directement. Le type doit implémenter une interface de tri et avoir une fonction triable. Ou transmettez la méthode de comparaison lorsque le nouveau treeMap🎜🎜🎜🎜Opérations de type de base de stockage🎜rrreee🎜🎜//Les résultats de sortie sont les suivants🎜//treeMap.containsKey(3) = true 🎜//treeMap.containsKey(6) = false 🎜 //treeMap.get(3) = J'ai 3 ans 🎜//treeMap.get(3) = Il a 3 ans🎜//treeMap.get(3) = null🎜//treeMap.firstKey() = 0🎜/ /treeMap .lastKey() = 9🎜//treeMap.floorKey(5) = 5🎜//treeMap.floorKey(6) = 5🎜//treeMap.ceilingKey(4) = 5🎜🎜🎜Stockage de types non basiques pour opérations🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!