博学谷：Java基础知识精讲学习笔记——DAY2_博学谷java零基础java配套学习笔记-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_46000312/article/details/122260978

这篇博客详细介绍了Java中的Date类和Calendar类的使用，包括构造方法和成员方法。接着讲解了集合的概念，对比了集合与数组的区别，并探讨了Java集合体系中的List和Set接口及其特点。还涵盖了增强型for循环、迭代器和泛型的使用。此外，文章还介绍了Collections工具类的功能，如排序和反转。最后，讲解了Set和Map集合的特性，包括添加元素、遍历和键值对的处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. Date类

日期和日历类，用于操作日期相关信息。

构造方法

Date() : 构造一个日期对象，当前系统时间，精确到毫秒。

package cn.itcast.dateandcalendardemo;

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        //测试Date类
        //测试空参构造，采用的是当前系统的默认时间。
        Date date1 = new Date();
        System.out.println(date1);
    }
}

Date(long) : 构造一个日期对象，时间为自时间原点起，至指定参数的毫秒数。

package cn.itcast.dateandcalendardemo;

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        //测试Date类

        //Thu Dec 16 14:38:36 CST 2021  ——>1639636716823
        //需求 ： 创建一个指定的时间对象
        Date date2 = new Date(1639636716823l);
        System.out.println(date2);
    }
}

成员方法

long getTime() : 将日期对象转换成对应时间的毫秒值。

package cn.itcast.dateandcalendardemo;

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        //测试Date类
        //测试空参构造，采用的是当前系统的默认时间。
        Date date1 = new Date();
        System.out.println(date1);

        //获取当前系统时间的毫秒值
        long time1 = date1.getTime();
        System.out.println(time1);
    }
}

2.Calendar类

日历类，用于操作日期相关信息。

由于Calendar类是抽象类，所以不能直接创建对象。如果new,则会报错。

成员方法

static Calendar getInstance() : 根据当前系统时区和语言环境获取日历对象。

package cn.itcast.dateandcalendardemo;

import java.util.Calendar;

/*
    Calendar类
            日历类，用于操作日期相关信息。
       成员方法
            - static Calendar getInstance() : 根据当前系统时区和语言环境获取日历对象。
            - int get(int field) : 返回给定日历字段的值。
            - void set(int field,int value) : 将给定的日历字段设置指定的值。
 */
public class CalendarTest {
    public static void main(String[] args) {
        //创建Calendar类型的对象
        Calendar  c = Calendar.getInstance();
        System.out.println(c);
    }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YTT3Lp9v-1640945938278)(C:\Users\26890\AppData\Roaming\Typora\typora-user-images\image-20211216145645027.png)]$

int get(int field) : 返回给定日历字段的值。

package cn.itcast.dateandcalendardemo;

import java.util.Calendar;

/*
    Calendar类
            日历类，用于操作日期相关信息。
       成员方法
            - static Calendar getInstance() : 根据当前系统时区和语言环境获取日历对象。
            - int get(int field) : 返回给定日历字段的值。
            - void set(int field,int value) : 将给定的日历字段设置指定的值。
 */
public class CalendarTest {
    public static void main(String[] args) {
        //创建Calendar类型的对象
        Calendar  c = Calendar.getInstance();
        System.out.println(c);

        //获取年月日的信息
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DATE);
        System.out.println("year: "+year);
        System.out.println("month: "+month);
        System.out.println("day: "+day);

    }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1V5KNoAF-1640945938279)(C:\Users\26890\AppData\Roaming\Typora\typora-user-images\image-20211216152458013.png)]$

void set(int field,int value) : 将给定的日历字段设置指定的值。

package cn.itcast.dateandcalendardemo;

import java.util.Calendar;

/*
    Calendar类
            日历类，用于操作日期相关信息。
       成员方法
            - static Calendar getInstance() : 根据当前系统时区和语言环境获取日历对象。
            - int get(int field) : 返回给定日历字段的值。
            - void set(int field,int value) : 将给定的日历字段设置指定的值。
 */
