05※、Map集合介绍、HashMap、Hashtable、LinkedHashMap、Properties和Collections

Map介绍

Map集合：
什么是 Map ?
–map 是指一种用来存放映射关系数据的容器。
什么是映射关系 ?
–映射关系是指用一个键, 与一个值所组成的关系对一个键对应到一个值, 这个键是不能重复的， 所以, 通过键就能找到对应的值。

HashMap [无序、不能重复、散列表]

 [1] 是一个线程不安全的 Map 实现类
 [2] 允许插入值为 null 的 key
1
2

HashMap：无序 不能重复（key不能重复，如果有出现重复的则后面的覆盖前面的数据）
–使用put方法添加键值对数据，其中key可以为null

注意:Entry 不要导包错误了 import java.util.Map.Entry;

/**
 * @author Lantzrung
 * @date 2022年7月26日
 * @Description
 */
package day0726;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
	// HashMap的使用 【线程不安全的】
	// 【无序的、key不重复、value可以重复】 key可以为null
	Map map = new HashMap<>();

	// 使用put添加键值对 [key和value都是引用类型的数据]
	map.put("一等奖", "双开门冰箱");
	map.put("二等奖", "普通冰箱");
	map.put("三等奖", "电饭煲");
	map.put("四等奖", "热水壶");
	map.put("五等奖", "水杯");
	map.put("特等奖", "水杯");

	System.out.println(map);// {三等奖=电饭煲, 五等奖=水杯, 一等奖=双开门冰箱, 特等奖=水杯, 四等奖=热水壶, 二等奖=普通冰箱}

	// 根据key获取value
	System.out.println(map.get("四等奖"));
	// 删除 可以根据key删除或者根据key和value删除
	map.remove("特等奖");
	System.out.println(map.get("特等奖"));// key不存在，则获取到null
	//
	System.out.println(map);

	// 实现map的遍历
	// 1、foreach 使用map的keySet方法获取key的set集合
	Set keys = map.keySet();
	for (Object key : keys) {
	    System.out.println("key==" + key + " ,  value==" + map.get(key));
	}
	/*
	 * key==三等奖 , value==电饭煲 key==五等奖 , value==水杯 key==一等奖 , value==双开门冰箱 key==四等奖 ,
	 * value==热水壶 key==二等奖 , value==普通冰箱
	 */
	// 使用map的values方法获取value的Collection集合
	Collection values = map.values();
	for (Object value : values) {
	    System.out.println(value);
	}
	/*
	 * 电饭煲 水杯 双开门冰箱 热水壶 普通冰箱
	 */

	// 2、遍历Entry来获取map 的k-v的数据
	// Map.Entry entrys = map.entrySet();
	Set entrys = map.entrySet();
	for (Object object : entrys) {
	    // Entry是map中提供的封装类
	    Map.Entry entry = (Entry) object;
	    //
	    System.out.println("key==" + entry.getKey() + "  , value==" + entry.getValue());
	}
	// key==三等奖 , value==电饭煲
	// key==五等奖 , value==水杯
	// key==一等奖 , value==双开门冰箱
	// key==四等奖 , value==热水壶
	// key==二等奖 , value==普通冰箱
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

Hashtable[无序、不能重复、散列表]

 [1] 是一个线程安全的 Map 实现类
 [2] 不允许插入值为 null 的 key
1
2

HashTable：无序 不能重复（key不能重复，如果有出现重复的则后面的覆盖前面的数据）
–使用put方法添加键值对数据，其中key不可以为null
Hashtable 特性
[1] 是一个线程安全的 Map 实现类
[2] 为了保证同步性, 性能比 HashMap 要差
[3] 不允许插入值为 null 的 key
[4] 底层使用散列表的存储方式(与 HashMap一致)

/**
 * @author Lantzrung
 * @date 2022年7月31日
 * @Description
 */
package com.day0729;

import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;

