java 集合工具_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 classStudent {//成员变量//姓名

privateString name;//年龄

private intage;//构造方法//无参构造

publicStudent() {

}//全参构造

public Student(String name, intage) {this.name =name;this.age =age;

}//成员方法

publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

@OverridepublicString toString() {return "Student{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

}

//测试类

importjava.util.ArrayList;importjava.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 classTest {public static voidmain(String[] args) {//1.创建集合对象

List list = newArrayList();//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(数据类型 变量名：数组或者集合对象){

//循环体，变量即元素

}

例子：

importjava.util.ArrayList;importjava.util.List;//测试类//案例：演示增强for循环//快捷方式：iter+回车 生成增强for的格式

/*** 注意：

* 增强for的底层依赖的是迭代器(Iterator)

* 增强for就是迭代器的简写*/

public classTest {public static voidmain(String[] args) {//需求：通过增强for遍历集合List//1.创建集合对象

List list = newArrayList();//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

例子：

importjava.util.ArrayList;importjava.util.List;importjava.util.ListIterator;//测试类//测试列表迭代器

public classTest2 {public static voidmain(String[] args) {//需求：判断如果集合有字符串b，就在它后面添加新的字符串：java//1.创建集合对象

List list = newArrayList();//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)

根据元素的自然顺序，将指定列表按升序排列

·max(Collection)

返回集合的最大元素

·reverse(List)

f反转List集合元素

·shuffle(List)

使用默认的随机源随机置换指定的列表

例子：

//测试类

importjava.util.ArrayList;importjava.util.Collections;importjava.util.List;/***成员方法

* ·sort(List)

* 根据元素的自然顺序，将指定列表按升序排列

* ·max(Collection)

* 返回集合的最大元素

* ·reverse(List)

* f反转List集合元素

* ·shuffle(List)

* 使用默认的随机源随机置换指定的列表

**/

public classTest {public static voidmain(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集合的特点

特点：

不可重复，无序

应用：

Setset = new HashSet<>();

案例：Set集合的简单使用

需求：向Set集合中添加5个元素，并遍历打印

分析：

A.向集合中添加元素的方法：add()

B.遍历集合的方式：迭代器

步骤：

1.创建集合对象

Set set = new HashSet<>();

2.分别创建5个Student对象

3.使用add方法将Student对象添加到集合中

4.使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同

importjava.util.Objects;//定义学生类

public classStudent {//成员变量

privateString name;private intage;//构造方法

public Student(String name, intage) {this.name =name;this.age =age;

}publicStudent() {

}//成员方法

publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

@OverridepublicString toString() {return "Student{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

@Overridepublic booleanequals(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);

}

@Overridepublic inthashCode() {returnObjects.hash(name, age);

}

}

//测试类

importjava.util.HashSet;importjava.util.Iterator;importjava.util.Set;/***案例：Set集合的简单使用

* 需求：向Set集合中添加5个元素，并遍历打印

* 分析：

* A.向集合中添加元素的方法：add()

* B.遍历集合的方式：迭代器

*

* 步骤：

* 1.创建集合对象

* Set set = new HashSet<>();

* 2.分别创建5个Student对象

* 3.使用add方法将Student对象添加到集合中

* 4.使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同

**/

public classTest {public static voidmain(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可以重复

应用：

Mapmap  = new HashMap<>();

案例：Map集合的简单使用

需求：向Map集合中添加三个元素，并遍历打印

分析：

A.向map集合中添加元素的方法为:put()

B:遍历集合的方式：

获取所有的Key:keySet()

遍历keySet,通过key获取value:get()

C.遍历keySet的方法：iterator()

步骤：

1.创建集合对象

Map map = new HashMap<>();

2.创建三个Student对象

3.使用put方法将Studdent对象添加到集合中

4.获取所有keym并使用迭代器遍历

importjava.util.Objects;//学生类

public classStudent {//成员变量

privateString name;private intage;//构造方法

publicStudent() {

}public Student(String name, intage) {this.name =name;this.age =age;

}//成员方法

publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

@OverridepublicString toString() {return "Student{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

@Overridepublic booleanequals(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);

}

@Overridepublic inthashCode() {returnObjects.hash(name, age);

}

}

//测试类

importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Set;/***案例：Map集合的简单使用

* 需求：向Map集合中添加三个元素，并遍历打印

* 分析：

* A.向map集合中添加元素的方法为:put()

* B:遍历集合的方式：

* 获取所有的Key:keySet()

* 遍历keySet,通过key获取value:get()

* C.遍历keySet的方法：iterator()

* 步骤：

* 1.创建集合对象

* Map map = new HashMap<>();

*

* 2.创建三个Student对象

* 3.使用put方法将Studdent对象添加到集合中

* 4.获取所有keym并使用迭代器遍历

*

*

**/

public classTest {public static voidmain(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 classTest {public static voidmain(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 , Mappukers){

String str= "";//给list集合排序

Collections.sort(list);//增强for的方式循环输出玩家的牌

for(Integer integer : list) {

str= str + pukers.get(integer)+"\t";

}returnstr;

}

}

运行结果：