javaSE------4.集合

1. Collection 集合

1.1 集合体系结构

集合类的特点

提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

集合类的体系图

1.2 Collection 集合概述和基本使用

Collection 集合概述
是单列集合的顶层接口，它表示一组对象，这些对象也称为 Collection的元素

JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

Collection 集合基本使用

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<>();

        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);
    }
}

1.3 Collection集合的常用方法

boolean add(E e) 			  添加元素

boolean remove(Object o) 	  从集合中移除指定的元素

void clear() 				  清空集合中的元素

boolean contains(Object o)    判断集合中是否存在指定的元素

boolean isEmpty() 			  判断集合是否为空

int size() 				     集合的长度，也就是集合中元素的个数

1.4 Collection集合的遍历

迭代器的介绍
（1）迭代器，集合的专用遍历方式

（2）Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到

（3）迭代器是通过集合的 iterator()方法得到的，所以我们说它是依赖于集合而存在的

Collection 集合的遍历

示例：
public class IteratorDemo {
  public static void main(String[] args) {
    //创建集合对象
    Collection<String> c = new ArrayList<>();
    //添加元素
    c.add("hello");
    c.add("world");
    c.add("java");
    c.add("javaee");
    //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
    Iterator<String> it = c.iterator();
    //用while循环改进元素的判断和获取
    while (it.hasNext()) {
      String s = it.next();
      System.out.println(s);
   }
 }
}

/*案例需求
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合*/
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;
    }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("小李",15);
        Student s2 = new Student("小王",16);
        Student s3 = new Student("小张",17);

        //创建Collection集合对象
        Collection<Student> c=new ArrayList(); //此处集合类的元素应该是Student类

        //把学生对象添加到集合中
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //用 Collection接口的实现类Arraylist调用iterator方法来创建迭代器
        Iterator<Student> it = c.iterator();
        //接口多态
        //迭代器接口<迭代器返回值类型>  对象名=实例化对象ArrayList调用迭代器方法，就会返回一个迭代器
       
        //遍历结合
        while (it.hasNext()){
            Student s= it.next();
            System.out.println("姓名："+s.getName()+"   "+"年龄："+s.getAge());
        }
    }
}

2. List 集合

2.1 List集合概述和特点

List 集合概述：

有序集合 (也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素

与 Set集合不同，列表通常允许重复的元素

List 集合特点：

（1）有索引

（2）可以存储重复元素

（3）元素存取有序

2.2 List集合的特有方法

void add(int index,E element) 		在此集合中的指定位置插入指定的元素

E remove(int index) 				删除指定索引处的元素，返回被删除的元素

E set(int index,E element) 			修改指定索引处的元素，返回被修改的元素

E get(int index) 					返回指定索引处的元素

/*案例需求
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合*/
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;
    }
}

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

public class ListDemo {
    public static void main(String[] args) {
        //创建List对象
       List<Student> list = new ArrayList<>();

       //创建学生类
        Student s1=new Student("李明",20);
        Student s2=new Student("李明",20);
        Student s3=new Student("丹尼",15);

        //把学生对象添加进List集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //第一种遍历数组
        //创建迭代器
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println("姓名："+s.getName()+"年龄："+s.getAge());
        }

        System.out.println("--------");

        //第二种遍历数组(只适用于有索引的集合)
        for (int i = 0; i <list.size(); i++) {
            Student ss = list.get(i);
            System.out.println("姓名："+ss.getName()+"年龄："+ss.getAge());
        }
    }
}

2.3 并发修改异常

（1）出现的原因
迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际
修改值不一致，则会出现：ConcurrentModificationException

（2）解决的方案
用for循环遍历，然后用集合对象做对应的操作即可

示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一 个"javaee"元素

        /*
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next(); //ConcurrentModificationException
            if (s.equals("world")) {
                list.add("javaee");//用集合对象调用方法进行添加，而不是Iterator中的
            }
        }
        */

        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("world")) {
                list.add("javaee");
                System.out.println(list);
            }
        }
    }
}

2.4 列表迭代器

ListIterator 介绍：
是Iterator的子接口，通过 List集合的listIterator()方法得到，所以说它是List集合特有的迭代器

用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

Listiterator中的常用方法：

E next():返回迭代中的下一个元素

boolean hasNext():如果迭代具有更多的元素，则返回true

E previous():返回列表中的上一个元素

boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多的元素，则返回true

void add(E e):   将指定的元素插入列表，注意：此处的方法应该用Listiterator实现类对象调用

示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorDemo {
    public static void main(String[] args) {
        //创建List<>的对象
        List<String> list = new ArrayList<>();

        list.add("hello");
        list.add("world");
        list.add("java");

        //listiterator遍历
        //创建listiterator迭代器
        ListIterator<String> lit = list.listIterator();
//            while (lit.hasNext()){//正向遍历
//                String s = lit.next();
//                System.out.println(s);
//            }
//
//            System.out.println("--------");
//
//            while (lit.hasPrevious()){//逆向遍历
//                String ss = lit.previous();
//                System.out.println(ss);
//            }

       while (lit.hasNext()){
           String s = lit.next();
           if ( s.equals("world")) {
               lit.add("javaee");   //注意：这次是通过ListIterator迭代器调用的方法，之前的是用List集合调用的
           }
       }
        System.out.println(list);
    }
}

2.5 增强for循环

增强for：
（1）简化数组和Collection集合的遍历

（2）实现Iterator接口的类允许其对象成为增强型for语句的目标（此处的目标就是迭代器名）

（3）它是JDK5之后出现的，其内部原理是一个Iterator迭代器

增强for格式：

for (元素数据类型 变量名 : 数组/集合对象名) {
  				循环体;
}

