Java Set集合及Map集合详解

news/2024/12/1 0:42:54/

一、LinkedHashSet使用

1.1知识点：

 HashSet怎么使用LinkedHashSet就怎么使用 

 1.2直接上代码，可以和前面的文章做对比

package com.qf.linkedhashset_class;import java.util.LinkedHashSet;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;public class Test01 {public static void main(String[] args) {/*** class LinkedHashSet extends HashSet* HashSet怎么使用，LinkedHashSet就怎么使用*///创建LinkedHashSet集合对象LinkedHashSet<String> set = new LinkedHashSet<>();//添加元素set.add("椎名空");set.add("李林俊");set.add("天使萌");set.add("佐佐木希");set.add("古川伊织");set.add("京香Julia");//将newSet1中所有的元素添加到set集合LinkedHashSet<String> newSet1 = new LinkedHashSet<>();Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用集合工具类对集合进行批量添加set.addAll(newSet1);//获取元素个数int size = set.size();System.out.println("获取元素个数：" + size);//清空集合中所有的元素//set.clear();System.out.println("判断集合中是否有指定元素：" + set.contains("天使萌"));//trueSystem.out.println("判断集合中是否有指定集合（判断包含关系）：" + set.containsAll(newSet1));//trueSystem.out.println("判断集合中是否没有元素：" + set.isEmpty());//false (true-没有元素 false-有元素)//依据元素删除元素set.remove("上原亚衣");//去除交集set.removeAll(newSet1);//保留交集LinkedHashSet<String> newSet2 = new LinkedHashSet<>();Collections.addAll(newSet2, "佐佐木希","古川伊织","天使萌","天使萌");set.retainAll(newSet2);//将集合转换为数组Object[] array = newSet2.toArray();System.out.println(Arrays.toString(array));System.out.println("---------------");//遍历1 - foreachfor (String element : set) {System.out.println(element);}System.out.println("---------------");//遍历2 - IteratorIterator<String> it = set.iterator();while(it.hasNext()){//判断是否有下一个可迭代的元素String next = it.next();//返回下一个元素System.out.println(next);}}
}

 1.3 LinkedHashSet特点

有序排序 + 去重

存储数据：
        1.获取对象的hash值
        2.通过hash值+散列算法获取到数组中的下标
        3.将元素添加到节点对象中（节点对象-双向链表）
取出数据：
        获取到第一个节点对象，再依次循环到下一个节点（有序的）  

 1.3.1 Node部分底层

package com.qf.linkedhashset_class;public class Node<E> {private E e;//元素private Node<E> prev;//上一个节点的地址private Node<E> next;//下一个节点的地址public Node() {}public Node(E e, Node<E> prev, Node<E> next) {this.e = e;this.prev = prev;this.next = next;}public E getE() {return e;}public void setE(E e) {this.e = e;}public Node<E> getPrev() {return prev;}public void setPrev(Node<E> prev) {this.prev = prev;}public Node<E> getNext() {return next;}public void setNext(Node<E> next) {this.next = next;}@Overridepublic String toString() {return e + "";}
}

package com.qf.linkedhashset_class;import java.util.LinkedHashSet;public class Test02 {public static void main(String[] args) {LinkedHashSet<String> set = new LinkedHashSet<>();set.add("椎名空");set.add("张三");set.add("天使萌");set.add("佐佐木希");set.add("古川伊织");set.add("京香Julia");set.add("京香Julia");for (String str : set) {System.out.println(str);}System.out.println("-------------");//稍微理解下双向链表//当前节点可以找到上一个节点，也可以找到下一个节点Node<String> node1 = new Node<>("椎名空", null, null);Node<String> node2 = new Node<>("张三", null, null);Node<String> node3 = new Node<>("天使萌", null, null);node1.setNext(node2);node2.setPrev(node1);node2.setNext(node3);node3.setPrev(node2);Node<String> first = node1;while(first != null){System.out.println(first);first = first.getNext();}}
}

1.4 TreeSet使用方法

 其实TreeSet的使用和LinkedHashSet的使用大同小异

 1.4.1TeeSet使用代码

package com.qf.treeset_class;import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;public class Test01 {public static void main(String[] args) {//创建TreeSet集合对象TreeSet<String> set = new TreeSet<>();//添加元素set.add("椎名空");set.add("李林俊");set.add("天使萌");set.add("佐佐木希");set.add("古川伊织");set.add("京香Julia");//将newSet1中所有的元素添加到set集合TreeSet<String> newSet1 = new TreeSet<>();Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用集合工具类对集合进行批量添加set.addAll(newSet1);//获取元素个数int size = set.size();System.out.println("获取元素个数：" + size);//清空集合中所有的元素//set.clear();System.out.println("判断集合中是否有指定元素：" + set.contains("天使萌"));//trueSystem.out.println("判断集合中是否有指定集合（判断包含关系）：" + set.containsAll(newSet1));//trueSystem.out.println("判断集合中是否没有元素：" + set.isEmpty());//false (true-没有元素 false-有元素)//依据元素删除元素set.remove("上原亚衣");//去除交集set.removeAll(newSet1);//保留交集TreeSet<String> newSet2 = new TreeSet<>();Collections.addAll(newSet2, "佐佐木希","古川伊织","天使萌","天使萌");set.retainAll(newSet2);//将集合转换为数组Object[] array = newSet2.toArray();System.out.println(Arrays.toString(array));System.out.println("---------------");//遍历1 - foreachfor (String element : set) {System.out.println(element);}System.out.println("---------------");//遍历2 - IteratorIterator<String> it = set.iterator();while(it.hasNext()){//判断是否有下一个可迭代的元素String next = it.next();//返回下一个元素System.out.println(next);}}}

1.5 TreeSet自身特点

自然排序 - 根究不同的类型自动找到对应的排序规则 

package com.qf.treeset_class;import java.util.TreeSet;public class Test02 {public static void main(String[] args) {//TreeSet存储String的排序方式：字典排序TreeSet<String> set1 = new TreeSet<>();set1.add("b");set1.add("d");set1.add("a");set1.add("c");set1.add("c");for (String element : set1) {System.out.println(element);}//TreeSet存储Integer的排序方式：数字升序TreeSet<Integer> set2 = new TreeSet<>();set2.add(5);set2.add(1);set2.add(3);set2.add(2);set2.add(4);set2.add(4);for (Integer element : set2) {System.out.println(element);}}
}

1.6 重点（内置比较器 - Comparable）

1.创建一个学生类实现 Comparable 接口方法

2.实现排序规则（排序规则按照自己的需求写）

package com.qf.treeset_class;public class Student implements Comparable<Student>{private String name;private char sex;private int age;private String classId;private String id;public Student() {}public Student(String name, char sex, int age, String classId, String id) {this.name = name;this.sex = sex;this.age = age;this.classId = classId;this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getClassId() {return classId;}public void setClassId(String classId) {this.classId = classId;}public String getId() {return id;}public void setId(String id) {this.id = id;}@Overridepublic boolean equals(Object obj) {if(this == obj){return true;}if(obj instanceof Student){Student stu = (Student) obj;if(this.classId.equals(stu.classId) && this.id.equals(stu.id)){return true;}}return false;}@Overridepublic String toString() {return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id + "]";}//排序规则：按照年龄排序@Overridepublic int compareTo(Student o) {return this.age - o.age;//this.age 是传进来的值 o.age 是上一个根节点的值}
}

package com.qf.treeset_class;import java.util.TreeSet;public class Test03 {public static void main(String[] args) {/*** 知识点：内置比较器 - Comparable*/TreeSet<Student> set = new TreeSet<>();set.add(new Student("天海翼", '女', 28, "2204", "001"));set.add(new Student("天使萌", '女', 21, "2204", "002"));set.add(new Student("水菜丽", '女', 25, "2204", "003"));set.add(new Student("佐佐木希", '女', 22, "2204", "004"));set.add(new Student("上原亚衣", '女', 27, "2204", "005"));set.add(new Student("濑亚美莉", '女', 18, "2204", "006"));set.add(new Student("深田咏美", '女', 23, "2204", "007"));set.add(new Student("泷泽萝拉", '女', 25, "2204", "008"));set.add(new Student("冲田杏梨", '女', 27, "2204", "009"));for (Student stu : set) {System.out.println(stu);}}
}

1.7外置比较器 - Comparator 

1.7.1使用条件 

 当内置比较器不满足排序规则时使用外置比较器（使用匿名内部类）

package com.qf.treeset_class;import java.util.Comparator;
import java.util.TreeSet;public class Test04 {public static void main(String[] args) {/*** 知识点：外置比较器 - Comparator* * 应用场景：* 			联合开发* * Comparable vs Comparator* 优先级别：Comparator > Comparable*/TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {//排序规则：按照名字长度排序，名字长度一致按照年龄排序@Overridepublic int compare(Student o1, Student o2) {if(o1.equals(o2)){return 0;}int nameLen1 = o1.getName().length();int nameLen2 = o2.getName().length();if(nameLen1 != nameLen2){return nameLen1 - nameLen2;}int age1 = o1.getAge();int age2 = o2.getAge();if(age1 != age2){return age1 - age2;}return 1;}});set.add(new Student("水菜丽", '女', 25, "2204", "003"));set.add(new Student("佐佐木希", '女', 22, "2204", "004"));set.add(new Student("天使萌", '女', 21, "2204", "002"));set.add(new Student("上原亚衣", '女', 27, "2204", "005"));set.add(new Student("濑亚美莉", '女', 18, "2204", "006"));set.add(new Student("天海翼", '女', 28, "2204", "001"));set.add(new Student("深田咏美", '女', 23, "2204", "007"));set.add(new Student("泷泽萝拉", '女', 25, "2204", "008"));set.add(new Student("冲田杏梨", '女', 27, "2204", "009"));set.add(new Student("冲田杏梨", '女', 27, "2204", "009"));for (Student stu : set) {System.out.println(stu);}}
}

 1.8二叉树（图片来着网络）

 二、HashMap

package com.qf.hashmap_class;import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;public class Test01 {public static void main(String[] args) {/*** 知识点：HashMap的使用* * 特点：无序 + key唯一(去重)*///创建HashMap对象HashMap<String, Integer> map = new HashMap<>();//添加数据Integer put1 = map.put("麻生希", 28);Integer put2 = map.put("椎名空", 23);Integer put3 = map.put("天使萌", 26);Integer put4 = map.put("水菜丽", 26);Integer put5 = map.put("爱田奈奈", 25);Integer put6 = map.put("小峰由衣", 29);System.out.println(put1);//nullSystem.out.println(put2);//nullSystem.out.println(put3);//nullSystem.out.println(put4);//nullSystem.out.println(put5);//nullSystem.out.println(put6);//null//将newMap集合添加到map集合中HashMap<String, Integer> newMap = new HashMap<>();newMap.put("aaa", 10);newMap.put("bbb", 20);newMap.put("ccc", 30);newMap.put("ccc", 40);map.putAll(newMap);//如果集合中有该key就获取对应的value值//如果集合中没有该key就添加数据Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);System.out.println("putIfAbsent -- " + putIfAbsent);//替换数据 -- 返回被替换的值Integer put7 = map.put("小峰由衣", 30);System.out.println(put7);//29//根据Key替换数据 -- 返回被替换的值Integer replace1 = map.replace("小峰由衣", 31);System.out.println(replace1);//30//根据Key+Value替换数据boolean replace2 = map.replace("小峰由衣", 31, 32);System.out.println(replace2);//true//通过key获取到valueInteger integer1 = map.get("天使萌");System.out.println("通过key获取到value：" + integer1);//通过key获取到value，如果key不存在则返回默认值Integer integer2 = map.getOrDefault("天使萌111", 888);System.out.println("通过key获取到value，如果key不存在则返回默认值：" + integer2);//清空集合中的数据//map.clear();System.out.println("判断集合中是否包含某个key：" + map.containsKey("天使萌"));System.out.println("判断集合中是否包含某个value：" + map.containsValue(26));System.out.println("判断集合是否没有元素：" + map.isEmpty());//删除元素map.remove("椎名空1");//通过key删除映射关系map.remove("小峰由衣", 32);//通过key+value删除映射关系System.out.println("获取元素（映射关系）个数：" + map.size());//获取map中所有的value，返回一个Collection集合Collection<Integer> values = map.values();System.out.println(Arrays.toString(values.toArray()));System.out.println("-----------------");//遍历1 -- keySet()//遍历思路：//	1.将map中所有的key获取出并存放在Set集合中//	2.遍历Set集合，依次取出key，再使用map.get(key)获取出对应的value值Set<String> keySet = map.keySet();for (String key : keySet) {Integer value = map.get(key);System.out.println(key + " -- " + value);}System.out.println("-----------------");//遍历2 -- entrySet()//遍历思路：//	1.将map中所有的映射关系对象获取出并存放在Set集合中//	2.遍历Set集合，依次取出映射关系对象，映射关系对象中包含的key和value也就取出了Set<Entry<String, Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

三、LinkedHashMap的使用

package com.qf.linkedhashmap_class;import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;public class Test01 {public static void main(String[] args) {/*** 知识点：LinkedHashMap的使用* * 特点：有序 + key唯一(去重)*///创建LinkedHashMap对象LinkedHashMap<String, Integer> map = new LinkedHashMap<>();//添加数据Integer put1 = map.put("麻生希", 28);Integer put2 = map.put("椎名空", 23);Integer put3 = map.put("天使萌", 26);Integer put4 = map.put("水菜丽", 26);Integer put5 = map.put("爱田奈奈", 25);Integer put6 = map.put("小峰由衣", 29);System.out.println(put1);//nullSystem.out.println(put2);//nullSystem.out.println(put3);//nullSystem.out.println(put4);//nullSystem.out.println(put5);//nullSystem.out.println(put6);//null//将newMap集合添加到map集合中LinkedHashMap<String, Integer> newMap = new LinkedHashMap<>();newMap.put("aaa", 10);newMap.put("bbb", 20);newMap.put("ccc", 30);newMap.put("ccc", 40);map.putAll(newMap);//如果集合中有该key就获取对应的value值//如果集合中没有该key就添加数据Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);System.out.println("putIfAbsent -- " + putIfAbsent);//替换数据 -- 返回被替换的值Integer put7 = map.put("小峰由衣", 30);System.out.println(put7);//29//根据Key替换数据 -- 返回被替换的值Integer replace1 = map.replace("小峰由衣", 31);System.out.println(replace1);//30//根据Key+Value替换数据boolean replace2 = map.replace("小峰由衣", 31, 32);System.out.println(replace2);//true//通过key获取到valueInteger integer1 = map.get("天使萌");System.out.println("通过key获取到value：" + integer1);//通过key获取到value，如果key不存在则返回默认值Integer integer2 = map.getOrDefault("天使萌111", 888);System.out.println("通过key获取到value，如果key不存在则返回默认值：" + integer2);//清空集合中的数据//map.clear();System.out.println("判断集合中是否包含某个key：" + map.containsKey("天使萌"));System.out.println("判断集合中是否包含某个value：" + map.containsValue(26));System.out.println("判断集合是否没有元素：" + map.isEmpty());//删除元素map.remove("椎名空1");//通过key删除映射关系map.remove("小峰由衣", 32);//通过key+value删除映射关系System.out.println("获取元素（映射关系）个数：" + map.size());//获取map中所有的value，返回一个Collection集合Collection<Integer> values = map.values();System.out.println(Arrays.toString(values.toArray()));System.out.println("-----------------");//遍历1 -- keySet()//遍历思路：//	1.将map中所有的key获取出并存放在Set集合中//	2.遍历Set集合，依次取出key，再使用map.get(key)获取出对应的value值Set<String> keySet = map.keySet();for (String key : keySet) {Integer value = map.get(key);System.out.println(key + " -- " + value);}System.out.println("-----------------");//遍历2 -- entrySet()//遍历思路：//	1.将map中所有的映射关系对象获取出并存放在Set集合中//	2.遍历Set集合，依次取出映射关系对象，映射关系对象中包含的key和value也就取出了Set<Entry<String, Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

 四、Hashtable的使用

package com.qf.hashtable_class;import java.util.Arrays;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.Set;public class Test01 {public static void main(String[] args) {/*** 知识点：Hashtable的使用* * 特点：无序 + key唯一(去重) + 线程安全的（加锁）* * 注意：Hashtable方法上加锁，效率低，弃用*///创建Hashtable对象Hashtable<String, Integer> map = new Hashtable<>();//添加数据Integer put1 = map.put("麻生希", 28);Integer put2 = map.put("椎名空", 23);Integer put3 = map.put("天使萌", 26);Integer put4 = map.put("水菜丽", 26);Integer put5 = map.put("爱田奈奈", 25);Integer put6 = map.put("小峰由衣", 29);System.out.println(put1);//nullSystem.out.println(put2);//nullSystem.out.println(put3);//nullSystem.out.println(put4);//nullSystem.out.println(put5);//nullSystem.out.println(put6);//null//将newMap集合添加到map集合中Hashtable<String, Integer> newMap = new Hashtable<>();newMap.put("aaa", 10);newMap.put("bbb", 20);newMap.put("ccc", 30);newMap.put("ccc", 40);map.putAll(newMap);//如果集合中有该key就获取对应的value值//如果集合中没有该key就添加数据Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);System.out.println("putIfAbsent -- " + putIfAbsent);//替换数据 -- 返回被替换的值Integer put7 = map.put("小峰由衣", 30);System.out.println(put7);//29//根据Key替换数据 -- 返回被替换的值Integer replace1 = map.replace("小峰由衣", 31);System.out.println(replace1);//30//根据Key+Value替换数据boolean replace2 = map.replace("小峰由衣", 31, 32);System.out.println(replace2);//true//通过key获取到valueInteger integer1 = map.get("天使萌");System.out.println("通过key获取到value：" + integer1);//通过key获取到value，如果key不存在则返回默认值Integer integer2 = map.getOrDefault("天使萌111", 888);System.out.println("通过key获取到value，如果key不存在则返回默认值：" + integer2);//清空集合中的数据//map.clear();System.out.println("判断集合中是否包含某个key：" + map.containsKey("天使萌"));System.out.println("判断集合中是否包含某个value：" + map.containsValue(26));System.out.println("判断集合是否没有元素：" + map.isEmpty());//删除元素map.remove("椎名空1");//通过key删除映射关系map.remove("小峰由衣", 32);//通过key+value删除映射关系System.out.println("获取元素（映射关系）个数：" + map.size());//获取map中所有的value，返回一个Collection集合Collection<Integer> values = map.values();System.out.println(Arrays.toString(values.toArray()));System.out.println("-----------------");//遍历1 -- keySet()//遍历思路：//	1.将map中所有的key获取出并存放在Set集合中//	2.遍历Set集合，依次取出key，再使用map.get(key)获取出对应的value值Set<String> keySet = map.keySet();for (String key : keySet) {Integer value = map.get(key);System.out.println(key + " -- " + value);}System.out.println("-----------------");//遍历2 -- entrySet()//遍历思路：//	1.将map中所有的映射关系对象获取出并存放在Set集合中//	2.遍历Set集合，依次取出映射关系对象，映射关系对象中包含的key和value也就取出了Set<Entry<String, Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

五、ConcurrentHashMap的使用 

package com.qf.concurrenthashmap_class;import java.util.Arrays;
import java.util.Collection;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;public class Test01 {public static void main(String[] args) {/*** 知识点：ConcurrentHashMap的使用* * 特点：无序 + key唯一(去重) + 线程安全的（加锁）* * 注意：ConcurrentHashMap是局部加锁+CAS实现的线程安全，效率高*///创建ConcurrentHashMap对象ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();//添加数据Integer put1 = map.put("麻生希", 28);Integer put2 = map.put("椎名空", 23);Integer put3 = map.put("天使萌", 26);Integer put4 = map.put("水菜丽", 26);Integer put5 = map.put("爱田奈奈", 25);Integer put6 = map.put("小峰由衣", 29);System.out.println(put1);//nullSystem.out.println(put2);//nullSystem.out.println(put3);//nullSystem.out.println(put4);//nullSystem.out.println(put5);//nullSystem.out.println(put6);//null//将newMap集合添加到map集合中ConcurrentHashMap<String, Integer> newMap = new ConcurrentHashMap<>();newMap.put("aaa", 10);newMap.put("bbb", 20);newMap.put("ccc", 30);newMap.put("ccc", 40);map.putAll(newMap);//如果集合中有该key就获取对应的value值//如果集合中没有该key就添加数据Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);System.out.println("putIfAbsent -- " + putIfAbsent);//替换数据 -- 返回被替换的值Integer put7 = map.put("小峰由衣", 30);System.out.println(put7);//29//根据Key替换数据 -- 返回被替换的值Integer replace1 = map.replace("小峰由衣", 31);System.out.println(replace1);//30//根据Key+Value替换数据boolean replace2 = map.replace("小峰由衣", 31, 32);System.out.println(replace2);//true//通过key获取到valueInteger integer1 = map.get("天使萌");System.out.println("通过key获取到value：" + integer1);//通过key获取到value，如果key不存在则返回默认值Integer integer2 = map.getOrDefault("天使萌111", 888);System.out.println("通过key获取到value，如果key不存在则返回默认值：" + integer2);//清空集合中的数据//map.clear();System.out.println("判断集合中是否包含某个key：" + map.containsKey("天使萌"));System.out.println("判断集合中是否包含某个value：" + map.containsValue(26));System.out.println("判断集合是否没有元素：" + map.isEmpty());//删除元素map.remove("椎名空1");//通过key删除映射关系map.remove("小峰由衣", 32);//通过key+value删除映射关系System.out.println("获取元素（映射关系）个数：" + map.size());//获取map中所有的value，返回一个Collection集合Collection<Integer> values = map.values();System.out.println(Arrays.toString(values.toArray()));System.out.println("-----------------");//遍历1 -- keySet()//遍历思路：//	1.将map中所有的key获取出并存放在Set集合中//	2.遍历Set集合，依次取出key，再使用map.get(key)获取出对应的value值Set<String> keySet = map.keySet();for (String key : keySet) {Integer value = map.get(key);System.out.println(key + " -- " + value);}System.out.println("-----------------");//遍历2 -- entrySet()//遍历思路：//	1.将map中所有的映射关系对象获取出并存放在Set集合中//	2.遍历Set集合，依次取出映射关系对象，映射关系对象中包含的key和value也就取出了Set<Entry<String, Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

 六、HashMap vs LinkedHashMap vs Hashtable vs ConcurrentHashMap

HashMap：无序 + key去重 + 线程不安全
LinkedHashMap：有序 + key去重 + 线程不安全
Hashtable：无序 + key去重 + 线程安全（方法加锁，效率低，弃用）
ConcurrentHashMap：无序 + key去重 + 线程安全（局部加锁+CAS，效率高）
存储nullKey nullValue
HashMap                 Ok
LinkedHashMap         OK
Hashtable             NO
ConcurrentHashMap     NO 

七、TreeMap的使用

package com.qf.treemap_class;import java.util.Arrays;
import java.util.Collection;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.Set;public class Test01 {public static void main(String[] args) {/*** 知识点：TreeMap的使用*///创建TreeMap对象TreeMap<String, Integer> map = new TreeMap<>();//添加数据Integer put1 = map.put("麻生希", 28);Integer put2 = map.put("椎名空", 23);Integer put3 = map.put("天使萌", 26);Integer put4 = map.put("水菜丽", 26);Integer put5 = map.put("爱田奈奈", 25);Integer put6 = map.put("小峰由衣", 29);System.out.println(put1);//nullSystem.out.println(put2);//nullSystem.out.println(put3);//nullSystem.out.println(put4);//nullSystem.out.println(put5);//nullSystem.out.println(put6);//null//将newMap集合添加到map集合中TreeMap<String, Integer> newMap = new TreeMap<>();newMap.put("aaa", 10);newMap.put("bbb", 20);newMap.put("ccc", 30);newMap.put("ccc", 40);map.putAll(newMap);//如果集合中有该key就获取对应的value值//如果集合中没有该key就添加数据Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);System.out.println("putIfAbsent -- " + putIfAbsent);//替换数据 -- 返回被替换的值Integer put7 = map.put("小峰由衣", 30);System.out.println(put7);//29//根据Key替换数据 -- 返回被替换的值Integer replace1 = map.replace("小峰由衣", 31);System.out.println(replace1);//30//根据Key+Value替换数据boolean replace2 = map.replace("小峰由衣", 31, 32);System.out.println(replace2);//true//通过key获取到valueInteger integer1 = map.get("天使萌");System.out.println("通过key获取到value：" + integer1);//通过key获取到value，如果key不存在则返回默认值Integer integer2 = map.getOrDefault("天使萌111", 888);System.out.println("通过key获取到value，如果key不存在则返回默认值：" + integer2);//清空集合中的数据//map.clear();System.out.println("判断集合中是否包含某个key：" + map.containsKey("天使萌"));System.out.println("判断集合中是否包含某个value：" + map.containsValue(26));System.out.println("判断集合是否没有元素：" + map.isEmpty());//删除元素map.remove("椎名空1");//通过key删除映射关系map.remove("小峰由衣", 32);//通过key+value删除映射关系System.out.println("获取元素（映射关系）个数：" + map.size());//获取map中所有的value，返回一个Collection集合Collection<Integer> values = map.values();System.out.println(Arrays.toString(values.toArray()));System.out.println("-----------------");//遍历1 -- keySet()//遍历思路：//	1.将map中所有的key获取出并存放在Set集合中//	2.遍历Set集合，依次取出key，再使用map.get(key)获取出对应的value值Set<String> keySet = map.keySet();for (String key : keySet) {Integer value = map.get(key);System.out.println(key + " -- " + value);}System.out.println("-----------------");//遍历2 -- entrySet()//遍历思路：//	1.将map中所有的映射关系对象获取出并存放在Set集合中//	2.遍历Set集合，依次取出映射关系对象，映射关系对象中包含的key和value也就取出了Set<Entry<String, Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

7.1TreeMap的特点 

package com.qf.treemap_class;import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;public class Test02 {public static void main(String[] args) {/*** 知识点：TreeMap的特点* * 特点：针对于Key排序*/TreeMap<String, Integer> map = new TreeMap<>();map.put("c", 24);map.put("d", 28);map.put("a", 21);map.put("b", 23);map.put("b", 26);Set<Entry<String,Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

 7.3内置比较器

package com.qf.treemap_class;import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;import com.qf.treeset_class.Student;public class Test03 {public static void main(String[] args) {/*** 知识点：内置比较器*/TreeMap<Student, String> map = new TreeMap<>();map.put(new Student("水菜丽", '女', 25, "2204", "003"), "拍电影");map.put(new Student("佐佐木希", '女', 22, "2204", "004"), "吃马赛克");map.put(new Student("天使萌", '女', 21, "2204", "002"), "吹喇叭");map.put(new Student("上原亚衣", '女', 27, "2204", "005"), "骑马");map.put(new Student("濑亚美莉", '女', 18, "2204", "006"), "交朋友");map.put(new Student("天海翼", '女', 28, "2204", "001"), "按摩");map.put(new Student("深田咏美", '女', 23, "2204", "007"), "写代码");map.put(new Student("泷泽萝拉", '女', 25, "2204", "008"), "看书");map.put(new Student("冲田杏梨", '女', 27, "2204", "009"), "补课");Set<Entry<Student,String>> entrySet = map.entrySet();for (Entry<Student, String> entry : entrySet) {System.out.println(entry);}}
}

7.4外置比较器

package com.qf.treemap_class;import java.util.Map.Entry;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;import com.qf.treeset_class.Student;public class Test04 {public static void main(String[] args) {/*** 知识点：外置比较器*/TreeMap<Student, String> map = new TreeMap<>(new Comparator<Student>() {//排序规则：按照名字长度排序，名字长度一致按照年龄排序@Overridepublic int compare(Student o1, Student o2) {if(o1.equals(o2)){return 0;}int nameLen1 = o1.getName().length();int nameLen2 = o2.getName().length();if(nameLen1 != nameLen2){return nameLen1 - nameLen2;}int age1 = o1.getAge();int age2 = o2.getAge();if(age1 != age2){return age1 - age2;}return 1;}});map.put(new Student("水菜丽", '女', 25, "2204", "003"), "拍电影");map.put(new Student("佐佐木希", '女', 22, "2204", "004"), "吃马赛克");map.put(new Student("天使萌", '女', 21, "2204", "002"), "吹喇叭");map.put(new Student("上原亚衣", '女', 27, "2204", "005"), "骑马");map.put(new Student("濑亚美莉", '女', 18, "2204", "006"), "交朋友");map.put(new Student("天海翼", '女', 28, "2204", "001"), "按摩");map.put(new Student("深田咏美", '女', 23, "2204", "007"), "写代码");map.put(new Student("泷泽萝拉", '女', 25, "2204", "008"), "看书");map.put(new Student("冲田杏梨", '女', 27, "2204", "009"), "补课");Set<Entry<Student,String>> entrySet = map.entrySet();for (Entry<Student, String> entry : entrySet) {System.out.println(entry);}}
}

 八、Hashtable的使用（弃用，作为了解）

package com.qf.hashtable_class;import java.util.Arrays;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.Set;public class Test01 {public static void main(String[] args) {/*** 知识点：Hashtable的使用* * 特点：无序 + key唯一(去重) + 线程安全的（加锁）* * 注意：Hashtable方法上加锁，效率低，弃用*///创建Hashtable对象Hashtable<String, Integer> map = new Hashtable<>();//添加数据Integer put1 = map.put("麻生希", 28);Integer put2 = map.put("椎名空", 23);Integer put3 = map.put("天使萌", 26);Integer put4 = map.put("水菜丽", 26);Integer put5 = map.put("爱田奈奈", 25);Integer put6 = map.put("小峰由衣", 29);System.out.println(put1);//nullSystem.out.println(put2);//nullSystem.out.println(put3);//nullSystem.out.println(put4);//nullSystem.out.println(put5);//nullSystem.out.println(put6);//null//将newMap集合添加到map集合中Hashtable<String, Integer> newMap = new Hashtable<>();newMap.put("aaa", 10);newMap.put("bbb", 20);newMap.put("ccc", 30);newMap.put("ccc", 40);map.putAll(newMap);//如果集合中有该key就获取对应的value值//如果集合中没有该key就添加数据Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);System.out.println("putIfAbsent -- " + putIfAbsent);//替换数据 -- 返回被替换的值Integer put7 = map.put("小峰由衣", 30);System.out.println(put7);//29//根据Key替换数据 -- 返回被替换的值Integer replace1 = map.replace("小峰由衣", 31);System.out.println(replace1);//30//根据Key+Value替换数据boolean replace2 = map.replace("小峰由衣", 31, 32);System.out.println(replace2);//true//通过key获取到valueInteger integer1 = map.get("天使萌");System.out.println("通过key获取到value：" + integer1);//通过key获取到value，如果key不存在则返回默认值Integer integer2 = map.getOrDefault("天使萌111", 888);System.out.println("通过key获取到value，如果key不存在则返回默认值：" + integer2);//清空集合中的数据//map.clear();System.out.println("判断集合中是否包含某个key：" + map.containsKey("天使萌"));System.out.println("判断集合中是否包含某个value：" + map.containsValue(26));System.out.println("判断集合是否没有元素：" + map.isEmpty());//删除元素map.remove("椎名空1");//通过key删除映射关系map.remove("小峰由衣", 32);//通过key+value删除映射关系System.out.println("获取元素（映射关系）个数：" + map.size());//获取map中所有的value，返回一个Collection集合Collection<Integer> values = map.values();System.out.println(Arrays.toString(values.toArray()));System.out.println("-----------------");//遍历1 -- keySet()//遍历思路：//	1.将map中所有的key获取出并存放在Set集合中//	2.遍历Set集合，依次取出key，再使用map.get(key)获取出对应的value值Set<String> keySet = map.keySet();for (String key : keySet) {Integer value = map.get(key);System.out.println(key + " -- " + value);}System.out.println("-----------------");//遍历2 -- entrySet()//遍历思路：//	1.将map中所有的映射关系对象获取出并存放在Set集合中//	2.遍历Set集合，依次取出映射关系对象，映射关系对象中包含的key和value也就取出了Set<Entry<String, Integer>> entrySet = map.entrySet();for (Entry<String, Integer> entry : entrySet) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key + " -- " + value);}}
}

九、Properties

package com.qf.properties_class;import java.io.IOException;
import java.util.Properties;public class Test01 {public static void main(String[] args) throws IOException {/*** 知识点：Properties* 含义：配置文件类* * 注意：配置文件创建在src目录下*///创建配置文件对象Properties p = new Properties();//加载配置文件p.load(Test01.class.getClassLoader().getResourceAsStream("DBConfig.properties"));//获取配置文件中的数据String username = p.getProperty("username");String password = p.getProperty("password");System.out.println(username + " -- " + password);}
}

http://www.ppmy.cn/news/160816.html

相关文章

世上最全的map集合体系的使用方法---喜欢请收藏

世上最全的map集合体系的使用方法---喜欢请收藏

1.知识点&#xff1a;使用LinkedHashSet的方法 /*** 知识点&#xff1a;使用LinkedHashSet的方法* * class LinkedHashSet extends HashSet* HashSet怎么使用&#xff0c;LinkedHashSet就怎么使用*///创建LinkedHashSet集合对象LinkedHashSet<String> set new LinkedHa…
阅读更多...
【PS3】二之国 白色圣灰的女王 日本制造的视觉效果

【PS3】二之国 白色圣灰的女王 日本制造的视觉效果

原文&#xff1a;http://www.element3ds.com/thread-29245-1-1.html 二之国 白色圣灰的女王 走向RPG的王道 日本制造的视觉效果 本作用CG再现了吉卜力工作室的温暖世界观。 作为把以前只能在电影作品中看到的世界积极运作的杰作&#xff0c;成为一个大话题。 这次因为在Level…
阅读更多...
后台(11)——Servlet（3）

后台(11)——Servlet（3）

探索Android软键盘的疑难杂症 深入探讨Android异步精髓Handler 详解Android主流框架不可或缺的基石 站在源码的肩膀上全解Scroller工作机制 Android多分辨率适配框架&#xff08;1&#xff09;— 核心基础 Android多分辨率适配框架&#xff08;2&#xff09;— 原理剖析 A…
阅读更多...
图书排行：计算机书籍每周销量排行榜

图书排行：计算机书籍每周销量排行榜

LSGO软件技术团队每个 星期一&#xff0c;统计 京东网、当当网、互动出版社、中国图书网 关于计算机类书籍销量的 7日 排行数据&#xff0c;大家可参考这份排行来挑选技术书籍。 数据统计时间&#xff1a;2019/05/27 至 2019/06/02 京东网 Top01&#xff1a;数学之美&#xf…
阅读更多...
读书笔记8 《所谓情商高，就是会说话》 佐佐木圭一

读书笔记8 《所谓情商高，就是会说话》 佐佐木圭一

人的行为意愿&#xff0c;会受到措辞的影响 不直接说——揣摩对方心思——符合双方利益的措辞&#xff08;双赢思维&#xff09; 把NO变成YES的技巧&#xff1a; 1、“投其所好” 技能获得对方的好感&#xff0c;又能实现自己的期望 2、“儆其所恶” 能形成强大的强制力&am…
阅读更多...
【C# 10 和 .NET 6】使用MVC模式构建网站（笔记1）

【C# 10 和 .NET 6】使用MVC模式构建网站（笔记1）

Building Websites Using the Model-View-Controller Pattern 使用模型-视图-控制器模式构建网站 本章介绍使用 Microsoft ASP.NET Core MVC 在服务器端构建具有现代 HTTP 架构的网站&#xff0c;包括构成 ASP.NET Core MVC 项目的启动配置、身份验证、授权、路由、请求和响应管…
阅读更多...
8个SQL优化要点，性能降低100倍

8个SQL优化要点，性能降低100倍

今天给大家分享几个SQL优化技巧 一、limit语句 分页查询是最常用的场景之一&#xff0c;但也通常也是最容易出问题的地方。比如对于下面简单的语句&#xff0c;一般 DBA 想到的办法是在 type, name, create_time 字段上加组合索引。这样条件排序都能有效的利用到索引&#xf…
阅读更多...
【图论基础数据结构及其应用】

【图论基础数据结构及其应用】

本文主要介绍Java中图论基础数据结构的基本原理、实现方式以及使用场景。图论是研究非线性方程组及其解的数学领域&#xff0c;广泛应用于计算机科学中&#xff0c;如网络拓扑、交通网络、地理信息系统等。 一、图的基本概念 图是由节点&#xff08;Vertex&#xff09;和边&a…
阅读更多...
最新文章

Copyright @ 2022~2023