public class CalendarTest {
    public static void main(String[] args) {
        //创建Calendar类型的对象
        Calendar  c = Calendar.getInstance();
        System.out.println(c);

        //获取年月日的信息
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);//Java中用0-11的数字来表示12个月份，所以要显示实际的月份则需要+1
        int day = c.get(Calendar.DATE);
        System.out.println("year: " + year + "\nmonth: " + (month + 1) + "\nday: " + day);
        System.out.println("-----------------------");

        //将该日历对象设置为指定日期,设置年份
        c.set(Calendar.YEAR,2022);
        int year1 = c.get(Calendar.YEAR);
        System.out.println("year: " + year1 + "\nmonth: " + (month + 1) + "\nday: " + day);
        System.out.println("-----------------------");

        //同时设置年月日,设置为2022年5月14日
        c.set(2022,4,14);
        int year2 = c.get(Calendar.YEAR);
        int month2 = c.get(Calendar.MONTH);//Java中用0-11的数字来表示12个月份，所以要显示实际的月份则需要+1
        int day2 = c.get(Calendar.DATE);
        System.out.println("year: " + year2 + "\nmonth: " + (month2 + 1) + "\nday: " + day2);

    }
}

3.集合

简称集，是用来存储多个元素的容器。

集合和数组的区别

元素类型：集合内的元素类型是引用类型（在存储基本类型时会自动装箱），数组内的元素类型时基本类型或元素类型。
元素个数：集合的元素个数是不固定的，可任意扩容的；数组中的元素个数是固定的，不能改变容量。
集合的好处：不受容器大小限制，可以随时添加、删除元素；提供了大量操作元素的方法（判断、获取等）

Java的集合体系

单列集合（Collection——接口）
- List ——接口: ArrayList——实现类
- Set ——接口: HashSet——实现类
双列集合（Map——接口 : key,value）
- HashMap——实现类

4.List集合的特点和应用

List集合的特点

特点：可重复（可添加相同元素）、有序（存取顺序相同）
注意：List是接口，所以可以通过创建其子类ArrayList对象来完成接口实例化。
```
List list = new ArrayList();//父接口指向子类对象，即多态
```
List接口中的常用成员方法：
- public boolean add(E e) : //将数据添加到集合的末尾，这里的E指的是泛型（目前可以先理解为Object类型）
- public E get(int index) : //根据索引，找到索取的元素
- public int size() : //获取集合的长度
使用集合的步骤：
- 创建集合对象
- 创建元素对象
- 将元素添加到集合中
- 遍历集合

案例：List集合的简单使用

需求：向List集合中添加三个元素，并遍历打印。
分析：
- 向集合中添加元素的方法为： add()
- 遍历集合的方式为： for循环
- 获取集合中元素个数的方法：size()
步骤：
- 创建集合对象
```
List list = new ArrayList();
```
- 分别创建三个Student对象
- 使用add()放啊将Student对象添加到集合总
- 使用for循环遍历集合并打印

package cn.itcast.demo1;

import java.util.ArrayList;
import java.util.List;

/*
      List集合的特点
            - 特点 ：可重复（可添加相同元素）、有序（存取顺序相同）
            - 注意 ：List是接口，所以可以通过创建其子类ArrayList对象来完成接口实例化。
                    List list = new ArrayList();//父接口指向子类对象，即多态
    - List接口中的常用成员方法：
         - public boolean add(E e) : //将数据添加到集合的末尾，这里的E指的是泛型（目前可以先理解为Object类型）
        - public E get(int index) : //根据索引，找到索取的元素
        - public int size() : //获取集合的长度
    - 使用集合的步骤：
         - 创建集合对象
         - 创建元素对象
         - 将元素添加到集合中
          - 遍历集合
 */