示例：
import java.util.ArrayList;
import java.util.List;
public class ForDemo {
    public static void main(String[] args) {

        int arr[]={1,2,3,4,5};
        for (int i:arr) {
            System.out.println(i);
        }
        System.out.println("--------");

        String strArr[]={"hello","world","java"};
        for (String s:strArr) {
            System.out.println(s);
        }
        System.out.println("--------");

        List<String> list=new ArrayList<>();

        list.add("我");
        list.add("爱");
        list.add("你");

        for (String l:list) {
            System.out.println(l);
        }
        System.out.println("--------");

        //验证底层原理是不是Iterator
        for (String ll:list) {
            if (ll.equals("爱")) { //报错ConcurrentModificationException，说明底层原理是Iterator
                list.add("一万年");
            }
        }
    }
}

案例:List集合存储学生对象三种方式遍历
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;
    }
}

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

public class StudentDemo {
    public static void main(String[] args) {
        //创建list集合对象
        List<Student> list = new ArrayList<>();
        //创建学生类对象
        Student s1=new Student("全智贤",20);
        Student s2=new Student("宋慧乔",21);
        Student s3=new Student("刘亦菲",18);

        //把学生对象导入集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //1.迭代器遍历-----集合特有
        ListIterator<Student> lit = list.listIterator();
        while (lit.hasNext()){
            Student s = lit.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");
        
        //2.普通for遍历-----带有索引的集合和数组
        for (int i = 0; i < list.size(); i++) {
            Student ss = list.get(i);
            System.out.println(ss.getName()+","+ss.getAge());
        }
        System.out.println("--------");
        
        //3.增强for-----最方便
        //方便阅读ListIterator<Student> lit = list.listIterator();
        for (Student sss:list){
            System.out.println(sss.getName()+","+sss.getAge());
        }
    }
}

3. 数据结构

数据结构：
是相互之间存在一定联系或关系的数据元素的集合，也是计算机存储、组织数据的方式。

3.1 数据结构之栈和队列

栈结构：先进的后出

队列结构：先进的先出

3.2 数据结构之数组和链表

数组结构：查询快、增删慢

链表结构：查询慢、增删快

4. List 集合的实现类

4.1 List集合子类的特点

ArrayList 集合：底层是数组结构实现，查询快、增删慢

LinkedList 集合：底层是链表结构实现，查询慢、增删快

//对ArrayList存储字符串并用三种方法遍历
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList的对象
        ArrayList<String> arr=new ArrayList();
            arr.add("hello");
            arr.add("world");
            arr.add("java");


        //1.Iterator遍历
        Iterator<String> it = arr.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("--------");
        //2.普通for遍历
        for (int i = 0; i < arr.size(); i++) {
            String ss = arr.get(i);
            System.out.println(ss);
        }
        System.out.println("--------");
        //3.增强for遍历
        for (String a:arr) {
            System.out.println(a);
        }
    }
}

//对LinkedList存储字符串并用三种方法遍历
import java.util.Iterator;
import java.util.LinkedList;
public class LinkedListDemo {
    public static void main(String[] args) {
        //创建LinkedList的对象
        LinkedList<String> list = new LinkedList();
        list.add("火影忍者");
        list.add("七龙珠");
        list.add("机器猫");

        //1.Iterator遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("--------");
        //2.普通for遍历
        for (int i = 0; i < list.size(); i++) {
            String ss = list.get(i);
            System.out.println(ss);
        }
        System.out.println("--------");
        //3.增强for遍历
        for (String sss:list) {
            System.out.println(sss);
        }
    }
}

/*案例需求
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合*/
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;
    }
}

import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList的对象
        ArrayList<Student> arr=new ArrayList<>();
        //创建Student的对象
        Student s1=new Student("哪里偷",20);
        Student s2=new Student("萨斯给",19);
        Student s3=new Student("萨克拉",18);

        //把学生对象添加到ArrayList集合中
        arr.add(s1);
        arr.add(s2);
        arr.add(s3);

        //1.Iterator遍历
        Iterator<Student> it = arr.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");
        //2.普通for遍历
        for (int i = 0; i < arr.size(); i++) {
            Student ss = arr.get(i);
            System.out.println(ss.getName()+","+ss.getAge());
        }
        System.out.println("--------");
        //2.增强for遍历
        for (Student sss:arr) {
            System.out.println(sss.getName()+","+sss.getAge());
        }

    }
}

4.2 LinkedList集合的特有功能

特有方法：

public void addFirst		(E e) 在该列表开头插入指定的元素

public void addLast			(E e) 将指定的元素追加到此列表的末尾

public E getFirst() 		返回此列表中的第一个元素

public E getLast() 			返回此列表中的最后一个元素

public E removeFirst() 		从此列表中删除并返回第一个元素

public E removeLast() 		从此列表中删除并返回最后一个元素

示例：
import java.util.LinkedList;
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> linkedList=new LinkedList<>();

        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        //1.在第一个元素前面，最后一个元素后面加一个元素
//        linkedList.addFirst("开始");
//        linkedList.addLast("结束");

        //2.获取第一个元素，最后一个元素
//        linkedList.getFirst();
//        linkedList.getLast();
//        System.out.println(linkedList.getFirst()+","+linkedList.getLast());
        
        //3.删除第一个元素，最后一个元素
        linkedList.removeFirst();
        linkedList.removeLast();

        System.out.println(linkedList);
    }
}

5. Set 集合

5.1 Set集合概述和特点

Set 集合概述：
不包含重复元素的集合。 更正式地，集合不包含一对元素e1和e2 ，使得e1.equals(e2) ，并且最多只有一个空元素

Set 集合的特点：
（1）元素存取无序

（2）没有索引、只能通过迭代器或增强 for循环遍历

（3）不能存储重复元素

示例：
import java.util.HashSet;
import java.util.Set;

public class SetDemo {
    public static void main(String[] args) {
        Set<String> set=new HashSet<>();

        set.add("九阴真经");
        set.add("独孤九剑");
        set.add("降龙十八掌");
        
        set.add("九阴真经");

        for(String s:set){
            System.out.println(s);
        }
    }
}

5.2 哈希值

（1）哈希值简介
是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值（不是地址值）

