Java学习的第十九天（JavaSE特别篇_Collections工具类_HashSet_TreeSet_Map）
程序员文章站
2024-01-14 09:15:46
...
一、前言
1. size()和get()适用于有索引的集合2. List：添加元素的方法 add()——它的底层返回值永远为true，所以允许重复3. Collection的迭代器是没有add()，而List集合的迭代器具有add()，所以可以避免并发修改异常4. ArrayList和LinkedList如何选择使用？？
对于查询速率要求高的，使用ArrayList
对于增删速率要求高的，使用LinkedList
二、Collections（操作集合的工具类）
封装了很多操作集合的方法
//static void sort(List<T> list) :按照列表中元素的自然顺序进行排序
//static int binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置
//static void reverse(List list) :反转
//static void shuffle(List list):傻否，随机置换
//static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列
//static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
/* Collections：
* 面试题：Collection和Collections有什么区别？
* Collection是集合体系的最顶层，包含了集合体系的共性
* Collections是一个工具类，方法都是用于操作Collection*/
package collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Demo_Collections {
public static void main(String[] args) {
List<Integer> l = new LinkedList<>();
l.add(3);
l.add(4);
l.add(1);
l.add(5);
l.add(0);
l.add(9);
System.out.println(l);
//static void sort(List<T> list) :按照列表中元素的自然顺序进行排序
Collections.sort(l);
System.out.println(l);
//static int binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置
int i = Collections.binarySearch(l, 4);
System.out.println(i);
l.set(i,12);
System.out.println(l);
//static void reverse(List list) :反转
Collections.reverse(l);
System.out.println(l);
//static void shuffle(List list):傻否，随机置换
Collections.shuffle(l);
System.out.println(l);
//static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列
List<Integer> lt = new LinkedList<>();
lt.add(0);lt.add(0);lt.add(0);lt.add(0);lt.add(0);lt.add(0);
Collections.copy(lt,l);
System.out.println(lt); //java.lang.IndexOutOfBoundsException
//static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
List<String> lt1 = new LinkedList<>();
lt1.add("张三");
lt1.add("李四");
lt1.add("王五");
System.out.println(lt1);
Collections.swap(lt1,0,2);
System.out.println(lt1);
}
}
//输出结果：
[3, 4, 1, 5, 0, 9]
[0, 1, 3, 4, 5, 9]
3
[0, 1, 3, 12, 5, 9]
[9, 5, 12, 3, 1, 0]
[1, 3, 5, 0, 9, 12]
[1, 3, 5, 0, 9, 12]
[张三, 李四, 王五]
[王五, 李四, 张三]
三、斗地主案例（利用ArrayList集合实现）
package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class Demo_DongDiZhu {
public static void main(String[] args) {
System.out.println("---农民斗地主---");
//斗地主：买牌，洗牌，发牌
//牌盒：集合（有54张牌）
ArrayList<String> box=new ArrayList<String>();
//将54张牌放到牌盒中去---首先要定义54张牌
//需要定义两个字符串数组用来存储牌的花色和牌的大小
String[] color={"♠","♥","♣","♦"};
String[] num={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//使用嵌套循环得到52张牌
for (int i = 0; i < color.length; i++) {
for (int j = 0; j < num.length; j++) {
//System.out.println(color[i]+num[j]);
box.add(color[i]+num[j]); //将得到的牌添加进集合box里面
}
}
//System.out.println(box);
//添加大王和小王添加进box里
box.add("小王");
box.add("大王");
//洗牌：Collections中的随机置换的方法
Collections.shuffle(box);
Collections.shuffle(box); //多洗两次
//System.out.println(box);
//发牌：发给3个人，因为每个人手上有17张牌，要定义三个集合来存储牌
ArrayList<String> A=new ArrayList<>();
ArrayList<String> B=new ArrayList<>();
ArrayList<String> C=new ArrayList<>();
//给三个人每人发17张牌
//遍历集合 留三张底牌
for(int i=0;i<box.size()-3;i++){
if(i%3==0){
A.add(box.get(i));
}else if(i%3==1){
B.add(box.get(i));
}else if(i%3==2){
C.add(box.get(i));
}
}
System.out.println("牌盒中的54张牌："+box);
System.out.println("---普通玩法---");
System.out.println("路人A的牌："+A);
System.out.println("路人B的牌："+B);
System.out.println("路人C的牌："+C);
//获取三张底牌的第一种方式
/* System.out.println("底牌1："+box.get(box.size()-1));
System.out.println("底牌2："+box.get(box.size()-2));
System.out.println("底牌3："+box.get(box.size()-3));
for(int i=box.size()-3;i<box.size();i++){
System.out.println("底牌"+i+": "+box.get(i));
}*/
//获取三张底牌的第二种方式
List<String> strings = box.subList(box.size() - 3, box.size());
System.out.println("底牌："+strings);
//癞子玩法
System.out.println("---癞子玩法---");
String s=" ";
do{
Random r=new Random();
int i = r.nextInt(box.size());
String s1 = box.get(i);
s = s1.substring(1, 2);
if(s.equals("1")){ //如果截取出来的牌数是10 那么只会截取出来“1” 所以将1用10替换
s="10";
}
}while(s.equals("王")); //先获取癞子牌数，但是不能等于大小王
System.out.println("癞子牌："+s);
for (int i1 = 0; i1 <A.size() ; i1++) {
if(A.get(i1).endsWith(s)){
A.set(i1,"[癞子]"+A.get(i1));
}
}
System.out.println("路人A的牌被癞子牌替换："+A);
for (int i2 = 0; i2 <B.size() ; i2++) {
if(B.get(i2).endsWith(s)){
B.set(i2,"[癞子]"+B.get(i2));
}
}
System.out.println("路人B的牌被癞子牌替换："+B);
for (int i3 = 0; i3 <C.size() ; i3++) {
if(C.get(i3).endsWith(s)){
C.set(i3,"[癞子]"+C.get(i3));
}
}
System.out.println("路人C的牌被癞子牌替换："+C);
for (int i4 = 0; i4 <strings.size(); i4++) {
if(strings.get(i4).endsWith(s)){
strings.set(i4,"[癞子]"+strings.get(i4));
}
}
System.out.println("底牌替换："+strings);
}
}
//输出结果：
---农民斗地主---
牌盒中的54张牌：[♥10, ♣A, ♥5, ♥9, ♣10, ♦K, ♠J, ♥2, ♦6, ♠A, ♣3, ♦10, ♣J, ♥4, ♦4, ♣4, ♠10, ♥3, ♦3, ♣7, ♠2, ♦7, ♣5, ♦2, ♠3, ♦A, ♥A, ♦9, ♠9, ♣Q, ♠7, ♠8, ♠4, ♣6, ♣9, ♥6, ♥J, ♠5, 大王, ♠6, ♥8, ♣8, ♦5, ♥K, ♥Q, 小王, ♥7, ♠K, ♣K, ♦J, ♦8, ♣2, ♦Q, ♠Q]
---普通玩法---
路人A的牌：[♥10, ♥9, ♠J, ♠A, ♣J, ♣4, ♦3, ♦7, ♠3, ♦9, ♠7, ♣6, ♥J, ♠6, ♦5, 小王, ♣K]
路人B的牌：[♣A, ♣10, ♥2, ♣3, ♥4, ♠10, ♣7, ♣5, ♦A, ♠9, ♠8, ♣9, ♠5, ♥8, ♥K, ♥7, ♦J]
路人C的牌：[♥5, ♦K, ♦6, ♦10, ♦4, ♥3, ♠2, ♦2, ♥A, ♣Q, ♠4, ♥6, 大王, ♣8, ♥Q, ♠K, ♦8]
底牌：[♣2, ♦Q, ♠Q]
---癞子玩法---
癞子牌：7
路人A的牌被癞子牌替换：[♥10, ♥9, ♠J, ♠A, ♣J, ♣4, ♦3, [癞子]♦7, ♠3, ♦9, [癞子]♠7, ♣6, ♥J, ♠6, ♦5, 小王, ♣K]
路人B的牌被癞子牌替换：[♣A, ♣10, ♥2, ♣3, ♥4, ♠10, [癞子]♣7, ♣5, ♦A, ♠9, ♠8, ♣9, ♠5, ♥8, ♥K, [癞子]♥7, ♦J]
路人C的牌被癞子牌替换：[♥5, ♦K, ♦6, ♦10, ♦4, ♥3, ♠2, ♦2, ♥A, ♣Q, ♠4, ♥6, 大王, ♣8, ♥Q, ♠K, ♦8]
底牌替换：[♣2, ♦Q, ♠Q]
四、HashSet集合
特点：无序、无索引、不允许重复 (需要重写equals()和hashcode())由于它是无序的，所以没有通过索引获取元素的get方法
package com.bianyiit.cast;
import java.util.Objects;
public class Student implements Comparable{
private String name;
private int age;
private int id;
public Student() {
}
public Student(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", id=" + id +
'}';
}
}
package com.bianyiit.cast;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
public class Demo_Set {
public static void main(String[] args) {
//创建set集合对象
HashSet<Student> set=new HashSet<>();
//添加集合对象
Student s1=new Student("张三",19,1);
Student s2=new Student("李四",20,4);
Student s3=new Student("王五",21,2);
Student s4=new Student("赵六",21,3);
Student s5=new Student("张三",21,1);
Student s6=new Student("孙七",19,1);
Student s7=new Student("张三",19,1);
set.add(s1);set.add(s2);set.add(s3);set.add(s4);set.add(s5);set.add(s6);set.add(s7);
for (Student student : set) {
System.out.println(student);
}
}
}
//输出结果：
Student{name='李四', age='20', id=4}
Student{name='张三', age='19', id=1}
Student{name='张三', age='21', id=1}
Student{name='王五', age='21', id=2}
Student{name='赵六', age='21', id=3}
Student{name='孙七', age='19', id=1}
Student{name='张三', age='19', id=1}
当我们重复输入name='张三', age='19', id=1的时候，集合中已经存在了，但是当我们添加的时候，还是添加进了集合里，那为什么会出现这种情况，又如何去重？？
HashSet的唯一性原理解释
规则:新添加到HashSet集合的元素都会与集合中已有的元素一一比较
首先比较哈希值(每个元素都会调用hashCode()产生一个哈希值)
如果新添加的元素与集合中已有的元素的哈希值都不同,新添加的元素存入集合
如果新添加的元素与集合中已有的某个元素哈希值相同,此时还需要调用equals(Object obj)比较
如果equals(Object obj)方法返回true,说明新添加的元素与集合中已有的某个元素的属性值相同,那么新添加的元素不存入集合
如果equals(Object obj)方法返回false, 说明新添加的元素与集合中已有的元素的属性值都不同, 那么新添加的元素存入集合
package com.bianyiit.cast;
import java.util.Objects;
public class Student{
private String name;
private int age;
private int id;
public Student() {
}
public Student(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", id=" + id +
'}';
}
}
package com.bianyiit.cast;
public class StudentDemo {
public static void main(String[] args) {
Student s=new Student();
System.out.println(s.hashCode()); //获取s的哈希值--物理层次给予对象的唯一标识，不是真正的地址值（可以人为更改的）
System.out.println(System.identityHashCode(s)); //获取s在内存中的地址值--系统层次给予对象的唯一标识（不可以人为更改）
}
}
//输出结果：
460141958
460141958
那么如果要去重，我们应该重写hashcode()和equals()
//Student.java
package com.bianyiit.cast;
import java.util.Objects;
public class Student{
private String name;
private int age;
private int id;
public Student() {
}
public Student(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", id=" + id +
'}';
}
@Override
public boolean equals(Object o) {
Student s = (Student) o;
if(this.age==s.getAge()&&this.name.equals(s.getName())&&this.id==s.getId()){
return true;
}else{
return false;
}
}
@Override
public int hashCode() {
return 1;
}
//如果hash值相同，那么还要比较里面的内容，如果里面的内容相同，就不能添加进去，所以能够达到去重的效果
}
package com.bianyiit.cast;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
public class Demo_Set {
public static void main(String[] args) {
//method();
//创建set集合对象
HashSet<Student> set=new HashSet<>();
//添加集合对象
Student s1=new Student("张三",19,1);
Student s2=new Student("李四",20,4);
Student s3=new Student("王五",21,2);
Student s4=new Student("赵六",21,3);
Student s5=new Student("张三",21,1);
Student s6=new Student("孙七",19,1);
Student s7=new Student("张三",19,1);
set.add(s1);set.add(s2);set.add(s3);set.add(s4);set.add(s5);set.add(s6);set.add(s7);
for (Student student : set) {
System.out.println(student);
}
}
}
//没有重写hashcode()和equals()的输出结果：
Student{name='李四', age='20', id=4}
Student{name='张三', age='19', id=1}
Student{name='张三', age='21', id=1}
Student{name='王五', age='21', id=2}
Student{name='赵六', age='21', id=3}
Student{name='孙七', age='19', id=1}
Student{name='张三', age='19', id=1}
//重写了hashcode()和equals()的输出结果：去掉了{name='张三', age='19', id=1的重复的Student对象
Student{name='张三', age='19', id=1}
Student{name='张三', age='21', id=1}
Student{name='孙七', age='19', id=1}
Student{name='王五', age='21', id=2}
Student{name='赵六', age='21', id=3}
Student{name='李四', age='20', id=4}
原理解释如下：
1.首先因为哈希值是物理层次的地址值，每new出来一个对象尽管内容是一样的，但是哈希值肯定不一样，所以HashSet的add()去不了重
2.而HashSet的add()首先判断的是对象的哈希值，如果哈希值不一样，就会直接添加进集合，所以我们要重写object的hashcode()，把每一个对象的哈希值改为一样的
3.HashSet的add()，如果判断对象的哈希值一致，那么就会判断对象的内容，如果内容不一样就添加进集合中，如果内容一样就去重
4.由于object的equals()比较的是真正的对象的地址值是否一致，但是我们如果只想比较内容还要去重写object的equals()
HashSet的优化
因为上面我们只是将hashcode()的返回值定义为1，那么每添加一个元素都要和集合中的所有元素的哈希值去比较，这样调用hashcode()的次数就会很多，也会消耗更多的内存，所以如果将每个属性的哈希值都得到，那么只要发现有某一个属性的哈希值不一样，代表的就是不同的对象
Set集合不能去重的根本原因：底层是用map图的put()，而put()又要比较hash值，如果Set集合的add()想去重，就要重写object的hashcode()和equals()
五、TreeSet集合
特点：可以自动的给添加进集合的数据进行排序(相当于调用的Collections的sort())
package com.bianyiit.cast;
import java.util.TreeSet;
public class Demo_TreeSet {
public static void main(String[] args) {
TreeSet t=new TreeSet();
//使用add()往集合中添加元素时会默认排序
t.add(1);
t.add(8);
t.add(5);
t.add(7);
t.add(6);
t.add(9);
t.add(3);
t.add(2);
t.add(4);
System.out.println(t);
}
}
//输出结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
package com.bianyiit.cast;
import java.util.Objects;
public class Student{
private String name;
private int age;
private int id;
public Student() {
}
public Student(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", id=" + id +
'}';
}
}
package com.bianyiit.cast;
import java.util.TreeSet;
public class Demo_TreeSet {
public static void main(String[] args) {
TreeSet t=new TreeSet();
//使用add()往集合中添加元素时会默认排序
Student s1=new Student("张三",19,1);
System.out.println(t);
}
}
//输出结果：--Student没有实现序列化
java.lang.ClassCastException: com.bianyiit.cast.Student cannot be cast to java.lang.Comparable
如果我们在Student实现了序列化，那么可以正常添加元素吗？？
package com.bianyiit.cast;
import java.util.Objects;
public class Student implements Comparable{ //实现序列化--Comparable
private String name;
private int age;
private int id;
public Student() {
}
public Student(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", id=" + id +
'}';
}
@Override
public int compareTo(Object o) {
return 0;
}
}
package com.bianyiit.cast;
import java.util.TreeSet;
public class Demo_TreeSet {
public static void main(String[] args) {
TreeSet t=new TreeSet();
//使用add()往集合中添加元素时会默认排序
Student s1=new Student("张三",19,1);
System.out.println(t);
}
}
//输出结果：
Student{name='张三', age='19', id=1}
那如果继续往集合中添加元素会出现什么结果？？
package com.bianyiit.cast;
import java.util.TreeSet;
public class Demo_TreeSet {
public static void main(String[] args) {
TreeSet t=new TreeSet();
//使用add()往集合中添加元素时会默认排序
Student s1=new Student("张三",19,1);
Student s2=new Student("李四",20,4);
Student s3=new Student("王五",21,2);
Student s4=new Student("赵六",21,3);
Student s5=new Student("张三",21,1);
Student s6=new Student("孙七",19,1);
Student s7=new Student("张三",19,1);
t.add(s1);t.add(s2);t.add(s3);t.add(s4);t.add(s5);t.add(s6);t.add(s7);
for (Object o : t) { //使用增强for进行遍历，详情请查看博主之前写的Java笔记
System.out.println(o);
}
}
}
//输出结果：还是只有一个内容 why??
Student{name='张三', age='19', id=1}
如何能够让TreeSet集合能够添加所有的Student对象
/*判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不添加进集合中。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。*/
TreeSet对元素进行排序的方式一：
package com.bianyiit.cast;
public class Person implements Comparable {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Object o){
Person p=(Person)o;
if(this.age>p.age){
return 1;
}else if(this.age==p.getAge()){
return 0;
}else if(this.age<p.age){
return -1;
}
return 0;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.bianyiit.cast;
import java.util.TreeSet;
public class PersonDemo {
public static void main(String[] args) {
TreeSet<Person> s=new TreeSet<>();
Person p1=new Person("张三",1);
Person p2=new Person("李四",2);
Person p3=new Person("王五",3);
Person p4=new Person("赵六",4);
Person p5=new Person("张三",1);
s.add(p1);
s.add(p2);
s.add(p3);
s.add(p4);
s.add(p5);
for (Person person : s) {
System.out.println(person);
}
}
}
//没有重写compareTo的输出结果：--Student没有实现序列化
java.lang.ClassCastException: com.bianyiit.cast.Student cannot be cast to java.lang.Comparable
//使用快捷键重写了compareTo之后的输出结果：可以添加对象进集合中，但是不去重
/*快捷键重写compareTo()
@Override
public int compareTo(Object o) {
return 0;
}*/
Person{name='张三', age=1}
Person{name='李四', age=2}
Person{name='王五', age=3}
Person{name='赵六', age=4}
Person{name='张三', age=1}
//重写了compareTo()方法里面的东西之后的输出结果：添加对象进集合中，已经去重了
/*自己重写comparTo()
@Override
public int compareTo(Object o){
Person p=(Person)o;
if(this.age>p.age){
return 1;
}else if(this.age==p.getAge()){
return 0;
}else if(this.age<p.age){
return -1;
}
return 0;
}*/
Person{name='张三', age=1}
Person{name='李四', age=2}
Person{name='王五', age=3}
Person{name='赵六', age=4}
TreeSet对元素进行排序的方式二：
package com.bianyiit.cast;
import java.util.Comparator;
public class PersonCamparator implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Person s1 = (Person) o1;
Person s2 = (Person) o2;
if(s1.getAge()>s2.getAge()){
return 1;
}else if(s1.getAge()<s2.getAge()){
return -1;
}else if(s1.getAge()==s2.getAge()){
if(s1.getName().compareTo(s2.getName())>0){
return 1;
}else if(s1.getName().compareTo(s2.getName())<0){
return -1;
}
return 0;
}
return 0;
}
}
package com.bianyiit.cast;
import java.util.TreeSet;
public class PersonDemo {
public static void main(String[] args) {
TreeSet<Person> s=new TreeSet<>(new PersonCamparator());
Person p1=new Person("张三",1);
Person p2=new Person("李四",2);
Person p3=new Person("王五",3);
Person p4=new Person("赵六",4);
Person p5=new Person("张三",1);
s.add(p1);
s.add(p2);
s.add(p3);
s.add(p4);
s.add(p5);
for (Person person : s) {
System.out.println(person);
}
}
}
//输出结果：
Person{name='张三', age=1}
Person{name='李四', age=2}
Person{name='王五', age=3}
Person{name='赵六', age=4}
六、Map集合（双列集合–夫妻对集合）
Map集合（双列集合--夫妻对集合）
Collection集合（单列集合--单身汉集合）
两种之间没有关系，都是集合体系的最顶层
两者都是接口
Map集合--存储数据是以键值对的方式进行存储（键是不允许重复的，而值是允许重复的）
常用方法
A:添加功能：
V put(K key, V value) :以键=值的方式存入Map集合
B:获取功能：
V get(Object key):根据键获取值
int size():返回Map中键值对的个数
C:判断功能：
boolean containsKey(Object key):判断Map集合中是否包含键为key的键值对
boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
boolean isEmpty():判断Map集合中是否没有任何键值对
D:删除功能：
void clear():清空Map集合中所有的键值对
V remove(Object key):根据键值删除Map中键值对
方法示例演示
package com.bianyiit.cast;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo_HashMap {
public static void main(String[] args) {
//创建HashMap集合对象
//Map<key,value> key只能映射（对应）一个value，但是一个value可以映射（对应）多个key
Map<Integer,String> m=new HashMap<Integer, String>();
//添加方法 put()
m.put(1,"张三");
m.put(2,"李四");
m.put(3,"王五");
m.put(4,"赵六");
System.out.println(m);
//A:添加功能：V put(K key, V value) :以键=值的方式存入Map集合
m.put(5,"路人七");
System.out.println(m);
//B:获取功能
// V get(Object key):根据键获取值
System.out.println(m.get(5));
//int size():返回Map中键值对的个数
System.out.println(m.size());
//C:判断功能：
//boolean containsKey(Object key):判断Map集合中是否包含键为key的键值对
System.out.println(m.containsKey(1));
// boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
System.out.println(m.containsValue("路人七"));
//boolean isEmpty():判断Map集合中是否没有任何键值对
System.out.println(m.isEmpty());
//D:删除功能：
// void clear():清空Map集合中所有的键值对
//m.clear();
//V remove(Object key):根据键值删除Map中键值对*/
m.remove(5);
}
}
//输出结果：
{1=张三, 2=李四, 3=王五, 4=赵六}
{1=张三, 2=李四, 3=王五, 4=赵六, 5=路人七}
路人七
5
true
true
false
遍历Map集合的两种方式
第一种方式Set<K> keySet()
//原理分析：通过遍历来获取集合中所有的键，然后通过键来获取对应的值
package com.bianyiit.cast;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo_HashMap {
public static void main(String[] args) {
//创建HashMap集合对象
//Map<key,value> key只能映射（对应）一个value，但是一个value可以映射（对应）多个key
Map<Integer,String> m=new HashMap<Integer, String>();
//添加方法 put()
m.put(1,"张三");
m.put(2,"李四");
m.put(3,"王五");
m.put(4,"赵六");
System.out.println(m);
//遍历map的第一种方式
Set<Integer> keys = m.keySet();
//为什么所有的key都要放在Set集合而不放在List集合里面，因为key是不允许重复的，而Set集合是可以去重的
for (Integer key : keys) {
//获取keys集合的每一个键，通过Integer的对象key来接收
String value = m.get(key);
System.out.println(key+":"+value);
}
}
}
//输出结果：
{1=张三, 2=李四, 3=王五, 4=赵六}
1:张三
2:李四
3:王五
4:赵六
第二种方式Set<Map.Entry<K,V>> entrySet()
//原理分析：同时一起获取所有的键值对，然后遍历键值对集合获取单个的键值对，可以通过单个的键值对象来获取相应的键和值
package com.bianyiit.cast;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo_HashMap {
public static void main(String[] args) {
//创建HashMap集合对象
//Map<key,value> key只能映射（对应）一个value，但是一个value可以映射（对应）多个key
Map<Integer,String> m=new HashMap<Integer, String>();
//添加方法 put()
m.put(1,"张三");
m.put(2,"李四");
m.put(3,"王五");
m.put(4,"赵六");
System.out.println(m);
//遍历map的第二种方式Set<Map.Entry<K,V>> entrySet()
Set<Map.Entry<Integer, String>> father = m.entrySet();
for (Map.Entry<Integer, String> son : father) {
Integer key = son.getKey();
String value = son.getValue();
System.out.println(key+":"+value);
}
}
}
下一篇： Guava工具类