public class Test {
    public static void main(String[] args) {
//        - 创建集合对象
        List list = new ArrayList();
//         - 创建元素对象 :创建学生对象，首先创建一个学生类
        Student stu1 = new Student("学生1",1);
        Student stu2 = new Student("学生2",2);
        Student stu3 = new Student("学生3",3);

        // - 将元素添加到集合中,add()方法是有返回值的，但每一次添加一定成功且返回值为true，所以返回值是没有意义的
        //  boolean b1 = list.add(stu1);
        // System.out.println(b1);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        //经上述操作且添加两个相同元素后，若此时直接打印，则可以看到输出顺序是按照添加顺序来的
        list.add(stu1);
        System.out.println(list);
        //get()方法，获取索引为2的元素
        Object obj1 = list.get(2);
        System.out.println("索引为2的元素是：" + obj1);
        //获取集合元素个数
        System.out.println("集合list中的元素个数为：" + list.size());
        //  - 遍历集合
        for (int i = 0; i < list.size(); i++) {
            //i表示的是集合中每个元素的索引
            System.out.println("索引为 ：" + i + "的元素是：" + list.get(i));
        }

    }
}

package cn.itcast.demo1;
/*
        学生类
        其属性为姓名，id
 */
public class Student {
    //名字属性
    private String name;
    //id属性
    private int id;

    //创建空参和全参构造方法
    public Student() {
    }

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    //重写getter()
    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    //setter()
    public void setName(String name) {
        this.name = name;
    }

    public void setId(int id) {
        this.id = id;
    }

    //重写toString()

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

5.增强型for循环

简化数组和集合的遍历。

格式

for(元素的数据类型  变量名 ：数组或集合对象){
		//循环体，变量也就是元素
}

案例演示

使用增强型for循环遍历List集合

package cn.itcast.demo2;

import java.util.ArrayList;
import java.util.List;

/*
    通过增强型for循环遍历List集合
    快捷方式 ———— iter
    注意：
        增强for的底层依赖的迭代器，即增强for就是迭代器的简写形式。
        
 */
public class Test {
    public static void main(String[] args) {
        //创建集合的步骤
        //1.创建List对象
        List list = new ArrayList();
        //2.创建元素对象（Student ——先创建该类）
        Student stu1 = new Student("学生1",12);
        Student stu2 = new Student("学生2",13);
        Student stu3 = new Student("学生3",14);

        //将元素对象添加到集合中
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        //输出测试
        System.out.println(list);

        //增强型for循环遍历集合
        for (Object obj : list){
            System.out.println(obj);
        }
    }
}

6.迭代器

迭代：对过程的重复即迭代。

迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。

常用方法

next() : 返回迭代的下一个元素对象。
hasNext() : 如果仍有元素可以迭代，则返回true。

案例演示

使用迭代器遍历List集合

package cn.itcast.demo3;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
        迭代器
            迭代：对过程的重复即迭代。
            迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。

        常用方法
            - next() : 返回迭代的下一个元素对象。
            - hasNext() : 如果仍有元素可以迭代，则返回true。

         注意：
            列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加、删除等操作。
            但是必须是通过调用列表迭代器的方法来实现的。

        使用步骤：
            - 根据集合对象获取其对象的迭代器对象
            - 判断迭代器中是否有元素
            - 如果有就获取元素
 */
public class Test {
    public static void main(String[] args) {
        //需求 ： 通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加至集合中
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        //4.遍历集合
        //迭代器的用法
       /* //1.根据集合对象获取其对象的迭代器对象
        Iterator it = list.iterator();
        //2.判断迭代器中是否有元素
        while (it.hasNext()) {//表示如果有元素，则运行循环体
            //如果有就返回元素
//            System.out.println(it.next());
            //向下转型（it.next()是泛型）
            Integer i = (Integer)it.next();
            System.out.println(i);
        }*/
        System.out.println("-----------------------------");

        //需求 ： 若在集合中有整型数据20，则在其后添加字符串java
        //先将整型转换为字符串类型
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            if("20".equals(s)) {//若常量与变量进行比较，要把常量写在前面，可以规避空指针异常（当s为null，调用方法是 变量.equals(常量) 时）
                //假设字符串为20，则在其后加上java
                list.add("java");//但是如果按照这种方法，运行将会报错（抛出ConcurrentModificationException并发修改异常）。
                // 因为在对一个普通迭代器进行遍历操作时，不能再进行其他操作（添加删除等）
                //如果要同时对集合进行多项操作，则必须使用列表迭代器。
            }
            System.out.println(s);
        }

    }
}