哈希值是为了保证Set集合元素的唯一性而设定的

（2）如何获取哈希值

public int hashCode()     Object类中的hashCode方法返回对象的哈希码值

（3）哈希值的特点
a. 同一个对象多次调用 hashCode()方法返回的哈希值是相同的

b. 默认情况下，不同对象的哈希值是不同的。而重写 hashCode()方法，可以实现让不同对象的哈希值相同

获取哈希值的代码:
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;
    }
}

public class HashCodeDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1=new Student("全智贤",20);
        //1.同一个对象，多次调用hashCode()产生的哈希值相同
        System.out.println(s1.hashCode());      //2083562754
        System.out.println(s1.hashCode());      //2083562754

        System.out.println("--------");

        Student s2=new Student("全智贤",20);

        //2.默认情况下：不同对象，调用hashCode()产生的哈希值不同
        System.out.println(s2.hashCode());      //1239731077

        System.out.println("宋慧乔".hashCode());   //23314072
        System.out.println("金喜善".hashCode());   //36574457
        System.out.println("刘亦菲".hashCode());   //20854308

        System.out.println("--------");

        //3.重写hashCode()方法可以让不同对象，产生相同的哈希值
        System.out.println("重地".hashCode());   //1179395
        System.out.println("通话".hashCode());   //1179395
    }
}

5.3 HashSet集合概述和特点

HashSet 集合概述：
该类实现Set接口，由哈希表支持。 对集合的迭代顺序不作任何保证; 特别是，它不能保证订单在一段时间内保持不变。 这个类允许null元素

HashSet 集合的特点：
（1）底层数据结构是哈希表

（2）对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致

（3）没有带索引的方法，所以不能使用普通 for循环遍历

（4）由于是 Set集合，所以是不包含重复元素的集合

举例：
import java.util.HashSet;
public class HashSetDemo {
    public static void main(String[] args) {
        //创建对象
        HashSet<String> hs=new HashSet<>();

        hs.add("孙悟空");
        hs.add("贝吉塔");
        hs.add("天津饭");

        hs.add("孙悟空");

        for (String s:hs) {
            System.out.println(s); //无序
        }
    }
}

5.4 HashSet集合保证元素唯一性源码分析

HashSet 集合保证元素唯一性的原理：

Tip：
用到的两个方法：hashcode()，equals()

（1）根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入（2）

（2）当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入（3）

（3）通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素

5.5 常见数据结构之哈希表

HashSet 集合存储学生对象并遍历:

创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求：学生对象的成员变量值相同，我们就认为是同一个对象
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;
    }

    //在Student类中重写equals()和hashCode()方法，来实现重复元素的去除
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

import java.util.HashSet;
public class HashSetDemo {
    public static void main(String[] args) {
        //创建HashSet集合的对象
        HashSet<Student> hs=new HashSet<>();

        //创建学生类对象
        Student s1=new Student("令狐冲",18);
        Student s2=new Student("乔峰",25);
        Student s3=new Student("郭靖",18);

        Student s4=new Student("令狐冲",18);

        //把学生类对象添加进集合里
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);

        hs.add(s4);

        //增强for遍历
        for(Student ss:hs){
            System.out.println(ss.getName()+","+ss.getAge());
        }
    }
}

5.6 LinkedHashSet集合概述和特点

LinkedHashSet 集合特点：
（1）哈希表和链表实现的 Set接口，具有可预测的迭代次序

（2）由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

（3）由哈希表保证元素唯一，也就是说没有重复的元素

示例：
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        LinkedHashSet<String> lhs = new LinkedHashSet();

        lhs.add("天龙八部");
        lhs.add("射雕英雄传");
        lhs.add("倚天屠龙记");

        lhs.add("天龙八部");

        for (String s:lhs) {
            System.out.println(s);
        }
    }
}

6. Set集合排序

6.1 TreeSet集合概述和特点

TreeSet 集合概述：
（1）元素有序（不同于存取有序），可以按照一定的规则进行排序，具体排序方式取决于构造方法

TreeSet() 		根据其元素的		自然排序  进行排序

TreeSet(Comparator comparator)    根据指定的比较器进行排序

Tip：

Comparator()     返回用于对该集合中的元素进行排序的比较器

（2）没有带索引的方法，所以不能使用普通 for循环遍历

（3）由于是 Set集合，所以不包含重复元素的集合

import java.util.TreeSet;
public class TreeSetDemo {
    public static void main(String[] args) {
        //<>泛型里只能填引用数据类型，想使用int数据类型就得转化为包装类型
        TreeSet<Integer> treeSet = new TreeSet<>();

        treeSet.add(15); //此处是自动装箱(int-->Integer)
        treeSet.add(8);
        treeSet.add(26);
        treeSet.add(3);

        treeSet.add(15);

        for (Integer s:treeSet) {
            System.out.println(s);
        }
    }
}

6.2 自然排序Comparable的使用

自然排序：
例如：数字从1-10，字母A-Z的排序

public interface Comparable<T>  该接口是带泛型的

该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法

案例需求：
存储学生对象并遍历，创建 TreeSet集合使用无参构造方法

要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

实现步骤：
（1）用 TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的

（2）自然排序，就是让元素所属的类实现 Comparable接口，重写compareTo(T o)方法

（3）重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
public class Student implements Comparable<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 int compareTo(Student s) {
        //return  0;   //重复元素，不添加进来
        //return  1;  //填写正序
        //return -1;   //填写倒序

        //按照年龄从小到大排序
        int num = this.age - s.age; //此处this为s2,s为s1
        //当年龄相同时，按照姓名的字母顺序排序
        int num2 =  num== 0 ? this.name.compareTo(s.name):num;
        //this.name.compareTo(s.name),此处name为字符串类型，而String也可以调用compareTo()，按字典顺序比较两个字符串
        return num2;
    }
}

