Java 常用工具-集合
1.集合简介
什么是集合？
简称集，是用来存储多个元素的容器
集合和数组的区别
1.元素类型
集合：引用类型（存储基本类型是自动装箱）
数组：基本类型，引用类型
2.元素个数
集合：不固定，可以任意扩容
数组：固定，不能改变容量
集合的好处
不受容器大小限制，可以随时添加、删除元素，提供大量操作元素的方法（判断、获取）
Java的集合体系
1.单列集合（Collection）
List：ArrayList
Set：HashSet
2.双列集合（Map:key,value）
Map：HashMap
2.List集合的特点和应用
List集合的特点
可重复、有序（存取顺序相同）
应用：
List list = new ArrayList();
案例：List集合的简单使用
需求：向List集合中添加三个元素，并遍历打印
分析：
A：向集合中添加元素的方法:add()
B：遍历集合的反思：for循环
C：获取集合中的元素个数的方法：size()
步骤：
1.创建集合对象：
List list = new ArrayList();
2.分别创建三个Student对象
3.使用add方法将Student对象添加到集合中
4.使用for循环遍历集合并打印
//定义一个学生类 public class Student { //成员变量 //姓名 private String name; //年龄 private int age; //构造方法 //无参构造 public Student() { } //全参构造 public Student(String name, int age) { this.name = name; this.age = 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; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
//测试类 import java.util.ArrayList; import java.util.List; /** *案例：List集合的简单使用 * 需求：向List集合中添加三个元素，并遍历打印 * * 分析： * A：向集合中添加元素的方法:add() * B：遍历集合的反思：for循环 * C：获取集合中的元素个数的方法：size() * * 步骤： * 1.创建集合对象： * List list = new ArrayList(); * 2.分别创建三个Student对象 * 3.使用add方法将Student对象添加到集合中 * 4.使用for循环遍历集合并打印 * * 使用集合的步骤： * 1.创建集合对象 * 2.创建元素对象 * 3.将元素对象添加到集合中 * 4.遍历集合 * */ public class Test { public static void main(String[] args) { //1.创建集合对象 List list = new ArrayList(); //2.创建三个元素对象 Student s1 = new Student("张三",12); Student s2 = new Student("李四",15); Student s3 = new Student("王二",13); //3.将元素添加到集合中 list.add(s1); list.add(s2); list.add(s3); //打印list System.out.println(list); System.out.println("-----------"); //获取索引为2的元素 Object obj = list.get(2); System.out.println(obj); System.out.println("----------"); //获取集合元素的个数 int size = list.size(); System.out.println("集合的长度："+size); System.out.println("----------"); //遍历集合 for (int i = 0; i <list.size() ; i++) { //获取元素 Object obj2 =list.get(i); System.out.println("索引为"+i+"的元素："+obj2); } } }
运行结果
3.增强for循环和迭代器
为什么需要增强for循环
简化数组和集合的遍历
增强for循环的格式
for(数据类型 变量名：数组或者集合对象){
//循环体，变量即元素
}
例子：
import java.util.ArrayList; import java.util.List; //测试类 //案例：演示增强for循环 //快捷方式：iter+回车 生成增强for的格式 /** * 注意： * 增强for的底层依赖的是迭代器（Iterator） * 增强for就是迭代器的简写 */ public class Test { public static void main(String[] args) { //需求：通过增强for遍历集合List //1.创建集合对象 List list = new ArrayList(); //2.创建元素对象 //3.将元素对象添加到集合中 list.add(10); list.add(20); list.add(30); list.add(40); //4.遍历元素对象 for (Object obj : list){ //obj是集合中的元素，其本身是Integer类型的数据 Integer i1 = (Integer) obj; System.out.println(i1); } for (Object o : list) { System.out.println(o); } } }
运行结果：
为什么需要迭代器？
对过程的重复，成为迭代
列表迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作
迭代器的常用方法
·next():返回迭代的下一个元素对象
·hasNext如果仍有元素可以迭代，则返回true
例子：
import java.util.ArrayList; import java.util.List; import java.util.ListIterator; //测试类 //测试列表迭代器 public class Test2 { public static void main(String[] args) { //需求：判断如果集合有字符串b，就在它后面添加新的字符串：java //1.创建集合对象 List list = new ArrayList(); //2.创建元素对象 //3.向集合添加元素 list.add("a"); list.add("b"); list.add("c"); list.add("d"); //根据集合对象获取其对象的迭代器对象 ListIterator it = list.listIterator(); //2.判断迭代器中是否有元素 while (it.hasNext()){//如果it中有元素就一种迭代 //3.如果有就获取元素 String s = (String)it.next(); if("b".equals(s)){//这样写可以避免空指针异常 //list.add("java");//必须用列表迭代器 it.add("java"); } System.out.println(s); } } }
运行结果：
4.泛型简介
什么是泛型？
即泛指任意类型，又叫参数化类型
对具体类型的使用起到辅助作用，类似于方法的参数
集合类泛型的解释
表示该集合中存放指定类型的元素
泛型的好处
类型安全
避免了类型转换
5.Collections工具类
简介
针对于集合进行操作的工具类
成员方法
·sort(List<T>)
根据元素的自然顺序，将指定列表按升序排列
·max(Collection<T>)
返回集合的最大元素
·reverse(List<T>)
f反转List集合元素
·shuffle(List<T>)
使用默认的随机源随机置换指定的列表
例子：
//测试类 import java.util.ArrayList; import java.util.Collections; import java.util.List; /** *成员方法 * ·sort(List<T>) * 根据元素的自然顺序，将指定列表按升序排列 * ·max(Collection<T>) * 返回集合的最大元素 * ·reverse(List<T>) * f反转List集合元素 * ·shuffle(List<T>) * 使用默认的随机源随机置换指定的列表 * */ public class Test { public static void main(String[] args) { //1.创建集合 List<Integer> list = new ArrayList<>(); //2.向集合添加数据 list.add(1); list.add(3); list.add(3); list.add(5); list.add(5); list.add(4); //3.打印集合 System.out.println("没有操作之前list中的数据:"+list); System.out.println("--------------------"); //获取集合中最大元素 Integer max = Collections.max(list); System.out.println("集合中最大的元素："+max); System.out.println("--------------------"); //对集合进行升序排列 Collections.sort(list); System.out.println("升序后的结果为："+list); System.out.println("--------------------"); //对集合进行反转 Collections.reverse(list); System.out.println("集合进行反转的结果："+list); //随机置换，相当于洗牌 Collections.shuffle(list); System.out.println("随机洗牌后的结果："+list); } }
运行结果：
6.Set集合的特点
特点：
不可重复，无序
应用：
Set<T>set = new HashSet<>();
案例：Set集合的简单使用
需求：向Set集合中添加5个元素，并遍历打印
分析：
A.向集合中添加元素的方法：add()
B.遍历集合的方式：迭代器
步骤：
1.创建集合对象
Set<Student> set = new HashSet<>();
2.分别创建5个Student对象
3.使用add方法将Student对象添加到集合中
4.使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同
import java.util.Objects; //定义学生类 public class Student { //成员变量 private String name; private int age; //构造方法 public Student(String name, int age) { this.name = name; this.age = age; } public Student() { } //成员方法 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; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hash(name, age); } }
//测试类 import java.util.HashSet; import java.util.Iterator; import java.util.Set; /** *案例：Set集合的简单使用 * 需求：向Set集合中添加5个元素，并遍历打印 * 分析： * A.向集合中添加元素的方法：add() * B.遍历集合的方式：迭代器 * * 步骤： * 1.创建集合对象 * Set<Student> set = new HashSet<>(); * 2.分别创建5个Student对象 * 3.使用add方法将Student对象添加到集合中 * 4.使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同 * */ public class Test { public static void main(String[] args) { //1.创建泛型集合 Set<Student> set = new HashSet<>(); //2.创建5个Student对象 Student s1 = new Student("张三",12); Student s2 = new Student("李四",15); Student s3 = new Student("王二",13); Student s4 = new Student("张三",12); Student s5 = new Student("李四",15); //3.使用add方法将Student对象添加到集合中 set.add(s1); set.add(s2); set.add(s3); set.add(s4); set.add(s5); //5.遍历并打印 //1.打印 System.out.println(set); System.out.println("----------"); //2.通过迭代器遍历打印 Iterator<Student> it = set.iterator(); while (it.hasNext()){ Student student = it.next(); System.out.println(student); } System.out.println("----------"); //3.通过增强for遍历打印 for (Student student : set) { System.out.println(student); } } }
运行结果：
7.Map集合的特点
特点：
双列集合，元素键对（Entry）构成
Key --Value
key不可重复，value可以重复
应用：
Map<T1,T2>map = new HashMap<>();
案例：Map集合的简单使用
需求：向Map集合中添加三个元素，并遍历打印
分析：
A.向map集合中添加元素的方法为:put()
B:遍历集合的方式：
获取所有的Key:keySet()
遍历keySet,通过key获取value:get()
C.遍历keySet的方法：iterator()
步骤：
1.创建集合对象
Map<Integer,Student> map = new HashMap<>();
2.创建三个Student对象
3.使用put方法将Studdent对象添加到集合中
4.获取所有keym并使用迭代器遍历
import java.util.Objects; //学生类 public class Student { //成员变量 private String name; private int age; //构造方法 public Student() { } public Student(String name, int age) { this.name = name; this.age = 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; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hash(name, age); } }
//测试类 import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** *案例：Map集合的简单使用 * 需求：向Map集合中添加三个元素，并遍历打印 * 分析： * A.向map集合中添加元素的方法为:put() * B:遍历集合的方式： * 获取所有的Key:keySet() * 遍历keySet,通过key获取value:get() * C.遍历keySet的方法：iterator() * 步骤： * 1.创建集合对象 * Map<Integer,Student> map = new HashMap<>(); * * 2.创建三个Student对象 * 3.使用put方法将Studdent对象添加到集合中 * 4.获取所有keym并使用迭代器遍历 * * * */ public class Test { public static void main(String[] args) { //1.创建集合对象 Map<Integer,Student> map = new HashMap<>(); //2.创建三个Student对象 Student s1 = new Student("张三",12); Student s2 = new Student("李四",12); Student s3 = new Student("王二",12); //3.使用put方法将Studdent对象添加到集合中 map.put(1,s1); map.put(2,s2); map.put(3,s3); //根据key获取value Student stu = map.get(3); System.out.println(stu); System.out.println("--------------"); //4.获取所有keym并使用迭代器遍历 System.out.println(map); //4.1 获取所有key的集合 Set<Integer> set = map.keySet(); //4.2 遍历所有key，获取每一个键 //获取迭代器 Iterator<Integer> it = set.iterator(); while(it.hasNext()){ //4.3 根据key获取value Integer i = it.next(); Student s = map.get(i); System.out.println("key:"+i +"value:"+s); } System.out.println("--------------"); //通过增强for实现 for (Integer i : set) { Student s = map.get(i); System.out.println("key:"+i +"value:"+s); } } }
运行结果：
8.案例：模拟斗地主发牌功能
需求：使用一个集合对象存储一副扑克牌，将所有扑克的顺序打乱，然后分发给使用集合便是的三个玩家和底牌，并答应玩家和地盘的集合内容
步骤：
1.买一副扑克牌
将花色和数字分别进行组合，生成所有的普通牌，生成的普通手动添加大、小王
2.洗牌
使用Collections工具类的shuffle()方法打乱牌的顺序
3.发牌
遍历牌堆，将每一张牌分发到三个玩家中
留三张底牌
4.看牌
分别打印每个玩家集合的内容
//测试类 import java.util.*; /** * *8.案例：模拟斗地主发牌功能 * * 需求：使用一个集合对象存储一副扑克牌，将所有扑克的顺序打乱，然后分发给使用集合便是的三个玩家和底牌，并答应玩家和地盘的集合内容 * * 步骤： * 1.买一副扑克牌 * 将花色和数字分别进行组合，生成所有的普通牌，生成的普通手动添加大、小王 * 2.洗牌 * 使用Collections工具类的shuffle()方法打乱牌的顺序 * 3.发牌 * 遍历牌堆，将每一张牌分发到三个玩家中 * 留三张底牌 * 4.看牌 * 分别打印每个玩家集合的内容 * */ public class Test { public static void main(String[] args) { //1.将花色和数字分别进行组合，生成所有的普通牌，生成的普通手动添加大、小王 //1.1创建一个Map集合用来存储牌的编号和花色数字 Map<Integer,String > pukers = new HashMap<>(); //1.2创建一个List集合来存储牌的编号 List<Integer> list = new ArrayList<>(); //1.3生成普通牌 //创建数字数组 String[] nums = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"}; //创建花色数组 String[] colors = {"♦","♣","♠","♥"}; //循环生成普通牌 int n = 0; for (String num : nums) { for (String color : colors) { String puker = color + num; //System.out.println(puker); pukers.put(n,puker); list.add(n++); } } //1.4生成大王，小王 //生成小王 pukers.put(n,"小王"); list.add(n++); //生成大王 pukers.put(n,"大王"); list.add(n); System.out.println("牌的编号："+ list); System.out.println("完整一副牌："+ pukers); System.out.println("-----------------------------"); //2.使用Collections工具类的shuffle()方法打乱牌的顺序 Collections.shuffle(list); System.out.println("乱序的编号："+list); System.out.println("-----------------------------"); //3.遍历牌堆，将每一张牌分发到三个玩家中,留三张底牌 //3.1创建三个玩家和底牌的集合 List<Integer> wan1 = new ArrayList<>(); List<Integer> wan2 = new ArrayList<>(); List<Integer> wan3 = new ArrayList<>(); List<Integer> dipai = new ArrayList<>(); //3.2遍历牌堆 for (int i = 0; i <list.size() ; i++) { Integer pukerNum = list.get(i); if(i>=list.size()-3){//判断是否是最后三张牌 dipai.add(pukerNum); }else if(i%3 == 0){//发给玩家1 wan1.add(pukerNum); }else if(i%3 == 1){//发给玩家2 wan2.add(pukerNum); }else if(i%3 == 2){//发给玩家3 wan3.add(pukerNum); } } //4.分别打印每个玩家和底牌集合的内容 /* (System.out.println("wan1:"+wan1); System.out.println("wan2:"+wan2); System.out.println("wan3:"+wan3); System.out.println("dipai"+dipai); */ System.out.println("玩家1:"+printPuker(wan1,pukers)); System.out.println("玩家2:"+printPuker(wan2,pukers)); System.out.println("玩家3:"+printPuker(wan3,pukers)); System.out.println("底牌:"+printPuker(dipai,pukers)); } //创建方法用来顺序查看玩家和底牌的牌 public static String printPuker(List<Integer> list , Map<Integer,String> pukers){ String str = ""; //给list集合排序 Collections.sort(list); //增强for的方式循环输出玩家的牌 for (Integer integer : list) { str = str + pukers.get(integer)+"\t"; } return str; } }
运行结果：