package cn.itcast.demo3;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*
       需求：通过列表迭代器对集合进行遍历的同时作添加操作。
 */
public class Test1 {
    public static void main(String[] args) {
        //测试列表迭代器
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加至集合中
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");

        //4.遍历及添加
        ListIterator lit= list.listIterator();
        while(lit.hasNext()) {
            String s =(String) lit.next();
            if ("20".equals(s)) {
                lit.add("java");//此处必须使用列表迭代器的方法，否则依然抛出异常。
            }
            System.out.println(s);
        }
        System.out.println("---------------");
        System.out.println(list);
    }
}

7.泛型

泛指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法的参数。

集合类泛型的解释

表示该集合中存放指定类型的元素。

案例演示（给List集合加上泛型String）

List<String> list = new ArrayList<>();
//在这个集合中只能添加String 类型的数据，其他类型将会报错

泛型的好处

类型安全
避免类型转换

演示

package cn.itcast.demo4;

import java.util.ArrayList;
import java.util.List;

/*
        泛型
            泛指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法的参数。

        集合类泛型的解释
            表示该集合中存放指定类型的元素。
        案例演示（给List集合加上泛型String）
        List<String> list = new ArrayList<>();//在这个集合中只能添加String 类型的数据，其他类型将会报错
        泛型的好处
            - 类型安全
            - 避免类型转换
 */
public class Test {
    public static void main(String[] args) {
            //需求 ：演示泛型
        //1.不使用泛型的集合演示
        List list1 = new ArrayList();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        list1.add("d");

        //遍历
        for (Object obj : list1) {
            String s = (String) obj;
            System.out.println(s);
        }
    }
}
//运行截图如下（正常运行，不报错）

注：假设不用泛型，但是又在集合中添加不同数据类型的数据，那么在遍历时若进行向下转型就会报错。

//假设不用泛型，但是又在集合中添加不同数据类型的数据，那么在遍历时若进行向下转型就会报错。
package cn.itcast.demo4;

import java.util.ArrayList;
import java.util.List;

/*
        泛型
            泛指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法的参数。

        集合类泛型的解释
            表示该集合中存放指定类型的元素。
        案例演示（给List集合加上泛型String）
        List<String> list = new ArrayList<>();//在这个集合中只能添加String 类型的数据，其他类型将会报错
        泛型的好处
            - 类型安全
            - 避免类型转换
 */
public class Test {
    public static void main(String[] args) {
            //需求 ：演示泛型
        //1.不使用泛型的集合演示
        List list1 = new ArrayList();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        list1.add("d");
        //假设在集合中添加一个Integer类型的数据，那么在遍历进行向下转型时就会抛出类型转换异常（ClassCastException）
        list1.add(10);

        //遍历
        for (Object obj : list1) {
            String s = (String) obj;
            System.out.println(s);
        }
    }
}
//运行截图如下

package cn.itcast.demo4;

import java.util.ArrayList;
import java.util.List;

/*
        泛型
            泛指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法的参数。

        集合类泛型的解释
            表示该集合中存放指定类型的元素。
        案例演示（给List集合加上泛型String）
        List<String> list = new ArrayList<>();//在这个集合中只能添加String 类型的数据，其他类型将会报错
        泛型的好处
            - 类型安全
            - 避免类型转换
         总结：泛型一般只和集合类结合使用。
         泛型时JDK5的新特性，但从JDK7以后可以不用指明数据类型（菱形泛型）了。
 */