import java.util.TreeSet;
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();

        Student s1 = new Student("yangguo",25);
        Student s2 = new Student("guojing",40);
        Student s3 = new Student("zhangwuji",22);
        Student s4 = new Student("weixiaobao",3);

        //此处的年龄和s4的相同，不能添加进来
        Student s5 = new Student("renyingying",3);
        Student s6 = new Student("renyingying",3);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        ts.add(s5);
        ts.add(s6);

        for (Student s:ts) {
            //不重写compareTo方法时报错：ClassCastException(类转换异常)
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

6.3 比较器排序Comparator的使用

案例需求：
存储学生对象并遍历，创建 TreeSet集合使用带参构造方法

要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

实现步骤：
（1）用 TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
（2）比较器排序，就是让集合构造方法接收 Comparator的实现类对象，重写compare(T o1,T o2)方法
（3）重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
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;
    }
}

import java.util.Comparator;
import java.util.TreeSet;

public class ComparatorDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student x1, Student x2) {
                //this.age-s.age
                //x1,x2
                int num = x1.getAge()-x2.getAge();
                int num2 =  num==0 ? x1.getName().compareTo(x2.getName()):num;
                return num2;
            }
        });

        Student s1 = new Student("yangguo",25);
        Student s2 = new Student("guojing",40);
        Student s3 = new Student("zhangwuji",22);
        Student s4 = new Student("weixiaobao",3);

        //此处的年龄和s4的相同，不能添加进来
        Student s5 = new Student("renyingying",3);
        Student s6 = new Student("renyingying",3);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        ts.add(s5);
        ts.add(s6);

        for (Student s:ts) {
            //不重写compareTo方法时报错：ClassCastException(类转换异常)
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

6.4 成绩排序案例

案例需求
用 TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合
要求：按照总分从高到低出现
public class Student {
    private String name;
    private int mathscore;
    private int languagescore;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getMathscore() {
        return mathscore;
    }

    public void setMathscore(int mathscore) {
        this.mathscore = mathscore;
    }

    public int getLanguagescore() {
        return languagescore;
    }

    public void setLanguagescore(int languagescore) {
        this.languagescore = languagescore;
    }

    public int  getSum() {
        return (this.languagescore+this.mathscore);
    }
}

import java.util.Comparator;
import java.util.TreeSet;
public class ComparatorDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student x1, Student x2) {
                //主要条件------(一般会给出)
                int num = x2.getSum() -x1.getSum();

                //次要条件------(需要分析)
                int num2 = num == 0 ? x1.getMathscore()-x2.getMathscore(): num;
                int num3 = num2 == 0 ? x1.getName().compareTo(x2.getName()) : num2;
                return num3;
            }
        });

        Student s1 = new Student("令狐冲",80,60);
        Student s2 = new Student("任盈盈",98,21);
        Student s3 = new Student("郭靖",62,58);
        Student s4 = new Student("黄蓉",75,100);

        //s4和s5的总分一样
        Student s5 = new Student("杨过",100,75);

        //s5和s6的总分一样，语文和数学都一样，但是姓名不一样
        Student s6 = new Student("小龙女",100,75);
        
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        
        for (Student ss:ts) {
            System.out.println(ss.getName()+","+ss.getMathscore()+","+ss.getLanguagescore()+","+ss.getSum());
        }
    }
}

6.5 不重复的随机数案例

案例需求：
编写一个程序，获取 10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
/*思路：
1.创建集合对象
2.创建随机数对象
3.循环语句进行判断，当集合长度小于10时，添加进来一个随机数
4.集合遍历*/

import java.util.Random;
import java.util.TreeSet;
public class ScannerDemo {
    public static void main(String[] args) {

        //1.创建TreeSet集合对象
        TreeSet<Integer> ts = new TreeSet<>();

        //2.创建随机数对象
        Random r=new Random();
        
        //3.循环语句进行判断，当集合长度小于10时，添加进来一个随机数
        while (ts.size()<10){
            //把Random对象添加到集合中
            int num=r.nextInt(20)+1;
                ts.add(num);
        }

        //遍历集合
        for(Integer i:ts){
            System.out.println(i);
        }
    }
}

7. 泛型

7.1 泛型概述和好处

泛型概述：
是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型定义格式：
（1）< 类型>：指定一种类型的格式。这里的类型可以看成是形参

（2）< 类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参，将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处：
（1）把运行时期的问题提前到了编译期间

（2）避免了强制类型转换

示例：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        c.add("hello");  //此处系统提示add方法里的参数为Object类型,因为在创建对象的时候没有给泛型，所以此处的参数类型为默认Object
        c.add("world");
        c.add("java");
        c.add(100);     //此处为自动装箱  创建对象加完泛型<String>后，就会亮显次数的编译异常
        //用iterator进行遍历
        Iterator it = c.iterator();

        while (it.hasNext()){
        //Object obj = it.next();  //  此处数据类型为Object类型，与集合类型一致

        //也可以强制转换为String类型
            String s = (String) it.next();  //添加泛型<String>后，不再需要强制转化了

            //报错：Integer类型无法转化为String类型，解决方法----创建对象时加  泛型<>
            System.out.println(s); //ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String
        }
    }
}

7.2 泛型类

定义格式：

修饰符 class 类名<类型> { } 

泛型类示例：
public class Student {
    private String name;

    public Student() {
    }

    public String getName() {
        return name;
    }

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

public class Teacher {
    private Integer age;
    public Teacher() {
    }

    public Integer getAge() {
        return age;
    }

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

public class GenericClass<T> {
    private T x;

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        //1.不用泛型类时，需要定义两个类Student和Teacher
        Student s=new Student();
        s.setName("郭靖");
        System.out.println(s.getName());

        Teacher t = new Teacher();
        t.setAge(30);
        System.out.println(t.getAge());

        System.out.println("--------");

        //2.可以用一个泛型类GenericClass<T>代替定义两个类，简便
        GenericClass<String> g1 = new GenericClass<>();
        g1.setX("郭靖");
        System.out.println(g1.getX());