public class HashTableDemo {
    public static void main(String[] args) {
	// Hashtable的使用 【线程安全】 key不能为null
	// 【无序的、key不重复、value可以重复】
	Hashtable map = new Hashtable<>();

	// 使用put添加键值对 [key和value都是引用类型的数据] 如果key存在则是替换value操作
	map.put("一等奖", "双开门冰箱");
	map.put("二等奖", "普通冰箱");
	map.put("三等奖", "电饭煲");
	map.put("四等奖", "热水壶");
	map.put("五等奖", "水杯");
	map.put("特等奖", "水杯");
	// map.put(null, "鼠标");
	// 出现空指针报错
	// Exception in thread "main" java.lang.NullPointerException
	// at java.util.Hashtable.put(Hashtable.java:464)
	// at com.day0729.HashTableDemo.main(HashTableDemo.java:34)

	System.out.println(map);// {三等奖=电饭煲, 五等奖=水杯, 一等奖=双开门冰箱, 特等奖=水杯, 四等奖=热水壶, 二等奖=普通冰箱}

	// 根据key获取value
	System.out.println(map.get("四等奖"));
	// 删除 可以根据key删除或者根据key和value删除
	map.remove("特等奖");
	System.out.println(map.get("特等奖"));// key不存在，则获取到null
	//
	System.out.println(map);

	// 实现map的遍历
	Enumeration enumer = map.keys();
	while (enumer.hasMoreElements()) {
	    Object key = (Object) enumer.nextElement();
	    System.out.println("key==" + key + ",vaule==" + map.get(key));
	}
	// key==一等奖,vaule==双开门冰箱
	// key==二等奖,vaule==普通冰箱
	// key==五等奖,vaule==水杯
	// key==四等奖,vaule==热水壶
	// key==三等奖,vaule==电饭煲

	Enumeration enumer1 = map.elements();// value
	while (enumer1.hasMoreElements()) {
	    Object value = enumer1.nextElement();
	    System.out.println("value==" + value);
	}
	// value==双开门冰箱
	// value==普通冰箱
	// value==水杯
	// value==热水壶
	// value==电饭煲
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

LinkedHashMap[无序、key不重复、value可以重复、链表]

LinkedHashMap通过链表来维护了数据插入的顺序 （和LinkedHashSet类似）
[1] 【无序的、key不重复、value可以重复】

/**
 * @author Lantzrung
 * @date 2022年7月26日
 * @Description
 */
package day0726;

import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class LinkedHashMapDemo {
    public static void main(String[] args) {
	// LinkedHashMapDemo的使用 【通过链表维护】
	// 【无序的、key不重复、value可以重复】
	LinkedHashMap map = new LinkedHashMap();

	// 使用put添加键值对 [key和value都是引用类型的数据] 如果key存在则是替换value操作
	map.put("一等奖", "双开门冰箱");
	map.put("二等奖", "普通冰箱");
	map.put("三等奖", "电饭煲");
	map.put("四等奖", "热水壶");
	map.put("五等奖", "水杯");
	map.put(null, "鼠标");
	// 输出结果
	System.out.println(map);
	// {一等奖=双开门冰箱, 二等奖=普通冰箱, 三等奖=电饭煲, 四等奖=热水壶, 五等奖=水杯, null=鼠标}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

TreeMap通过二叉树结构进行存储（和TreeSet类似），是根据key来进行排序的，注意TreeMap中key需要实现可比较接口，value不需要

/**
 * @author Lantzrung
 * @date 2022年7月31日
 * @Description
 */

import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
	// TreeMap和TreeSet是类似的，但是要注意key来进行排序
	// 都是可以--定制排序--自然排序
	TreeMap treeMap = new TreeMap<>();
	//
	treeMap.put(new Student("001", "zhang", 18), "001");
	treeMap.put(new Student("002", "zhang", 13), "二");
	treeMap.put(new Student("003", "li", 28), "003");
	treeMap.put(new Student("004", "wang", 28), "四");
	// 输出结果 使用了定制排序 用来比较id 降序
	System.out.println(treeMap);// {Student [id=004, name=wang, age=28]=四, Student [id=003, name=li, age=28]=003, Student [id=002, name=zhang, age=13]=二, Student [id=001, name=zhang, age=18]=001}

    }
}

class Student implements Comparable {
    public String id;
    public String name;
    public int age;

    @Override
    public int compareTo(Object o) {
	Student s = (Student) o;
	return s.id.compareTo(id);
    }

    public Student(String d, String n, int i) {
	super();
	this.id = d;
	this.name = n;
	this.age = i;
    }

    public Student() {
	super();
    }

    @Override
    public String toString() {
	return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

Properties 属性文件键值对类型

Properties 属性文件键值对类型
–Properties properties = new Properties();
–setProperty
–getProperty
–load();

/**
 * @author Lantzrung
 * @date 2022年7月31日
 * @Description
 */
package com.Test032;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo {

    public static void main(String[] args) throws FileNotFoundException, IOException {

	// Properties 是用于加载属性文件的键值对集合
	Properties pro = new Properties();
	// 通过load加载文件的信息【IO】
	pro.load(new FileInputStream(
		new File("C:\\Users\\Lantzrung\\Desktop\\G22440718qwq\\Test01\\src\\com\\Test032\\jdbc.properties")));
	// 输出结果:
	System.out.println(pro.get("dirverClassName"));// com.mysql.Driver
	// 修改username的值为admin
	pro.setProperty("username", "admin");
	System.out.println(pro.get("username"));// admin // 注意这里的username不是修改jdbc.properties为admin的，而是把这里的类转换为admin
	// 源文件中还是为root的
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注意:这里的username不是修改jdbc.properties为admin的，而是把这里的类转换为admin

Collections集合工具类

–排序Collections.sort(list);
–反转Collections.reverse(list);
–洗牌Collections.shuffle(list);
–交换Collections.swap(list, 1, 3);
–交换所有i处和j处的元素
–替换Collections.replaceAll(list, “123”, “789”);
–替换所有old的元素
–二分查找Collections.binarySearch(list, “12.33”);
–集合需要正序排序
–复制操作Collections.copy(dest, src);
–来源集合src的长度要小于dest复制的目标集合的长度 copy(dest, src);

/**
 * @author Lantzrung
 * @date 2022年7月31日
 * @Description
 */
package com.Test032;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsTool {
    public static void main(String[] args) {
	// 集合的工具类
	List list = new ArrayList<>();
//	list.add(45);
//	list.add(245);
//	list.add(15);
//	list.add(4);
//	list.add(4566);
//	list.add(466);

	list.add(new Person("001", "zhang", 18));
	list.add(new Person("002", "zhang", 13));
	list.add(new Person("003", "li", 28));
	list.add(new Person("004", "wang", 16));

	// 排序
	Collections.sort(list, new Comparator() {
	    public int compare(Object o1, Object o2) {
		Person p1 = (Person) o1;
		Person p2 = (Person) o2;
		return p2.age - p1.age;
	    }
	});
	// 输出结果 年龄从大到小进行排序
	System.out.println(list);// [Person [id=003, name=li, age=28], Person [id=001, name=zhang, age=18],
	// Person [id=004, name=wang, age=16], Person [id=002, name=zhang, age=13]]

	// 洗牌
	Collections.shuffle(list);
	System.out.println(list); // [Person [id=004, name=wang, age=16], Person [id=003, name=li, age=28],
	// Person [id=001, name=zhang, age=18], Person [id=002, name=zhang, age=13]]

	// 交换 根据索引来进行交换
	Collections.swap(list, 0, 1);
	System.out.println(list);
	// [Person [id=001, name=zhang, age=18], Person [id=004, name=wang, age=16],
	// Person [id=003, name=li, age=28], Person [id=002, name=zhang, age=13]]

	// 复制
	List dest = new ArrayList<>();// 目标集合
	dest.add("1");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	dest.add("2");
	
	// -- 来源集合src的长度要小于dest复制的目标集合的长度 copy(dest,src);把src的数据复制到覆盖到dest集合中
	Collections.copy(dest, list);
	System.out.println(dest);
	// [Person [id=001, name=zhang, age=18], Person [id=002, name=zhang, age=13],
	// Person [id=004, name=wang, age=16], Person [id=003, name=li, age=28], 2, 2,
	// 2, 2, 2, 2]

    }
}

class Person implements Comparator {
    public String id;
    public String name;
    public int age;

    public Person(String id, String name, int age) {
	super();
	this.id = id;
	this.name = name;
	this.age = age;
    }

    public Person() {
	super();
    }

    @Override
    public int compare(Object o1, Object o2) {
	Person p1 = (Person) o1;
	Person p2 = (Person) o2;
	return p2.age - p1.age;
    }

    @Override
    public String toString() {
	return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

Map练习

练习：【认定为同一个对象】【map\HashMap】
// 人： 指纹编码； 国籍 ； 姓名； 性别
// 数据信息中心DataBase 保存人的数据 【定义规则：指纹编码一样的，则认为同一个人】【key为Person，value为String信息】
// 有多条数据批量插入到数据信息中心【确保数据不重复-指纹编码】
// 数据信息中心记录格式： 指纹编码 – 姓名，国籍，性别 【如果这个人是双重国籍，则追加信息】{姓名，国籍，性别 ; 姓名，国籍，性别}
举例：
sft0250,中国，张三，男
sft0250,新加坡，王五，男
{中国，张三，男；新加坡，王五，男}

/**
 * @author Lantzrung
 * @date 2022年7月31日
 * @Description
 */
package com.day01545;

import java.util.Objects;

// 练习：【认定为同一个对象】【map\HashMap】

public class Person {

    // 人： 指纹编码； 国籍 ； 姓名； 性别
    public String code;
    public String name;
    public String country;
    public String sex;

    // 有多条数据批量插入到数据信息中心【确保数据不重复-指纹编码】
    // 1、HashCode 指纹编码一样的，则认为为同一个人
    @Override
    public int hashCode() {
	return code.hashCode();
    }

    // 2、equals 指纹编码一样的、则认为同一个人
    @Override
    public boolean equals(Object obj) {
	//
	if (obj == null) {
	    return false;
	}
	if (obj == obj) {
	    return true;
	}

	// 判断指纹编码
	Person p = (Person) obj;
	return p.code.equals(code);
    }

    public Person(String code, String name, String country, String sex) {
	super();
	this.code = code;
	this.name = name;
	this.country = country;
	this.sex = sex;

    }

    // OPEN1:
//    @Override
//    public String toString() {
//	return "Person [code=" + code + ", name=" + name + ", country=" + country + ", sex=" + sex + "]";
//    }

    // OPEN2:
    @Override
    public String toString() {
	return code + "," + name + "," + country + "," + sex;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

/**
 * @author Lantzrung
 * @date 2022年7月31日
 * @Description
 */
package com.day01545;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class DateBase {
    // 容器存放数据
    public static HashMap datas = new HashMap();

    // 定义一个方法来实现数据插入的操作
    public static void inserf(Person p) {
	// 判断集合中是否存在这个key
	if (datas.get(p) != null) {
	    // 拼接信息
	    String value = (String) (datas.get(p)) + ";" + p.toString();
	    // 重新添加回去
	    DateBase.datas.put(p, value);
	} else {
	    DateBase.datas.put(p, p.toString());
	}
    }

    // 测试代码
    public static void main(String[] args) {
	// 创建对象
	Person p1 = new Person("SD001", "张三", "中国", "男");
	Person p2 = new Person("SD002", "张2", "中国", "男");
//	Person p3 = new Person("SD003", "张4", "中国", "男");
	Person p3 = new Person("SD001", "zhang", "美国", "男");
	// OPEN4:注释掉数容器存放数据
	// 容器存放数据
//	DateBase.datas.put(p1, p1.toString());
//	DateBase.datas.put(p2, p2.toString());
//	DateBase.datas.put(p3, p3.toString());

//	 调用插入的方法
	inserf(p1);
	inserf(p2);
	inserf(p3);

	// 输出结果
//	System.out.println(datas);
	// {Person [code=SD002, name=张2, country=中国, sex=男]=Person [code=SD002, name=张2,
	// country=中国, sex=男], Person [code=SD001, name=张三, country=中国, sex=男]=Person
	// [code=SD001, name=张三, country=中国, sex=男], Person [code=SD003, name=张4,
	// country=中国, sex=男]=Person [code=SD003, name=张4, country=中国, sex=男]}

	// OPEN2:使用遍历器输出结果
//	Set keys = datas.keySet();
//	for (Object key : keys) {
//	    System.out.println("key=" + key + "value=" + datas.get(key));
//	}
	// key=Person [code=SD002, name=张2, country=中国, sex=男]value=Person [code=SD002,
	// name=张2, country=中国, sex=男]
	// key=Person [code=SD001, name=张三, country=中国, sex=男]value=Person [code=SD001,
	// name=张三, country=中国, sex=男]
	// key=Person [code=SD003, name=张4, country=中国, sex=男]value=Person [code=SD003,
	// name=张4, country=中国, sex=男]

	// OPEN3: 把p3的数据修改为 ，修改toString的结果
//	Set keys = datas.keySet();
//	for (Object key : keys) {
//	    System.out.println("key=" + key + "value=" + datas.get(key));
//	}
	// 正常的数据应该为
//	key=SD001,张三,中国,男value=SD001,"张三", "中国", "男"
//      而不是为//	key=SD001,张三,中国,男value=SD001,zhang,美国,男
	// 输出的结果为:
//	key=SD002,张2,中国,男value=SD002,张2,中国,男
//	key=SD001,张三,中国,男value=SD001,zhang,美国,男

	// OPEN4:
//	Person p3 = new Person("SD001", "zhang", "美国", "男");
//        加入一个数据排序的操作
	// public static void inserf(Person p) {
	Set keys = datas.keySet();
	for (Object key : keys) {
	    System.out.println("key=" + key + "value=" + datas.get(key));
	}
	// 发现结果为:结果为名字为张三导入了美国的国籍
//	key=SD002,张2,中国,男value=SD002,张2,中国,男
//	key=SD001,张三,中国,男value=SD001,张三,中国,男;SD001,zhang,美国,男

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92