public class Test {
    public static void main(String[] args) {
            //需求 ：演示泛型
        //1.不使用泛型的集合演示
        List list1 = new ArrayList();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        list1.add("d");
        //假设在集合中添加一个Integer类型的数据，那么在遍历进行向下转型时就会抛出类型转换异常（ClassCastException）
//        list1.add(10);

        //遍历
        for (Object obj : list1) {
            String s = (String) obj;
            System.out.println(s);
        }
        System.out.println("-------------------------");

        List<String> list2 = new ArrayList<>();//JDK7以后后面的尖括号里不用再写数据类型
        //List<String> list2 = new ArrayList<String>();JDK5要写数据类型
        list2.add("abc");
        list2.add("bcd");
        list2.add("cde");

        for (String s : list2) {
            System.out.println(s);
        }
    }
}
//运行截图如下

8.Collections工具类的使用

针对集合进行操作的工具类。

常用成员方法

sort（List） : 根据元素的自然顺序，将指定列表按升序排序
max(Collection) :返回集合的最大元素
reverse(List) : 反转List集合元素
shuffle(List) :使用默认的随机源随机置换指定的列表

package cn.itcast.demo5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*
       ### Collections工具类的使用

			针对集合进行操作的工具类。

	**常用成员方法**
            - sort（List<T>） : 根据元素的自然顺序，将指定列表按升序排序
            - max(Collection<T>)  :返回集合的最大元素
            - reverse(List<T>)  : 反转List集合元素
            - shuffle(List<T>)  :使用默认的随机源随机置换指定的列表
 */
public class Test {
    public static void main(String[] args) {
        // 需求 ： 测试Collections的成员方法
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(10);
        list.add(3);
        list.add(11);
        list.add(14);
        list.add(1);

        for (Integer i : list) {
            System.out.println(i);
        }
        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);
        System.out.println("------------------");

        //对集合中的元素进行随即置换
        Collections.shuffle(list);
        System.out.println("随即置换后的元素：" + list);

    }
}
//运行截图如下

9.Set集合的特点

特点：不可重复、无序
应用： Set set = new HashSet<>();
向集合中添加元素的方法为：add()
遍历集合的方式：迭代器

案例：Set集合的简单使用

需求：向Set集合中添加5个元素，并遍历打印。
分析：
- 向集合中添加元素的方法为：add()
- 遍历集合的方式：迭代器
步骤
- 创建集合（Set集合）对象
- 分别创建5个学生对象
- 使用add()方法将元素添加到集合中
- 遍历打印

package cn.itcast.demo6;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
    ### Set集合的特点
        - 特点 ：不可重复、无序,唯一
        - 应用 ： Set<T>  set = new HashSet<>();
        - 向集合中添加元素的方法为：add()
        - 遍历集合的方式 ：迭代器
 */
public class Test {
    public static void main(String[] args) {
        //需求 ：对set集合进行遍历打印
        //1.创建Set集合对象
        Set<Student> set = new HashSet<>();

        //创建学生对象
        Student stu1 = new Student("学生1",1);
        Student stu2 = new Student("学生2",2);
        Student stu3 = new Student("学生3",3);
        Student stu4 = new Student("学生4",4);
        Student stu5 = new Student("学生5",5);
        Student stu6 = new Student("学生5",5);

        //将元素学生对象添加至set集合中
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu3);
        set.add(stu4);
        set.add(stu5);

        //遍历打印
        System.out.println(set);


    }
}

package cn.itcast.demo6;
//学生类，有name和id属性
public class Student {
    private String name;
    private int id;

    //创建全参和空参构造方法

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public Student() {
    }

    //getter and setter

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    //toString()

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

注：set中的唯一性依赖于泛型中的equals()和 HashCode()方法。若没有在泛型中重写这两个方法，那么唯一性就依赖于Object类型中的这两个方法。又由于Object类型中的equals()方法默认比较的是两个对象的地址值。所以运行截图中，重复添加的stu3只出现了一次，但是id和name都相同的学生5出现了两次。

若在Student类中重写equals()和HashCode()方法（如下），则：

package cn.itcast.demo6;

import java.util.Objects;

//学生类，有name和id属性
public class Student {
    private String name;
    private int id;

    //创建全参和空参构造方法

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public Student() {
    }