        GenericClass<Integer> g2 = new GenericClass<>();
        g2.setX(30);
        System.out.println(g2.getX());

        System.out.println("--------");

        GenericClass<Boolean> g3 = new GenericClass<>();
        g3.setX(true);
        System.out.println(g3.getX());

    }
}

7.3 泛型方法

定义格式：

修饰符 <类型> 返回值类型 方法名(类型 变量名) { } 

示例:
public class Generic{

   /* 一般方法
    public void show(String s){
        System.out.println(s);
    }
    public void show(Integer i){
        System.out.println(i);
    }
    public void show(Boolean b){
        System.out.println(b);
    }
    */

    /*
    //用泛型类改写
    public void show(T x){
        System.out.println(x);
    }
    */

    //用泛型方法改写
    public<T> void show(T x){
        System.out.println(x);
    }
}

public class GenericDemo {
    public static void main(String[] args) {

           /*一般方法
            Generic g=new Generic();
            g.show("孙悟空");
            g.show(800);
            g.show(true);*/

           /*
           //用泛型类优化后,记得在类后面加泛型<>
            Generic<String> g1 = new Generic<>();
            g1.show("孙悟空");
            Generic<Integer> g2 = new Generic<>();
            g2.show(100);
            Generic<Boolean> g3 = new Generic<>();
            g3.show(true);
            */

            //泛型方法改进后
                Generic g=new Generic();
                g.show("孙悟空");
                g.show(100);
                g.show(true);
    }
}

7.4 泛型接口

定义格式：

修饰符 interface 接口名<类型> { } 

public interface Generic <T>{
    void show(T x);
}

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T x) {
        System.out.println(x);
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1=new GenericImpl();
        g1.show("孙悟空");
        Generic<Integer> g2=new GenericImpl();
        g2.show(800);
        Generic<Boolean> g3=new GenericImpl();
        g3.show(true);
    }
}

7.5 类型通配符

类型通配符的作用：
为了表示各种泛型 List的父类，可以使用类型通配符

类型通配符的分类：

（1）类型通配符： <?>
List<?> ：表示元素类型未知的List，它的元素可以匹配任何的类型

这种带通配符的 List仅表示它是各种泛型List的父类，并不能把元素添加到其中

（2）类型通配符上限： <? extends 类型>
如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限

List<? extends Number> ：它表示的类型是Number或者其子类型

（3）类型通配符下限： <? super 类型>
如果说我们不希望List<?>是任何泛型List的子类，只希望它代表某一类泛型List的子类，可以使用类型通配符的下限

List<? super Number> ：它表示的类型是Number或者其父类型

示例：
import java.util.ArrayList;
import java.util.List;

public class GenericDemo {
    public static void main(String[] args) {
        //（1）类型通配符： <?>
        List<?> list1=new ArrayList<Object>();
        List<?> list2=new ArrayList<Number>();
        List<?> list3=new ArrayList<Integer>();

        //（2）类型通配符上限： <? extends 类型>   泛型本身及其子类
        List<? extends Number> list4=new ArrayList<Number>();
        List<? extends Number> list6=new ArrayList<Integer>();
        //List<? extends Number> list5=new ArrayList<Object>(); 错误


        //（3）类型通配符下限： <? super 类型>     泛型本身及其父类
        List<? super Number> list7=new ArrayList<Number>();
        List<? super Number> list8=new ArrayList<Object>();
        //List<? super Number> list9=new ArrayList<Integer>();  错误
    }
}

8. 可变参数

8.1 可变参数

可变参数介绍：
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

可变参数定义格式：

修饰符 返回值类型 方法名(数据类型… 变量名) { } 

可变参数的注意事项：
（1）这里的变量其实是一个数组

（2）如果一个方法有多个参数，包含可变参数，可变参数要放在最后

public class ArgsDemo01 {
    public static void main(String[] args) {

        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));

        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));

    }

    public static  int  sum(int b,int... a) {//如果有其他参数时，可变参数放后边
        //a的本质一个被封装的数组
        int sum=0;

        for (int i:a) {
            sum +=i;
        }
        return  sum;
    }

    //一般方法：
//    public static  int  sum(int a,int b) {
//        return a+b;
//    }
//    public static  int  sum(int a,int b,int c) {
//        return a+b+c;
//    }
//    public static  int  sum(int a,int b,int c,int d) {
//        return a+b+c+d;
//    }
	}
}

8.2 可变参数的使用

（1）Arrays 工具类中有一个静态方法：

public static  List asList(T... a)：返回由指定数组支持的固定大小的列表

返回的集合不能做增删操作，可以做修改操作

（2）List 接口中有一个静态方法：

public static  List of(E... elements)：返回包含任意数量元素的不可变列表

返回的集合不能做增删改操作

（3）Set 接口中有一个静态方法：

public static  Set of(E... elements) ：返回一个包含任意数量元素的不可变集合

在给元素的时候，不能给重复的元素

返回的集合不能做增删操作，没有修改的方法

示例：
import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class ArgsDemo02 {
    public static void main(String[] args) {

        //Arrays工具中的静态方法(不能增删，只能修改)
        //public static  List asList(T... a)：返回由指定数组支持的固定大小的列表

//        List<String> list= Arrays.asList("hello","world","java");
//            list.add("javaee");     //UnsupportedOperationException
//            list.remove("java");  //UnsupportedOperationException
//           list.set(0,"cool");
//        System.out.println(list);

        //List<>集合中的静态方法
        //public static  List of(E... elements)：返回包含任意数量元素的不可变列表
//        List<String> list=List.of("hello","world","java");
//        list.add("javaee");  //UnsupportedOperationException
//        list.remove("world");  //UnsupportedOperationException
//          list.set(0,"javaee");  //UnsupportedOperationException
//        System.out.println(list);

        //public static  Set of(E... elements) ：返回一个包含任意数量元素的不可变集合
        Set<String> s=Set.of("hello","world","java");
//        s.add("javaee");  //UnsupportedOperationException
//        s.remove("world");  //UnsupportedOperationException
//       s.set(0,"javaee");  //Set集合没有索引，没有修改方法，所以不能修改
        System.out.println(s);
    }
}

