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)

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

·max(Collection)

返回集合的最大元素

·reverse(List)

f反转List集合元素

·shuffle(List)

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

例子:

//测试类

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集合的特点

特点:

不可重复,无序

应用:

Setset = new HashSet<>();

案例:Set集合的简单使用

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

分析:

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

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

步骤:

1.创建集合对象

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

运行结果:

![]()

声明:该文章系转载,转载该文章的目的在于更广泛的传递信息,并不代表本网站赞同其观点,文章内容仅供参考。

本站是一个个人学习和交流平台,网站上部分文章为网站管理员和网友从相关媒体转载而来,并不用于任何商业目的,内容为作者个人观点, 并不代表本网站赞同其观点和对其真实性负责。

我们已经尽可能的对作者和来源进行了通告,但是可能由于能力有限或疏忽,导致作者和来源有误,亦可能您并不期望您的作品在我们的网站上发布。我们为这些问题向您致歉,如果您在我站上发现此类问题,请及时联系我们,我们将根据您的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。