目录
集合简介
什么是集合？
简称集，是用来存储多个元素的容器
集合和数组的区别
元素类型
集合：引用类型（存储基本类型时自动装箱）
数组：基本类型、引用类型
元素个数
集合：不固定，可任意扩容
数组：固定，不能改变容量
集合的好处
不受容器大小限制，可以随时添加、删除元素
提供了大量操作元素的方法（判断、获取等）
Java的集合体系
单列集合（Collection）
- List：
ArrayList
- Set：
HashSet
双列集合（Map： key，value ）
- Map：
HashMap
List集合的特点和应用
package com.itcast.demo10;
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 +
'}';
}
}
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
Student s1 = new Student("张三", 21);
Student s2 = new Student("李四", 19);
Student s3 = new Student("王五", 22);
Student s4 = new Student("赵六", 17);
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
//获取索引为2的元素
Object o = list.get(2);
System.out.println(o);
//获取集合长度
System.out.println(list.size());
//有序，可重复
System.out.println(list);
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
System.out.println("索引为"+i+"的元素是："+obj);
}
}
}
增强for循环和迭代器
为什么需要增强for循环？
简化数组和集合的遍历
增强for循环的格式：
for(数据类型 变量名 : 数组或者集合对象) {
// 循环体，变量即元素
}
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//创建元素对象
//将元素对象添加到集合对象中
list.add(10);
list.add(20);
list.add(30);
list.add(40);
list.add(50);
//遍历集合 迭代器（Iterator）
for (Object obj : list) { //快捷键iter(增强for的格式)
System.out.println(obj);
}
}
}
为什么需要迭代器？
对过程的重复，称为迭代。
迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。
迭代器的常用方法
- next()： 返回迭代的下一个元素对象
- hasNext()： 如果仍有元素可以迭代，则返回true
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
//通过迭代器遍历集合
//创建集合对象
List list = new ArrayList();
//创建元素对象
//将元素对象添加到集合对象中
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//遍历集合
// 迭代器（Iterator）的用法
//根据集合对象获取其对象的迭代器对象
Iterator it = list.iterator();
//判断迭代器中是否有对象
while (it.hasNext()) {
//如果有，获取元素
String s = (String) it.next();
System.out.println(s);
}
}
}
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Test1 {
public static void main(String[] args) {
//测试列表迭代器
//创建集合对象
List list = new ArrayList();
//创建元素对象
//将元素对象添加到集合对象中
list.add("a");
list.add("b");
list.add("c");
//判断如果集合中有字符串”b“，就在其后添加一个新字符串java
//根据集合对象获取其对象的迭代器对象
ListIterator it = list.listIterator();//alt+enter
//判断迭代器中是否有对象
while (it.hasNext()){
//如果有，获取元素
String s = (String) it.next();
if ("b".equals(s)){
it.add("java");
}
System.out.println(s);
}
System.out.println(list); //打印的新的集合
}
}
泛型简介
什么是泛型？
即泛指任意类型，又叫参数化类型（ParameterizedType），对具体类型的使用起到辅助作用，类似于方法的参数。
集合类泛型的解释
表示该集合中存放指定类型的元素
泛型的好处
类型安全 避免了类型转换
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.List;
public class Test2 {
public static void main(String[] args) {
//创建集合对象
List list1 = new ArrayList();
//创建元素对象
//将元素对象添加到集合对象中
list1.add("a");
list1.add("b");
list1.add("c");
//如果放其他类型会报错（类型转换异常）
//list1.add(10);
//遍历集合
for (Object obj : list1) {
String s = (String) obj;
System.out.println(s);
}
//改进
//创建集合对象
List<String> list2 = new ArrayList();
//创建元素对象
//将元素对象添加到集合对象中
list2.add("abg");
list2.add("ber");
list2.add("cwq");
//list2.add(10);
//遍历集合
for (String s1 : list2) {
System.out.println(s1);
}
}
}
Collections工具类
Collections简介
针对集合进行操作的工具类。
成员方法
- sort(List,Comparator) 根据比较器规则对列表进行排序
- max(Collection) 返回集合的最大元素
- reverse(List) 反转List集合元素
- shuffle(List) 根据自然顺序返回最大元素
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test2 {
public static void main(String[] args) {
List<Integer> list = new ArrayList();
//创建元素对象
//将元素对象添加到集合对象中
list.add(1);
list.add(3);
list.add(4);
list.add(10);
list.add(3);
System.out.println(list);
//最大元素
Integer max = Collections.max(list);
System.out.println(max);
//升序排列
Collections.sort(list);
System.out.println(list);
//元素反转
Collections.reverse(list);
System.out.println(list);
//降序排列（升序再反转）
Collections.sort(list);
Collections.reverse(list);
System.out.println(list);
//随机置换
Collections.shuffle(list);
System.out.println(list);
}
}
Set集合的特点和应用
Set集合的特点
特点
不可重复、无序
应用
Set set = new HashSet<>();
案例：Set集合的简单使用
需求：向Set集合中添加五个元素，并遍历打印
package com.itcast.demo10;
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);
}
}
package com.itcast.demo10;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test3 {
public static void main(String[] args) {
Set<Student> set = new HashSet<>();
Student s1 = new Student("张三", 21);
Student s2 = new Student("李四", 19);
Student s3 = new Student("王五", 22);
Student s4 = new Student("李四", 19);
Student s5 = new Student("王五", 22);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
System.out.println(set);
//通过迭代器遍历
Iterator<Student> it = set.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s);
}
//通过增强for遍历集合
for (Student student : set) {
System.out.println(student);
}
}
}
Map集合的特点和应用
Map集合的特点
特点
双列集合，元素由键值对（Entry）
构成： key -- value
key不可以重复，value可以重复
应用
Map <T1,T2> map = new HashMap<>();
案例：Map集合的简单使用
需求：向Map集合中添加三个元素，并遍历打印
package com.itcast.demo10;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test4 {
public static void main(String[] args) {
Map<Integer,Student> map = new HashMap<>();
Student s1 = new Student("张三", 21);
Student s2 = new Student("李四", 19);
Student s3 = new Student("张三", 21);
map.put(1, s1);
map.put(2, s2);
map.put(3, s3);
//根据键获取值
Student student = map.get(2);
System.out.println("key:"+2+",value"+student);
System.out.println(map);
//遍历双链集合时要先转化成单链集合
Set<Integer> keys = map.keySet();
//迭代器
Iterator<Integer> it = keys.iterator();
while (it.hasNext()){
Integer key = it.next();
Student value = map.get(key);
System.out.println(value);
}
//增强for
Set<Integer> keys1 = map.keySet();
for (Integer integer : keys1) {
Student student1 = map.get(integer);
System.out.println(student1);
}
}
}
案例：模拟斗地主发牌
需求
使用一个集合对象存储一副扑克牌，将所有扑克牌的顺序打乱，然后分发给用集合表示的三个玩家和底牌，并打印玩 家和底牌的集合内容
步骤
1. 买一副扑克牌 将花色和数字分别进行组合，生成所有的普通牌 手动添加“大王”、“小王”
package com.itcast.demo10;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SendTest {
public static void main(String[] args) {
//定义双链集合，键：牌的编号，值：具体的牌
Map<Integer, String> pokers = new HashMap<>();
//定义单链集合，用来存储牌的编号
List<Integer> list = new ArrayList<>();
//普通牌
String[] colors = {"♠", "♥", "♣", "♦"};
String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
int num = 0; // 牌的编号
//循环嵌套 普通牌
for (String number : numbers) { //外循环，获取点数
for (String color : colors) {//内循环，获取花色
String poker = color + number;
//编号,具体的牌放到双列集合中；
pokers.put(num, poker);
//将牌的编号放到单列集合
list.add(num);
//每增加一张，编号自增1
num++;
}
}
//大小王
pokers.put(num, "小王");
list.add(num++);
pokers.put(num, "大王");
list.add(num);
//打印牌
System.out.println("所有的牌" + pokers);
System.out.println("牌的编号" + list);
}
}
2. 洗牌 使用Collections工具类的shuffle()方法打乱牌的顺序
3. 发牌 遍历牌堆，将每一张牌分发到三个玩家集合中 留三张作为底牌
//2.洗牌
Collections.shuffle(list);
System.out.println("洗好牌后" + list);
//3.发牌
//定义四个集合，分别表示3个玩家和底牌
List<Integer> dipai = new ArrayList<>();
List<Integer> xiaohei = new ArrayList<>();
List<Integer> xiaobai = new ArrayList<>();
List<Integer> wuxian = new ArrayList<>();
//具体发牌动作，将索引和3取模，决定发给谁
for (int i = 0; i < list.size(); i++) {
Integer pokerNum = list.get(i);
//System.out.println(pokerNum);
if (i >= list.size() - 3) {
dipai.add(pokerNum);
} else if (i % 3 == 0) {
xiaohei.add(pokerNum);
} else if (i % 3 == 1) {
xiaobai.add(pokerNum);
} else if (i % 3 == 2) {
wuxian.add(pokerNum);
}
}
//查看玩家，底牌的编号
System.out.println("小黑" + xiaohei);
System.out.println("小白" + xiaobai);
System.out.println("无限" + wuxian);
4. 看牌 分别打印每个玩家集合的内容
/*
4.定义一个方法，用来看牌
方法名：printPoker
参数列表：List<Integer>,Map<Integer,String>
返回值：String
*/
public static String printPoker(List<Integer> nums, Map<Integer, String> pokers) {
//对牌的编号进行升序排列
Collections.sort(nums);
//遍历牌的编号集合
StringBuilder sb = new StringBuilder();
for (Integer num : nums) {
//根据编号去双列集合中查找该编号的对于具体牌
String poker = pokers.get(num);
//将获取的牌进行拼接
sb.append(poker + " ");
}
String str = sb.toString();
return str.trim();
//返回最后结果完整代码：
package com.itcast.demo10;
import java.util.*;
public class SendTest {
public static void main(String[] args) {
//定义双链集合，键：牌的编号，值：具体的牌
Map<Integer, String> pokers = new HashMap<>();
//定义单链集合，用来存储牌的编号
List<Integer> list = new ArrayList<>();
//普通牌
String[] colors = {"♠", "♥", "♣", "♦"};
String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
int num = 0; // 牌的编号
//循环嵌套 普通牌
for (String number : numbers) { //外循环，获取点数
for (String color : colors) {//内循环，获取花色
String poker = color + number;
//编号,具体的牌放到双列集合中；
pokers.put(num, poker);
//将牌的编号放到单列集合
list.add(num);
//每增加一张，编号自增1
num++;
}
}
//大小王
pokers.put(num, "小王");
list.add(num++);
pokers.put(num, "大王");
list.add(num);
//打印牌
System.out.println("所有的牌" + pokers);
System.out.println("牌的编号" + list);
System.out.println("--------------------------");
//2.洗牌
Collections.shuffle(list);
System.out.println("洗好牌后" + list);
//3.发牌
//定义四个集合，分别表示3个玩家和底牌
List<Integer> dipai = new ArrayList<>();
List<Integer> xiaohei = new ArrayList<>();
List<Integer> xiaobai = new ArrayList<>();
List<Integer> wuxian = new ArrayList<>();
//具体发牌动作，将索引和3取模，决定发给谁
for (int i = 0; i < list.size(); i++) {
Integer pokerNum = list.get(i);
//System.out.println(pokerNum);
if (i >= list.size() - 3) {
dipai.add(pokerNum);
} else if (i % 3 == 0) {
xiaohei.add(pokerNum);
} else if (i % 3 == 1) {
xiaobai.add(pokerNum);
} else if (i % 3 == 2) {
wuxian.add(pokerNum);
}
}
//查看玩家，底牌的编号
// System.out.println("小黑" + xiaohei);
// System.out.println("小白" + xiaobai);
// System.out.println("无限" + wuxian);
// System.out.println("底牌" + dipai);
//查看具体牌
// String str = printPoker(xiaohei,pokers);
// System.out.println("小黑" +str);
System.out.println("--------------------------");
System.out.println("小黑:" + printPoker(xiaohei, pokers));
System.out.println("小白:" + printPoker(xiaobai, pokers));
System.out.println("无限:" + printPoker(wuxian, pokers));
System.out.println("底牌:" + printPoker(dipai, pokers));
}
/*
4.定义一个方法，用来看牌
方法名：printPoker
参数列表：List<Integer>,Map<Integer,String>
返回值：String
*/
public static String printPoker(List<Integer> nums, Map<Integer, String> pokers) {
//对牌的编号进行升序排列
Collections.sort(nums);
//遍历牌的编号集合
StringBuilder sb = new StringBuilder();
for (Integer num : nums) {
//根据编号去双列集合中查找该编号的对于具体牌
String poker = pokers.get(num);
//将获取的牌进行拼接
sb.append(poker + " ");
}
String str = sb.toString();
return str.trim();
//返回最后结果
}
}
194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