    //getter and setter

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    //toString()

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

观察下图可发现学生5只出现了一次。

两种遍历方式的演示

通过迭代器进行集合的遍历

package cn.itcast.demo6;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
    ### Set集合的特点
        - 特点 ：不可重复、无序,唯一
        - 应用 ： Set<T>  set = new HashSet<>();
        - 向集合中添加元素的方法为：add()
        - 遍历集合的方式 ：迭代器
 */
public class Test {
    public static void main(String[] args) {
        //需求 ：对set集合进行遍历打印
        //1.创建Set集合对象
        Set<Student> set = new HashSet<>();

        //创建学生对象
        Student stu1 = new Student("学生1",1);
        Student stu2 = new Student("学生2",2);
        Student stu3 = new Student("学生3",3);
        Student stu4 = new Student("学生4",4);
        Student stu5 = new Student("学生5",5);
        Student stu6 = new Student("学生5",5);

        //将元素学生对象添加至set集合中
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu3);
        set.add(stu4);
        set.add(stu5);
        set.add(stu6);

        //遍历打印
        System.out.println(set);
        System.out.println("------------------------");

        //通过迭代器进行遍历
        System.out.println("通过迭代器进行遍历:");
        //1.通过集合对象获取其对应的迭代器对象
        Iterator<Student> it = set.iterator();
        //2.判断迭代器中是否有元素
        //若有则获取对象
        while (it.hasNext()) {
            Student stu = it.next();
            System.out.println(stu);
        }

    }
}

(C:\Users\26890\AppData\Roaming\Typora\typora-user-images\image-20211219173248265.png)]

通过增强for进行集合的遍历

package cn.itcast.demo6;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
    ### Set集合的特点
        - 特点 ：不可重复、无序,唯一
        - 应用 ： Set<T>  set = new HashSet<>();
        - 向集合中添加元素的方法为：add()
        - 遍历集合的方式 ：迭代器
 */
public class Test {
    public static void main(String[] args) {
        //需求 ：对set集合进行遍历打印
        //1.创建Set集合对象
        Set<Student> set = new HashSet<>();

        //创建学生对象
        Student stu1 = new Student("学生1",1);
        Student stu2 = new Student("学生2",2);
        Student stu3 = new Student("学生3",3);
        Student stu4 = new Student("学生4",4);
        Student stu5 = new Student("学生5",5);
        Student stu6 = new Student("学生5",5);

        //将元素学生对象添加至set集合中
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu3);
        set.add(stu4);
        set.add(stu5);
        set.add(stu6);

        //遍历打印
        System.out.println(set);
        System.out.println("------------------------");

        //通过迭代器进行遍历
        System.out.println("通过迭代器进行遍历:");
        //1.通过集合对象获取其对应的迭代器对象
        Iterator<Student> it = set.iterator();
        //2.判断迭代器中是否有元素
        //若有则获取对象
        while (it.hasNext()) {
            Student stu = it.next();
            System.out.println(stu);
        }
        System.out.println("------------------------");

        //通过增强for进行遍历
        System.out.println("通过增强for进行遍历:");
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

10.Map集合的特点和应用

Map集合的特点

特点：Map集合是双列集合，元素由键值对（Entry）构成：(key,value).key具有唯一性，value可以重复
应用：Map<T1,T2> map = new HashMap<>();

案例：Map集合的简单使用

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

向map集合中添加元素：put()

用put方法向集合中添加元素后，返回的是该键的上一个值。比如，第一次添加键为1的元素，返回值就为null；第二次添加键为1 的元素，返回值就是第一次添加进来的元素的值。

package cn.itcast.demo1;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
    **Map集合的特点**
        - 特点：Map集合是双列集合，元素由键值对（Entry）构成：(key,value).key具有唯一性，value可以重复
        - 应用：Map<T1,T2> map = new HashMap<>();

        **案例：Map集合的简单使用**

