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 Stringname;
//年龄
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
//获取元素
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 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 Stringname;
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 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 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 Stringname;
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 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 set = map.keySet();
//4.2 遍历所有key，获取每一个键
//获取迭代器
Iterator 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 pukers =new HashMap<>();
//1.2创建一个List集合来存储牌的编号
List 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 wan1 =new ArrayList<>();
List wan2 =new ArrayList<>();
List wan3 =new ArrayList<>();
List dipai =new ArrayList<>();
//3.2遍历牌堆
for (int i =0; 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 list , Map pukers){
String str ="";
//给list集合排序
Collections.sort(list);
//增强for的方式循环输出玩家的牌
for (Integer integer : list) {
str = str + pukers.get(integer)+"\t";
}
return str;
}
}
运行结果：
网友评论