9. Map 集合

9.1 Map集合概述和特点

Map 集合概述:

interface Map<K,V>  K：键的类型；V：值的类型 

Map 集合的特点:

（1）键值对映射关系

（2）一个键对应一个值

（3）键不能重复，值可以重复

（4）元素存取无序

示例：
import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        //创建对象
        Map<String,String> map=new HashMap<>();
        //添加元素
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        map.put("张无忌","赵敏");
        //输出集合对象
        System.out.println(map); //输出结果：{杨过=小龙女, 郭靖=黄蓉, 张无忌=赵敏}
    }
}

9.2 Map集合的基本功能

V put(K key,V value)   添加元素（包括了键和对应的值）

V remove(Object key) 根据键删除键值对元素

void clear()        移除所有的键值对元素

boolean containsKey(Object key)   判断集合是否包含指定的键

boolean containsValue(Object value)    判断集合是否包含指定的值

boolean isEmpty()     判断集合是否为空

int size()      集合的长度，也就是集合中键值对的个数

示例：
import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        //创建对象
        Map<String, String> map = new HashMap<>();
        //1.V put(K key,V value) 添加元素
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        map.put("张无忌","赵敏");
        //2.V remove(Object key) 根据键删除键值对元素
        //map.remove("郭靖");

        //3.void clear() 移除所有的键值对元素
        //map.clear();

        //4.boolean containsKey(Object key) 判断集合是否包含指定的键
        //map.containsKey("张无忌");
        //System.out.println(map.containsKey("张无忌"));

        //5.boolean containsValue(Object value) 判断集合是否包含指定的值
        //map.containsValue("小龙女");
        //System.out.println(map.containsValue("小龙女"));

        //6.boolean isEmpty() 判断集合是否为空
        //map.isEmpty();
        //System.out.println(map.isEmpty());

        //7.int size() 集合的长度，也就是集合中键值对的个数
        map.size();
        System.out.println(map.size());

        System.out.println(map);
    }
}

9.3 Map集合的获取功能

V get(Object key)       根据键获取值

Set keySet() 		   获取所有键的集合（键不能重复，Set集合元素不能重复）

Collection values()    获取所有值的集合（值可以重复，Collection集合元素可以重复）

Set<Map.Entry<K,V>> entrySet()     获取所有键值对对象的集合

示例：
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo03 {
    public static void main(String[] args) {
        //创建对象
        Map<String,String> map=new HashMap<>();

        //添加元素
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        map.put("张无忌","赵敏");

        //1.V get(Object key)       根据键获取值
        System.out.println(map.get("杨过"));
        System.out.println(map.get("周伯通"));  //返回null
        System.out.println("--------");

        //2.Set keySet() 		   获取所有键的集合（键不能重复，Set集合元素不能重复）
        Set<String> keySet = map.keySet();
        //遍历所有键
        for (String k:keySet) {
            System.out.println(k);
        }
        System.out.println("--------");

        //3.Collection values()    获取所有值的集合（值可以重复，Collection集合元素可以重复）
        Collection<String> values = map.values();
        //遍历所有值
        for (String v:values) {
            System.out.println(v);
        }
        System.out.println("--------");

        //4.Set<Map.Entry<K,V>> entrySet()     获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历所有键值对象
        for (Map.Entry<String, String> me:entrySet) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+","+value);
        }
    }
}

9.4 Map集合的遍历(方式1)

遍历思路：
我们刚才存储的元素都是成对出现的，所以我们把 Map看成是一个夫妻对的集合

把所有的丈夫给集中起来

遍历丈夫的集合，获取到每一个丈夫

根据丈夫去找对应的妻子

步骤分析：
（1）获取所有键的集合。用 keySet()方法实现

（2）遍历键的集合，获取到每一个键。用增强 for实现

（3）根据键去找值。用 get(Object key)方法实现

示例：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();

        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        map.put("张无忌","赵敏");

        //1.把所有键集合起来
        Set<String> keySet = map.keySet();
        //2.遍历保存每一个键
        for (String key:keySet) {
            //3.用每一个键去查找对应的值
            String value = map.get(key);
            System.out.println(key+","+value);
        }
    }
}

9.5 Map集合的遍历(方式2)

遍历思路：
我们刚才存储的元素都是成对出现的，所以我们把 Map看成是一个夫妻对的集合

获取所有结婚证的集合

遍历结婚证的集合，得到每一个结婚证

根据结婚证获取丈夫和妻子

步骤分析：
（1）获取所有键值对对象的集合

Set<Map.Entry<K,V>> entrySet() ：获取所有键值对对象的集合

（2）遍历键值对对象的集合，得到每一个键值对对象

用增强 for实现，得到每一个Map.Entry

（3）根据键值对对象获取键和值

用 getKey()得到键

用 getValue()得到值

示例：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo02 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();

        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        map.put("张无忌","赵敏");

        //1.获取所有键值对的对象
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //2.遍历保存所有键值对对象
        for (Map.Entry<String, String> me:entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+","+value);
        }
    }
}

9.6 Map集合的案例

9.6.1 HashMap集合练习之键是String值是Student

案例需求:
创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对元素，并遍历
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;
    }
}

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

/*案例需求:
创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对元素，并遍历*/
public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,Student> map=new HashMap<>();

        //创建学生对象
        Student s1 = new Student("全智贤",25);
        Student s2 = new Student("金喜善",27);
        Student s3 = new Student("宋慧乔",30);

        //给集合中添加键值对元素
        map.put("01",s1);
        map.put("02",s2);
        map.put("03",s3);

        //遍历方式1：遍历保存所有的键，用每一个键去查找对象对应的值
        Set<String> keySet = map.keySet();
        for (String key:keySet) {
            Student value = map.get(key);
            System.out.println(key+","+value.getName()+","+value.getAge());
        }

        System.out.println("--------");

        //遍历方式2：键值对对象的键和值
        Set<Map.Entry<String, Student>> entrySet = map.entrySet();
        for (Map.Entry<String, Student> me:entrySet) {
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key+","+value.getName()+","+value.getAge());
        }
    }
}