        - 需求：向Map集合中添加三个元素，并遍历打印
        - 分析
          - 向map集合中添加元素：put()
          - 遍历集合的方式：
            - 先获取所有的key :keySet()
            - 遍历keySet,通过key获取value：get()
          - 遍历keySet的方法 ：iterator()
        - 步骤
          - 创建集合对象：Map<Integer,Student> map = new HashMap<> ();  <u>键是学生编号（Integer类型），值是具体的学生对象（Student类型）。</u>
          - 创建三个学生对象
          - 将学生对象添加到集合中（put()方法）
          - 获取所有的key，并使用迭代器进行遍历
 */
public class MapTest {
    public static void main(String[] args) {
        //需求 ：向双列集合Map中添加三个学生对象并打印
        //1.创建双列集合
        Map<Integer,Student> map = new HashMap<>();

        //2.创建学生对象
        Student stu1 = new Student("学生1",17);
        Student stu2 = new Student("学生2",18);
        Student stu3 = new Student("学生3",19);


        //3.将学生对象添加进集合
        Student  s1 = map.put(1,stu1);
        map.put(2,stu2);
        map.put(3,stu3);

        System.out.println(map);
        //特点测试：key的唯一性
        //先打印key=1不重复时的值
        System.out.println("key = 1 ：" + s1);

        //再添加一个键为1时，集合中key = 1 值
        Student s2 = map.put(1,stu2);
        System.out.println("key = 1 ：" + s2);
        
    }
}

遍历集合的方式：
- 先获取所有的key :keySet()
- 遍历keySet,通过key获取value：get()
遍历keySet的方法：iterator()

步骤
- 创建集合对象：Map<Integer,Student> map = new HashMap<> (); 键是学生编号（Integer类型），值是具体的学生对象（Student类型）。
- 创建三个学生对象
- 将学生对象添加到集合中（put()方法）
- 获取所有的key，并使用迭代器进行遍历

package cn.itcast.demo1;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
    **Map集合的特点**
        - 特点：Map集合是双列集合，元素由键值对（Entry）构成：(key,value).key具有唯一性，value可以重复
        - 应用：Map<T1,T2> map = new HashMap<>();

        **案例：Map集合的简单使用**

        - 需求：向Map集合中添加三个元素，并遍历打印
        - 分析
          - 向map集合中添加元素：put()
          - 遍历集合的方式：
            - 先获取所有的key :keySet()
            - 遍历keySet,通过key获取value：get()
          - 遍历keySet的方法 ：iterator()
        - 步骤
          - 创建集合对象：Map<Integer,Student> map = new HashMap<> ();  <u>键是学生编号（Integer类型），值是具体的学生对象（Student类型）。</u>
          - 创建三个学生对象
          - 将学生对象添加到集合中（put()方法）
          - 获取所有的key，并使用迭代器进行遍历
 */
public class MapTest {
    public static void main(String[] args) {
        //需求 ：向双列集合Map中添加三个学生对象并打印
        //1.创建双列集合
        Map<Integer,Student> map = new HashMap<>();

        //2.创建学生对象
        Student stu1 = new Student("学生1",17);
        Student stu2 = new Student("学生2",18);
        Student stu3 = new Student("学生3",19);


        //3.将学生对象添加进集合
        map.put(1,stu1);
        map.put(2,stu2);
        map.put(3,stu3);
  
     
        //测试get（）方法
        Student s3 = map.get(2);
        System.out.println("当 key = " + 2 + "时，集合中元素对应的值为：" + s3);
        System.out.println("----------------------");

        //4.遍历集合
        //双列集合是不能直接遍历的，要先转换成单列集合再进行遍历
        //遍历步骤
        //4.1 获取所有键的集合 ：通过keySet()方法
        //keySet()方法返回的是一个Set集合
        Set keys = map.keySet();

        //4.2 遍历所有的键，获取每一个键 ：通过迭代器或者增强for循环
        Iterator<Integer> it = keys.iterator();
        while(it.hasNext()) {
           Integer key = it.next();
            //4.3 通过键，获取到指定的值 ： get()方法
           Student stu = map.get(key);
           System.out.println(key);
           System.out.println("key = " + key + "时，元素的值为 ：" + stu);

        }
        
    }
}