Java Set集合及Map集合详解
一、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 set = new LinkedHashSet<>();
//添加元素
set.add("椎名空");
set.add("李林俊");
set.add("天使萌");
set.add("佐佐木希");
set.add("古川伊织");
set.add("京香Julia");
//将newSet1中所有的元素添加到set集合
LinkedHashSet 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("天使萌"));//true
System.out.println("判断集合中是否有指定集合（判断包含关系）：" + set.containsAll(newSet1));//true
System.out.println("判断集合中是否没有元素：" + set.isEmpty());//false (true-没有元素 false-有元素)
//依据元素删除元素
set.remove("上原亚衣");
//去除交集
set.removeAll(newSet1);
//保留交集
LinkedHashSet newSet2 = new LinkedHashSet<>();
Collections.addAll(newSet2, "佐佐木希","古川伊织","天使萌","天使萌");
set.retainAll(newSet2);
//将集合转换为数组
Object[] array = newSet2.toArray();
System.out.println(Arrays.toString(array));
System.out.println("---------------");
//遍历1 - foreach
for (String element : set) {
System.out.println(element);
}
System.out.println("---------------");
//遍历2 - Iterator
Iterator 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 {
private E e;//元素
private Node prev;//上一个节点的地址
private Node next;//下一个节点的地址
public Node() {
}
public Node(E e, Node prev, Node 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 getPrev() {
return prev;
}
public void setPrev(Node prev) {
this.prev = prev;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return e + "";
}
}
package com.qf.linkedhashset_class;
import java.util.LinkedHashSet;
public class Test02 {
public static void main(String[] args) {
LinkedHashSet 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 node1 = new Node<>("椎名空", null, null);
Node node2 = new Node<>("张三", null, null);
Node node3 = new Node<>("天使萌", null, null);
node1.setNext(node2);
node2.setPrev(node1);
node2.setNext(node3);
node3.setPrev(node2);
Node 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 set = new TreeSet<>();
//添加元素
set.add("椎名空");
set.add("李林俊");
set.add("天使萌");
set.add("佐佐木希");
set.add("古川伊织");
set.add("京香Julia");
//将newSet1中所有的元素添加到set集合
TreeSet 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("天使萌"));//true
System.out.println("判断集合中是否有指定集合（判断包含关系）：" + set.containsAll(newSet1));//true
System.out.println("判断集合中是否没有元素：" + set.isEmpty());//false (true-没有元素 false-有元素)
//依据元素删除元素
set.remove("上原亚衣");
//去除交集
set.removeAll(newSet1);
//保留交集
TreeSet newSet2 = new TreeSet<>();
Collections.addAll(newSet2, "佐佐木希","古川伊织","天使萌","天使萌");
set.retainAll(newSet2);
//将集合转换为数组
Object[] array = newSet2.toArray();
System.out.println(Arrays.toString(array));
System.out.println("---------------");
//遍历1 - foreach
for (String element : set) {
System.out.println(element);
}
System.out.println("---------------");
//遍历2 - Iterator
Iterator 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 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 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{
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;
}
@Override
public 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;
}
@Override
public String toString() {
return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id + "]";
}
//排序规则：按照年龄排序
@Override
public 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 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 set = new TreeSet<>(new Comparator() {
//排序规则：按照名字长度排序，名字长度一致按照年龄排序
@Override
public 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 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);//null
System.out.println(put2);//null
System.out.println(put3);//null
System.out.println(put4);//null
System.out.println(put5);//null
System.out.println(put6);//null
//将newMap集合添加到map集合中
HashMap 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获取到value
Integer 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 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 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> entrySet = map.entrySet();
for (Entry 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 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);//null
System.out.println(put2);//null
System.out.println(put3);//null
System.out.println(put4);//null
System.out.println(put5);//null
System.out.println(put6);//null
//将newMap集合添加到map集合中
LinkedHashMap 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获取到value
Integer 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 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 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> entrySet = map.entrySet();
for (Entry 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 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);//null
System.out.println(put2);//null
System.out.println(put3);//null
System.out.println(put4);//null
System.out.println(put5);//null
System.out.println(put6);//null
//将newMap集合添加到map集合中
Hashtable 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获取到value
Integer 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 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 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> entrySet = map.entrySet();
for (Entry 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 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);//null
System.out.println(put2);//null
System.out.println(put3);//null
System.out.println(put4);//null
System.out.println(put5);//null
System.out.println(put6);//null
//将newMap集合添加到map集合中
ConcurrentHashMap 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获取到value
Integer 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 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 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> entrySet = map.entrySet();
for (Entry 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 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);//null
System.out.println(put2);//null
System.out.println(put3);//null
System.out.println(put4);//null
System.out.println(put5);//null
System.out.println(put6);//null
//将newMap集合添加到map集合中
TreeMap 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获取到value
Integer 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 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 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> entrySet = map.entrySet();
for (Entry 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 map = new TreeMap<>();
map.put("c", 24);
map.put("d", 28);
map.put("a", 21);
map.put("b", 23);
map.put("b", 26);
Set> entrySet = map.entrySet();
for (Entry 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 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> entrySet = map.entrySet();
for (Entry 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 map = new TreeMap<>(new Comparator() {
//排序规则：按照名字长度排序，名字长度一致按照年龄排序
@Override
public 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> entrySet = map.entrySet();
for (Entry 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 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);//null
System.out.println(put2);//null
System.out.println(put3);//null
System.out.println(put4);//null
System.out.println(put5);//null
System.out.println(put6);//null
//将newMap集合添加到map集合中
Hashtable 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获取到value
Integer 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 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 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> entrySet = map.entrySet();
for (Entry 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);
}
}