Map集合
Map介绍
Map集合:
什么是 Map ?
–map 是指一种用来存放映射关系数据的容器。
什么是映射关系 ?
–映射关系是指用一个键, 与一个值所组成的关系对一个键对应到一个值, 这个键是不能重复的, 所以, 通过键就能找到对应的值。
HashMap [无序、不能重复、散列表]
[1] 是一个线程不安全的 Map 实现类
[2] 允许插入值为 null 的 key
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==普通冰箱
}
}
Hashtable[无序、不能重复、散列表]
[1] 是一个线程安全的 Map 实现类
[2] 不允许插入值为 null 的 key
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==电饭煲
}
}
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=鼠标}
}
}
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 + "]";
}
}
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的
}
}
注意:这里的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 + "]";
}
}
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;
}
}
/**
* @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,美国,男
}
}