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 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;

}

}

运行结果：


©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,311评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,339评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,671评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,252评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,253评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,031评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,340评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,973评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,466评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,937评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,039评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,701评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,254评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,259评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,485评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,497评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,786评论 2赞 345

推荐阅读更多精彩内容