9.6.2 HashMap 集合练习之键是Student值是String

案例需求:
创建一个 HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象
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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

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

public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<Student,String> map=new HashMap<>();

        //创建学生对象
        Student s1 = new Student("全智贤",25);
        Student s2 = new Student("金喜善",27);
        Student s3 = new Student("宋慧乔",30);

        Student s4 = new Student("宋慧乔",30);//s3和s4相同

        //添加键值对象到集合
        map.put(s1,"首尔");
        map.put(s2,"济州岛");
        map.put(s3,"汉城");

        map.put(s4,"釜山");  //键相同时,s3的值会被覆盖掉，但是需要在学生类中重写equals和hashCode方法

        Set<Map.Entry<Student, String>> entrySet = map.entrySet();
        for (Map.Entry<Student, String> me:entrySet) {
            Student key = me.getKey();
            String value = me.getValue();
            System.out.println(key.getName()+","+key.getAge()+","+value);
        }
    }
}

9.6.3 集合嵌套之ArrayList嵌套HashMap

/*案例需求:
创建一个 ArrayList集合，存储三个元素，每一个元素都是HashMap
每一个 HashMap的键和值都是String，并遍历。*/
//孙策      大乔
//周瑜      小乔
//令狐冲    任盈盈
//林平之    岳灵珊
//郭靖      黄蓉
//杨过      小龙女
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
        //创建一个 ArrayList集合，存储三个元素，每一个元素都是HashMap,每一个 HashMap的键和值都是String
        ArrayList<HashMap<String, String>> array = new ArrayList<>();

        //创建Hashmap集合对象,并添加元素
        HashMap<String,String> hm1=new HashMap<>();
        hm1.put("孙策","大乔");
        hm1.put("周瑜","小乔");
        //把Hashmap集合对象，添加到ArrayList<HashMap<String, String>>集合中
        array.add(hm1);

        HashMap<String,String> hm2=new HashMap<>();
        hm2.put("令狐冲","任盈盈");
        hm2.put("林平之","岳灵珊");
        array.add(hm2);

        HashMap<String,String> hm3=new HashMap<>();
        hm3.put("郭靖","黄蓉");
        hm3.put("杨过","小龙女");
        array.add(hm3);

        //遍历：
        for (HashMap<String, String> hm:array) {
            Set<String> keySet = hm.keySet();
            for (String key:keySet) {
                String value = hm.get(key);
                System.out.println(key+","+value);
            }
        }
    }
}

9.6.4 集合嵌套之HashMap嵌套ArrayList

/*集合嵌套之HashMap嵌套ArrayList
案例需求
创建一个 HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList
每一个 ArrayList的元素是String，并遍历。*/
//三国：诸葛亮 赵云
//西游：孙悟空 唐僧
//水浒：武松   鲁智深
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class ArrayListDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象，键为String,值为ArrayList，且值的元素类型为
        HashMap<String, ArrayList<String>> hm=new HashMap<>();

        //创建ArrayList集合的对象,并添加元素
        ArrayList<String> sg=new ArrayList<>();
        sg.add("诸葛亮");
        sg.add("赵云");
        //把ArrayList<String>集合添加到HashMap<String, ArrayList<String>>集合
         hm.put("三国演义",sg);

        ArrayList<String> xy=new ArrayList<>();
        xy.add("孙悟空");
        xy.add("唐僧");
        hm.put("西游记",xy);

        ArrayList<String> sh=new ArrayList<>();
        sh.add("武松");
        sh.add("鲁智深");
        hm.put("水浒传",sh);

        //遍历:
        Set<String> keySet = hm.keySet();
        for (String key:keySet) {
            System.out.println(key);
            ArrayList<String> getvalue = hm.get(key);
            for (String value:getvalue) {
                System.out.println("\t"+value);
            }
        }
    }
}

9.6.5 统计字符串中每个字符出现的次数

/*案例需求
键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
举例：键盘录入 “aababcabcdabcde” 在控制台输出：“a(5)b(4)c(3)d(2)e(1)”*/
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class CountStringDemo {
    public static void main(String[] args) {
        //创建随机数对象
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line=sc.nextLine();

        //创建HashMap集合，键是Character(字符)，值是Integer(字符的个数)
        HashMap<Character,Integer> hm=new HashMap<>();

        //for循环，遍历得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i); //遍历并保存了每一个键

            Integer value = hm.get(key);  //保存每一个键对应的值

            //如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
            if (value == null) {
                hm.put(key,1);
            }else{
           //如果返回值不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key,value);
            }
        }
            //遍历集合并用字符串进行拼接
            StringBuilder sb=new StringBuilder();

        Set<Map.Entry<Character, Integer>> entrySet = hm.entrySet();
        for (Map.Entry<Character, Integer> entry:entrySet) {
            Character k = entry.getKey();
            Integer v = entry.getValue();

            sb.append(k).append("(").append(v).append(")");
        }

        //把StringBuilder转化为String
        String result = sb.toString();
        System.out.println(result);
    }
}

10. Collections 集合工具类

10.1 Collections概述和使用

Collections 类的作用：

是针对集合操作的工具类

Collections 类常用方法：

public static void sort(List list)         将指定的列表按升序排序

public static void reverse(List<?> list)   反转指定列表中元素的顺序

public static void shuffle(List<?> list)   使用默认的随机源随机排列指定的列表

示例：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list=new ArrayList<>();

        //添加元素
        list.add(60);
        list.add(40);
        list.add(80);
        list.add(20);
        list.add(50);
        list.add(30);

//        1.public static void sort(List list) 将指定的列表按升序排序
            //Collections.sort(list);

//        2.public static void reverse(List<?> list) 反转指定列表中元素的顺序
            //Collections.reverse(list);
//        3.public static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表
            Collections.shuffle(list);
            System.out.println(list);
    }
}

10.2 ArrayList集合存储学生并排序

//案例需求
//ArrayList 存储学生对象，使用Collections对ArrayList进行排序
//要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class CollectionsDemo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arrayList = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("quanzhixian", 25);
        Student s2 = new Student("songhuiqiao", 30);
        Student s3 = new Student("jinxishan", 30); //s3和s4年龄相同
        Student s4 = new Student("liuyifei", 18);

        //把学生对象添加到集合
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        //sort(List<T> list, Comparator<? super T> c)
        Collections.sort(arrayList, new Comparator<Student>() {
            @Override
            public int compare(Student x1, Student x2) {
                int num = x1.getAge() - x2.getAge();
                int num2 = num == 0 ? x1.getName().compareTo(x2.getName()):num;
                return num2;
            }
        });

        //遍历
        for (Student s:arrayList) {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

10.3 斗地主案例（普通版）

/*案例需求
通过程序实现斗地主过程中的洗牌，发牌和看牌*/
/*思路：
1.创建一个牌盒  ♠♥♦♣
2.洗牌
3.遍历牌盒中的所有牌，分别发给每个玩家，留三张底牌
4.遍历并输出每个玩家手里的牌*/
import java.util.ArrayList;
import java.util.Collections;

public class PokerDemo {
    public static void main(String[] args) {
        //1.创建一个牌盒
        ArrayList<String> poker = new ArrayList<>();
        //创建花色和点数字符串数组
        String colour[] = {"♠", "♥", "♦", "♣"};
        String number[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        //for循环遍历两个数组，并将花色和对应的点数进行拼接,添加到集合中
        for (String c : colour) {
            for (String n : number) {
                String poker2 = c + n;
                poker.add(poker2);
            }
        }
        //把大王，小王也加入牌盒
        poker.add("大王");
        poker.add("小王");

        //2.洗牌
        Collections.shuffle(poker);

        //3.遍历牌盒中的所有牌，分别发给每个玩家，留三张底牌
        //创建三个玩家和底牌集合
        ArrayList<String> play1 = new ArrayList<>();
        ArrayList<String> play2 = new ArrayList<>();
        ArrayList<String> play3 = new ArrayList<>();
        ArrayList<String> lastThree = new ArrayList<>();

        //给每个玩家发牌
        for (int i = 0; i < poker.size(); i++) {
            if (i >= poker.size() - 3) {
                lastThree.add(poker.get(i));
            } else if (i % 3 == 0) { //如果这张牌的编号的索引  对3取余结果是0，就发给第一个人
                play1.add(poker.get(i));
            } else if (i % 3 == 1) {  //如果这张牌的编号的索引  对3取余结果是1，就发给第二个人
                play2.add(poker.get(i));
            } else if (i % 3 == 2) {   //如果这张牌的编号的索引  对3取余结果是2，就发给第三个人
                play3.add(poker.get(i));
            }
        }

        //调用看牌方法
        look("1号玩家",play1);
        look("2号玩家",play2);
        look("3号玩家",play3);
        look("最后三张",lastThree);
    }

       //遍历每个玩家的牌
       public static void look(String name,ArrayList<String> plays) {
           System.out.print(name+"的牌是：");
           for (String s:plays) {
               System.out.print("\t"+s);
           }
           System.out.println();
       }
}

10.4 斗地主案例（升级版）

案例需求：
通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序
import java.util.*;
public class PokerDemo02 {
    public static void main(String[] args) {

        //1.创建一个牌的集合，键是索引，值是牌(花色+点数)
        HashMap<Integer, String> hm = new HashMap<>();

        //2.创建一个集合，用来保存索引
        ArrayList<Integer> arrayList = new ArrayList<>();

        //创建花色和点数字符串数组
        String colour[] = {"♠", "♥", "♦", "♣"};
        String number[] = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};

        //3.遍历所有牌，拼接好后把牌添加进poker集合，同时把索引添加到arrayList集合
        //定义索引初始值
        int index = 0;
        for (String c : colour) {
            for (String n : number) {
                hm.put(index, c + n+"\t");
                arrayList.add(index);
                index++;
            }
        }
            //添加大王，小王
            hm.put(index, "小王");
            arrayList.add(index);
            index++;
            hm.put(index, "大王");
            arrayList.add(index);

            //4.洗牌(洗索引集合)
            Collections.shuffle(arrayList);

            //5.遍历洗好后的牌，分发给每个玩家，留三张底牌(发的是索引)
            //创建三个玩家和底牌TreeSet集合(TreeSet有自然排序的特性)
            TreeSet<Integer> play1 = new TreeSet<>();
            TreeSet<Integer> play2 = new TreeSet<>();
            TreeSet<Integer> play3 = new TreeSet<>();
            TreeSet<Integer> lastThree = new TreeSet<>();

            for (int i = 0; i < arrayList.size(); i++) {
                if (i>=arrayList.size()-3) {
                    lastThree.add(arrayList.get(i));
                }else if (i%3==0) {
                    play1.add(arrayList.get(i));
                }else if (i%3==1) {
                    play2.add(arrayList.get(i));
                }else if (i%3==2) {
                    play3.add(arrayList.get(i));
                }
            }
            //7.调用方法
            look("1号玩家",play1,hm);
            look("2号玩家",play2,hm);
            look("3号玩家",play3,hm);
            look("\t"+"底牌",lastThree,hm);


        }

        //6.定义一个方法，遍历每一个人的牌并输出
        public static void look(String name,TreeSet<Integer> plays,HashMap<Integer, String> hm) {

            System.out.print(name+"的扑克排序显示:");
            for (Integer key:plays) {
                String value = hm.get(key);
                System.out.print(value);
            }
            System.out.println();
        }
    }