[Java知识库]Java笔记

集合进阶

1.Collection

1.集合知识回顾

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。

2.集合类体系结构

3.Collection集合概述和使用

Collection集合概述：
是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素。
JDK不提供此接口的任何直接实现，它提供更具体的子接口（如：Set和List）实现。

创建Collection集合的对象：多态的方式；具体的实现类ArrayList。

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

public class CollectionDemo01 {

    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);
        //[hello, world, java]     //ArrayList重写了toString方法

    }

}

4.Collection集合常用方法

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

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

        //boolean add(E e):添加元素。
        System.out.println(c.add("hello"));  //true
        System.out.println(c.add("hello"));  //true
        /*  Ctrl + B
            public boolean add(E e) {
            modCount++;
            add(e, elementData, size);
            return true;
            }
         */
        // 可以添加重复的内容，并且返回值永远为true。可以改写为：
        c.add("hello");
        c.add("world");
        System.out.println(c);  //[hello, hello, hello, world]

        /*//boolean remove(Object o):从集合中移除指定的元素。
        System.out.println(c.remove("hello"));  //true
        System.out.println(c.remove("javaee" )); //false
        System.out.println(c);  //[hello, hello, world]*/

        /*//void clear():清空集合中的元素。
        //因为是void，所以直接对象调用即可
        c.clear();
        System.out.println(c);  // []*/

        //boolean contains(Object o):判断集合中是否存在指定的元素。
        System.out.println(c.contains("world"));  //true
        System.out.println(c.contains("java"));   //false

        //boolean isEmpty():判断集合是否为空。
        System.out.println(c.isEmpty());  //false

        //int size():集合的长度，也就是集合中元素的个数。
        System.out.println(c.size()); // 4

    }
}

5.Collection集合的遍历

Iterator:迭代器，集合的专用遍历方式。
Iterator iterator() :返回此集合中元素的迭代器，通过集合的iterator()方法得到；
迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的。

Iterator中的常用方法：
E next() : 返回迭代器中的下一个元素；
boolean hasNext（）：如果迭代具有更多元素，则返回true。

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

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

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

        //Iterator<E> iterator() :返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        /*//E next():返回迭代中的下一个元素
        System.out.println(it.next()); //hello
        System.out.println(it.next()); //world
        System.out.println(it.next()); //java
        System.out.println(it.next()); //NoSuchElementException:表示被请求的元素不存在。*/

        //boolean hasNext（）：如果迭代具有更多元素，则返回true。
        while (it.hasNext()){
            //System.out.println(it.next());
            String s = it.next();
            System.out.println(s);
        }
        /*
        hello
        world
        java
         */

    }
}

案例：Collection集合存储学生对象并遍历
需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
思路：
1.定义学生类
2.创建Collection集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合（迭代器方式）

/*
    学生类
 */
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 CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象  注意是Student泛型
        Collection<Student> c = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("路飞", 12);
        Student s2 = new Student("艾斯", 18);
        Student s3 = new Student("萨博", 15);

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

        //遍历集合
        Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}

2.List

概述和特点
概述：
有序集合（也称为序列 ），用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。
与Set集合不同，列表通常允许重复的元素。

特点：
有序：存储和取出的元素顺序一致；
可重复：存储的元素可以重复。

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

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

        //输出集合对象
        //System.out.println(list);  //[hello, world, java, world]

        //采用迭代器的方式进行遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

    }
}

2.List集合特有方法

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

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

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

        //void add(int index, E element)
        list.add(1, "javaee"); //[hello, javaee, world, java]

        //E remove(int index) : 删除指定索引处的元素，返回被删除的元素
        //System.out.println(list.remove(1));  //  javaee

        System.out.println(list.set(1, "hhhh"));

        System.out.println(list.get(1));

        System.out.println(list);

        System.out.println("----------");
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

    }
}

案例：List集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
思路：
1.定义学生类
2.创建List集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合（迭代器方式,for 循环方式）

//学生类

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

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

        //创建学生对象
        Student s1 = new Student("路飞", 12);
        Student s2 = new Student("萨博", 15);
        Student s3 = new Student("艾斯", 18);

        //把学生添加到集合
        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 s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}

3.并发修改异常

ConcurrentModificationException :当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。

产生原因：迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致。

解决方法：用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”元素
       /* 
       //ConcurrentModificationException :当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if(s.equals("world")){
                list.add("javaee");
            }
        }*/

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

4.Listlterator
Listlterator：列表迭代器。
通过List集合的listlterator（）方法得到，所以说它是List集合特有的迭代器。
用于允许程序员沿任一方向遍历列表的列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。

Listlterator中的常用方法：
E next?() ：返回列表中的下一个元素
boolean hasNext?() ：如果此列表迭代器在向前方向遍历列表时具有更多元素，则返回 true 。
E previous?() ：返回列表中的上一个元素
boolean hasPrevious?() ：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回 true
void add?(E e) ：将指定的元素插入列表。

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

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

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

       /* //通过List集合的listIterator()方法得到
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
            *//*
            hello
            world
            java
             *//*
        }
        System.out.println("----------");
        while (lit.hasPrevious()){
            String s = lit.previous();
            System.out.println(s);
            *//*
            java
            world
            hello
             *//*
        }
        System.out.println("----------");
        */
        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            if(s.equals("world")){
                lit.add("javaee");
            }
        }
        System.out.println(list);
        //[hello, world, javaee, java]
        //实际修改值会赋值给预期修改值，就不会出现并发修改异常

    }
}

5.增强for循环
增强for：简化数组和Collection集合的遍历
实现Iterable接口的类允许其对象成为增强型for语句的目标；
它是JDK5之后出现的，其内部原理是一个Iterable迭代器。

增强for的格式：
for（元素数据类型 变量名：数组或者Collection集合）{
//在此处使用变量即可，该变量就是元素
}
例：
int[] arr = {1,2,3,4,5};
for(int i : arr)
{
System.out.println(i);
}

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[] strArray = {"hello", "world", "java"};
        for (String s : strArray) {
            System.out.println(s);
        }
        System.out.println("---------");

        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");

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

        /*//内部原理是一个Interator迭代器
        for (String s:list){
            if(s.equals("world")){
                list.add("javaee");
            }
        }
        //ConcurrentModificationException*/

    }
}

案例：List集合存储学生对象用三种方式遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
思路：
1.定义学生类
2.创建List集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合[迭代器方式（集合特有的）,普通for （带索引），增强for(最方便）]

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

        //创建学生对象
        Student s1 = new Student("艾斯", 18);
        Student s2 = new Student("萨博", 15);
        Student s3 = new Student("路飞", 12);

        //把学生添加到集合
        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循环
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }

        System.out.println("----------");
        //增强for,最方便
        for (Student s : list) {
            System.out.println(s.getName() + "," + s.getAge());
        }
        
    }
}

6.数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合。
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

7.常见的数据结构之栈

一断开口，一端封口。
栈顶元素 / 栈底元素
数据进入栈模型的过程称为：压 / 进栈
数据离开栈模型的过程称为：弹 / 出栈
栈是一种数据先进后出的模型。

8.常见的数据结构之队列

一端开口（后端），一端开头（前端）
数据从后端进入队列模型的过程称为：入队列。
数据从前端离开队列模型的过程称为：出队列。
队列是一种先进先出的模型。

9.常见的数据结构之数组

查询数据通过索引定位，查询任意数据耗时相同，查询效率高；
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低；
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低。
数组是一种查询快，增删慢的模型。

10.常见数据结构之链表

链表是一种增删快，查询慢的模型。（对比数组）
因为每次查询都需要从头（head）部开始查询。

11.List集合子类特点

List集合常用子类：ArrayList、LinkedList
ArrayList：底层为数组，查询快，增删慢
LinkedList：底层为链表，查询慢增删快

练习：分别采用 ArrayList 和 LinkedList 完成存储字符串并遍历

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

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

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

        //遍历
        for (String s : array) {
            System.out.println(s);
        }
        System.out.println("-------");

        for (int i = 0; i < array.size(); i++) {
            String s = array.get(i);
            System.out.println(s);
        }
        System.out.println("-------");

        Iterator<String> it = array.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

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

        LinkedList<String> linked = new LinkedList<>();

        linked.add("路飞");
        linked.add("萨博");
        linked.add("艾斯");

        //遍历
        for (String s : linked) {
            System.out.println(s);
        }
        System.out.println("---------");

        for (int i = 0; i < linked.size(); i++) {
            String s = linked.get(i);
            System.out.println(s);
        }
        System.out.println("---------");

        Iterator<String> it2 = linked.iterator();
        while (it2.hasNext()) {
            String s = it2.next();
            System.out.println(s);
        }

    }
}

案例：ArrayList集合存储学生对象用三种方式遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
思路：
1.定义学生类
2.创建List集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合

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

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

        //创建学生对象
        Student s1 = new Student("路飞", 12);
        Student s2 = new Student("艾斯", 15);
        Student s3 = new Student("萨博", 18);

        //添加
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //遍历
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("------------");

        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("------------");

        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
        
    }
}

12.LinkedList集合的特有功能

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> linkedList = new LinkedList<>();

        linkedList.add("路飞");
        linkedList.add("索隆");
        linkedList.add("娜美");

        System.out.println(linkedList); //[路飞, 索隆, 娜美]

        linkedList.addFirst("乔巴");
        linkedList.addLast("乌索普");
        System.out.println(linkedList);  //[乔巴, 路飞, 索隆, 娜美, 乌索普]

        System.out.println(linkedList.getFirst()); //乔巴
        System.out.println(linkedList.getLast());  //乌索普

        System.out.println(linkedList);  //[乔巴, 路飞, 索隆, 娜美, 乌索普]
        System.out.println("--------");

        System.out.println(linkedList.removeFirst()); //乔巴
        System.out.println(linkedList.removeLast());  //乌索普
        System.out.println(linkedList);  //[路飞, 索隆, 娜美]
        
    }
}

3.Set

1.Set集合概述和特点

Set集合特点：不包含重复元素的集合；没有带索引的方法，所以不能使用普通for循环遍历

Set集合练习：存储字符串并遍历。

import java.util.HashSet;
import java.util.Set;
/*
    Set集合特点：
    不包含重复元素的集合；
    没有带索引的方法，所以不能使用普通for循环遍历

    HashSet：对集合的迭代顺序不作任何保证
 */
public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象。
        Set<String> set = new HashSet<String>();

        //添加元素
        set.add("路飞");
        set.add("索隆");
        set.add("娜美");

        //遍历
        for (String s : set) {
            System.out.println(s);
            /*
            娜美
            索隆
            路飞
             */
        }

    }
}

2.哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。

Object类中有一个方法可以获取对象的哈希值
public int hashCode() :返回对象的哈希码值

对象的哈希值特点：
同一个对象多次调用hashCode() 方法返回的哈希值是相同的；
默认情况下，不同对象的哈希值是不同的。而重写hashCode() 方法，可以实现让不同对象的哈希值相同。

public class HashDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("路飞",12);

        //同一个对象多次调用hasCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode());  //189568618
        System.out.println(s1.hashCode());  //189568618
        System.out.println("-----------");

        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写，可以实现不同对象的哈希值是相同的
        Student s2 = new Student("路飞",12);
        System.out.println(s2.hashCode()); //793589513

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

        System.out.println("hello".hashCode());  //99162322
        System.out.println("world".hashCode());  //113318802
        System.out.println("java".hashCode());   //3254818

        System.out.println("world".hashCode());  //113318802
        System.out.println("------------");

        System.out.println("重地".hashCode());  //1179395
        System.out.println("通话".hashCode());  //1179395

    }
}

3.HashSet集合概述和特点

HashSet集合特点
底层数据结构是哈希表；
对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致；
没有带索引的方法，所以不能使用普通for循环遍历；
由于是Set集合，所以是不包含重复元素的集合。

HashSet集合练习：存储字符串并遍历。

import java.util.HashSet;

public class HashDemo {
    public static void main(String[] args) {
        //创建集合
        HashSet<String> hs = new HashSet<>();

        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");//也不包含重复元素

        //遍历
        for (String s : hs) {
            System.out.println(s);
            /*
            world
            java
            hello
             */
        }

    }
}

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

HashSet集合添加一个元素的过程：

HashSet集合存储元素：要保证元素唯一性，需要重写hashCode()和equals()

5.常见数据结构之哈希表

哈希表：
JDK8之前，底层采用 数组+链表 实现，可以说是一个元素为链表的数组；
JDK8之后，在长度比较长的时候，底层实现了优化。

案例：HashSet集合存储学生对象并遍历
需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合。
要求：学生对象的成员变量值相同，我们就认为是同一个对象。

//重写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<Student> hs = new HashSet<>();

        //创建学生对象
        Student s1 = new Student("路飞", 12);
        Student s2 = new Student("萨博", 15);
        Student s3 = new Student("艾斯", 18);
        Student s4 = new Student("艾斯", 18);

        //添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

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

    }
}

6.LinkedHashSet集合概述和特点

LinkedHashSet集合特点：
哈希表和链表实现的Set接口，具有可预测的迭代次序；
由链表保证元素有序，也就是说元素的存储和取出顺序 是一致的；
由哈希表保证元素唯一，也就是说没有重复的元素

LinkedHashSet集合练习：存储字符串并遍历。

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> link = new LinkedHashSet<>();

        //添加元素
        link.add("路飞");
        link.add("萨博");
        link.add("艾斯");

        //遍历集合
        for (String s : link) {
            System.out.println(s);
        }

    }
}

7.TreeSet集合概述和特点

TreeSet集合特点：
元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法；
TreeSet() :根据其元素的自然排序进行排序，
TreeSet( Comparator comparator) :根据指定的比较器进行排序。
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以不包含重复元素的集合。

TreeSet集合练习：存储整数并遍历

import java.util.TreeSet;

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象   存储整数并遍历
        TreeSet<Integer> tree = new TreeSet<Integer>(); //用的是包装类类型

        //添加元素
        tree.add(12);
        tree.add(20);
        tree.add(23);
        tree.add(50);
        tree.add(18);
        tree.add(20);

        //遍历集合
        for (Integer i : tree) {
            System.out.println(i);
        }
        /*  自然排序且不包含重复元素
        12
        18
        20
        23
        50
         */
        
    }
}

8.自然排序Comparable的使用

存储学生对象并遍历，创建TreeSet集合使用无参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序。

	//学生类重写的内容
 @Override
    public int compareTo(Student s) {
        //return 0;  //认为相同元素，后面不添加
        //return 1;  //升序
        //return -1; //倒序

        //按照年龄从小到大排序
        int num = this.age - s.age; //年龄升序
        //int num = s.age - this.age; //年龄降序

        //年龄相同时，按照姓名的字母顺序排序
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }

import java.util.TreeSet;

public class TreeSetDemo02 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Student> ts = new TreeSet<>();

        //创建学生对象
        Student s1 = new Student("lufei", 12);
        Student s2 = new Student("sabo", 15);
        Student s3 = new Student("aisi", 18);
        Student s4 = new Student("suolong",16);
        Student s5 = new Student("qiaoba",16);

        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

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

    }
}

结论：
用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
自然排序，就是让元素所属的类实现Comparable接口，重写comparaTo(To)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

9.比较器排序Comparator的使用
存储学生对象并遍历，创建TreeSet集合使用带参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序。

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

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象  
        TreeSet<Student> t = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        Student s1 = new Student("lufei", 12);
        Student s2 = new Student("sabo", 15);
        Student s3 = new Student("aisi", 18);
        Student s4 = new Student("suolong", 16);
        Student s5 = new Student("qiaoba", 16);

        //把学生添加到集合
        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        t.add(s5);

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

    }
}

用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
比较器排序，就是让集合构造方法接受Comparator的实现类对象，重写compare(T o1,T o2)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

案例：成绩排序。
需求：用TreeSet集合存储多个学生信息（姓名，语文成绩，数学成绩），并遍历该集合。
要求：按照总分从高到低出现。

法一：比较器排序

/*
    学生类
 */
public class Student {
    private String name;
    private int chinese;
    private int math;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getSum() {
        return this.chinese + this.math;
    }

}

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

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> t = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //int num = (s2.getChinese() + s2.getMath()) - (s1.getChinese() + s1.getMath());
                //主要条件
                int num = s2.getSum() - s1.getSum();
                //次要条件
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;

                return num3;
            }
        });

        //添加学生对象
        Student s1 = new Student("路飞", 95, 93);
        Student s2 = new Student("萨博", 93, 99);
        Student s3 = new Student("艾斯", 97, 90);
        Student s4 = new Student("索隆", 91, 92);
        Student s5 = new Student("乌索普", 97, 90);

        //添加到集合
        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        t.add(s5);

        //遍历集合
        for (Student s : t) {
            System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getSum());
        }

    }
}

法二：自然排序方法

/*
    学生类
 */
public class Student implements Comparable<Student> {
    private String name;
    private int chinese;
    private int math;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getSum() {
        return this.getChinese() + getMath();
    }

    @Override
    public int compareTo(Student s) {
        int num = s.getSum() - this.getSum(); //比较总分
        int num2 = num == 0 ? s.getChinese() - this.getChinese() : num;
        int num3 = num2 == 0 ? s.getName().compareTo(this.getName()) : num2;
        return num3;
    }
    /*//从低到高  this ：s2
    @Override
    public int compareTo(Student s) {
        int num = this.getSum() - s.getSum();
        int num2 = num == 0 ? this.getChinese() - s.getChinese() : num;
        int num3 = num2 == 0 ? this.getName().compareTo(s.getName()) : num2;
        return num3;
    }*/
}

import java.util.TreeSet;

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

        //添加学生对象
        Student s1 = new Student("路飞", 95, 93);
        Student s2 = new Student("萨博", 93, 99);
        Student s3 = new Student("艾斯", 97, 90);
        Student s4 = new Student("索隆", 91, 92);
        Student s5 = new Student("乌索普", 97, 90);

        //添加到集合
        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        t.add(s5);

        //遍历
        for (Student s : t) {
            System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getSum());
        }

    }
}

案例：不重复的随机数
需求：编写一个程序，获取10个 1-20之间的随机数，要求随机数不能重复，并在控制台输出。
思路：
1.创建Set集合对象
2.创建随机数对象
3.判断集合的长度是否小于10
是：产生一个随机数，添加到集合
回到3继续
4.遍历集合

import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo {
    public static void main(String[] args) {
        //创建集合
        Set<Integer> set = new HashSet<Integer>();
        //Set<Integer> set = new TreeSet<Integer>();  //排序输出

        //创建随机数对象
        Random r = new Random();

        //判断集合长度是否小于10
        while (set.size() < 10) {
            //产生随机数,添加到集合
            int number = r.nextInt(20) + 1;
            set.add(number);
        }

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

    }
}

4.泛型

1.泛型概述
泛型：是JDK5中引入的特性，它提供了编译时类型安全监测机制，该机制允许在编译时检测到非法的类型。他的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
参数化类型：就是将类型由原来的具体的类型参数化，然后在使用 / 调用时传入具体的类型。
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。

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

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

/*
    Collection集合存储字符串并遍历
 */
public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        //Collection c = new ArrayList();

        Collection<String> c = new ArrayList<String>();

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

        //遍历
        //Iterator it = c.iterator();
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            /*Object obj = it.next();
            System.out.println(obj);*/
           // String s = (String) it.next();  //ClassCastException
            String s = it.next();
            System.out.println(s);
        }

    }
}

好处：把运行时期的问题提前到编译时期；避免了强制类型转换。

2.泛型类

泛型类的定义格式：
格式： 修饰符 class 类名 <类型>{ }
例：public class Generic< T > { }
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于标识泛型

/*
    泛型类
 */
public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

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

        Generic<String> g1 = new Generic<String>();
        g1.setT("王路飞");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<>();
        g2.setT(25);
        System.out.println(g2.getT());

        Generic<Boolean> g3 = new Generic<>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

3.泛型方法

定义格式：
格式：修饰符<类型> 返回值类型 方法名（类型 变量名）{ }
例：public < T > void show(T t) { }

//泛型方法
public class Generic {
    public <T> void show(T t){
        System.out.println(t);
    }
}

/*
    测试类
 */
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("王路飞");
        g.show(23);
        g.show(true);
        g.show(1.3);
    }
}

4.泛型接口

定义格式：
格式：修饰符 interface 接口名 <类型> { }
例：public interface Generic< T >{ }

/*
    定义接口
 */
public interface Generic <T>{
    void show(T t);
}

/*
    接口实现类
 */
public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

/*
    测试类
 */
public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<>();
        g1.show("乔巴");
        Generic<Integer> g2 = new GenericImpl<>();
        g2.show(18);
    }
}

5.类型通配符

为了表示各种泛型List的父类，可以使用类型通配符：
类型通配符：<?>
List<?>: 表示元素类型未知的List，它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果我们不希望List<?> 是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限：
类型通配符上限：<?extends类型>
List<?extends Number>: 它表示的类型是Number 或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限：
类型通配符下限：<?super类型>
List<?super Number>: 它表示的类型是Number或者其父类型

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

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符：<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("-----------------");
        //类型通配符上限：<?extends类型>
        List<? extends Number> list4 = new ArrayList<Number>();
        List<? extends Number> list5 = new ArrayList<Integer>();
        System.out.println("-----------------");
        //类型通配符下限：<?super类型>
        List<? super Number> list6 = new ArrayList<Object>();
        List<? super Number> list7 = new ArrayList<Number>();
        
    }
}

6.可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
格式：修饰符 返回值类型 方法名（数据类型… 变量名）{ }
例：public static int sum（int…a）{ }

/*
    测试类
 */
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,12,3,6,5,2,5,8,85));
    }
  
    //a 其实是个数组，把参数封装到数组内了
    public static int sum(int... a) {
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        return sum;
    }

}

可变参数注意事项：
这里的变量其实是一个数组；如果一个方法有多个参数，包含可变参数，可变参数要放在最后。

7.可变参数的使用

Arrays工具类中有一个静态方法：
public static < T > List< T > asList(T… a):返回由指定数组支持的固定大小的列表。
返回的集合不能做增删操作，可以做修改操作。

List接口中有一个静态方法：
public static < E > List< E > of(E…elements): 返回包含任意数量元素的不可变列表。
返回的集合不能做增删改操作。

Set接口中有一个静态方法：
public static < E > Set< E > of(E…elements):返回一个包含任意数量元素的不可变集合
在给元素的时候，不能给重复的元素
返回的集合不能做增删操作，没有修改的方法。

import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class ArgsDemo02 {
    public static void main(String[] args) {
      /*  //public static < T  > List< T > asList(T... a):返回由指定数组支持的固定大小的列表。

        List<String> list = Arrays.asList("hello", "world", "java");

        //因为增删会改变数组长度
        //list.add("javaee");   //UnsupportedOperationException
        //list.remove("world");  //UnsupportedOperationException
        list.set(1,"javaee");

        System.out.println(list);
*/
        /*//public static < E > List< E > of(E...elements): 返回包含任意数量元素的不可变列表。

        List<String> list = List.of("hello","world","java","world");

        //list.add("javaee");  //UnsupportedOperationException
        //list.remove("java");  //UnsupportedOperationException
        //list.set(1,"lufei");    //UnsupportedOperationException

        System.out.println(list);*/

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

        Set<String> set = Set.of("hello", "word", "java");
        //set集合不能有重复元素     IllegalArgumentException

//        set.add("javaee");         //UnsupportedOperationException
//        set.remove("world");    //UnsupportedOperationException

        System.out.println(set);

    }
}

5.Map

1.Map集合概述和使用

Map集合概述：
interface Map<K,V> K:键的类型；V：值的类型
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
例：学生的学号和姓名
meili001 路飞
meili002 索隆
meili003 乌索普
meili004 娜美

创建Map集合的对象： 多态的方式；具体的实现类HashMap

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

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

        //V put (K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("meili001","路飞");
        map.put("meili002","索隆");
        map.put("meili003","乌索普");
        map.put("meili004","娜美");
        //保证 K 的唯一性，第二次录入会把第一次值修改了

        System.out.println(map); //{meili002=索隆, meili003=乌索普, meili004=娜美, meili001=路飞}

    }
}

2.Map集合的基本功能

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

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

        map.put("路飞","索隆");
        map.put("娜美","乌索普");
        map.put("乔巴","弗兰克");
        //{娜美=乌索普, 乔巴=弗兰克, 路飞=索隆}

        System.out.println(map.remove("乔巴"));
        System.out.println(map.remove("艾斯"));
        /*
        弗兰克
        null
        {娜美=乌索普, 路飞=索隆}
         */

//        map.clear();  //{}

        System.out.println(map.containsKey("路飞"));  //true
        System.out.println(map.containsKey("萨博"));  //false
        System.out.println("----------");

        System.out.println(map.containsValue("乌索普")); //true
        System.out.println(map.containsValue("索隆"));   //true
        System.out.println(map.containsValue("路飞"));   //false

        System.out.println("===");
        System.out.println(map.isEmpty());   //false

        System.out.println(map);  //{娜美=乌索普, 路飞=索隆}
        System.out.println(map.size());  //2
        System.out.println(map);
    }
}

3.Map集合的获取功能

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("艾斯", "萨博");

        System.out.println(map.get("路飞"));  //索隆 根据K获取V
        System.out.println(map.get("乔巴"));  //null
        //获取所有键的集合
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key);
        }
        /*
        艾斯
        娜美
        路飞
         */
        System.out.println("--------");
        //获取所有值
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
        /*
        萨博
        乌索普
        索隆
         */
    }
}

4.Map集合的遍历（方式1）
我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合。
遍历思路：
把所有的丈夫给集中起来；
遍历丈夫的集合，获取每一个丈夫；
根据丈夫去找对应的妻子。

转化为Map集合中的操作：
获取所有键的集合。用keySet()方法实现；
遍历键的集合，获取到每一个键。用增强for实现；
根据键去找值。用get（Object key）方法实现。

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

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

        //添加元素
        map.put("路飞", "索隆");
        map.put("娜美", "乌索普");
        map.put("艾斯", "萨博");

        //遍历, 获取所有键的集合
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键。
        for (String key : keySet) {
            //根据键去找值
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
        /*
        艾斯,萨博
        娜美,乌索普
        路飞,索隆
         */
    }
}

5.Map集合的遍历（方式2）

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
遍历思路：
获取所有结婚证的集合；
遍历结婚证的集合，得到每一个结婚证；
根据结婚证获取丈夫和妻子。

转换为Map集合中的操作：
获取所有键值对对象的集合：Set<Map.Entry<K,V>> entrySet?() ：获取所有键值对对象的集合
遍历键值对对象的集合，得到每一个键值对对象：用增强for实现，得到每一个Map.Entry
根据键值对对象获取键和值：用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("艾斯", "萨博");

        //遍历:获取所有键值对对象的集合
        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);
        }

    }
}

案例：HashMap集合存储学生对象并遍历。

需求：创建一个HashMap集合，键是学号（String），值是学生对象（Student）。存储三个键值对元素，并遍历。
思路：
1.定义学生类
2.创建HashMap集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合：键找值；键值对对象找键和值。

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

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

        //创建学生对象
        Student s1 = new Student("路飞", 18);
        Student s2 = new Student("索隆", 20);
        Student s3 = new Student("娜美", 17);
        Student s4 = new Student("乔巴", 16);

        //把学生添加到集合
        hm.put("001", s1);
        hm.put("002", s2);
        hm.put("003", s3);
        hm.put("004", s4);

        //遍历集合

        //法一：键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
        System.out.println("-----------------");
        //法二：键值对对象找键和值
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> me:entrySet){
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }

    }
}

案例：HashMap集合存储学生对象并遍历。

需求：创建一个HashMap集合，键是学生对象（Student），值是居住地（String）。存储多个键值对元素，并遍历。要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象。
思路：
1.定义学生类
2.创建HashMap集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合。
6.在学生类中重写两个方法。
hashCode()
equals()

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

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

        //创建学生对象
        Student s1 = new Student("路飞", 18);
        Student s2 = new Student("萨博", 20);
        Student s3 = new Student("艾斯", 22);
        Student s4 = new Student("索隆", 19);
        Student s5 = new Student("路飞", 18);

        //把学生添加到集合
        hm.put(s1, "南海");
        hm.put(s2, "东海");
        hm.put(s3, "北海");
        hm.put(s4, "西海");
        hm.put(s5, "新航路");

        //遍历集合  键找值
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
 
    }
}

案例：ArrayList集合存储HashMap元素并遍历

需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String,并遍历。
思路:
1.创建ArrayList集合
2.创建HashMap集合，并添加键值对元素
3.把HashMap作为元素添加到ArrayList集合
4.遍历ArrayList集合

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<HashMap<String, String>> array = new ArrayList<>();

        //创建HashMap集合
        HashMap<String, String> hm1 = new HashMap<String, String>();
        hm1.put("孙策", "大乔");
        hm1.put("周瑜", "小乔");

        //把HashMap作为元素添加到ArrayList集合
        array.add(hm1);

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

        //把HashMap作为元素添加到ArrayList集合
        array.add(hm2);

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

        //把HashMap作为元素添加到ArrayList集合
        array.add(hm3);

        //遍历ArrayList集合
        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);
            }
        }

    }
}

案例： HashMap集合存储ArrayList元素并遍历

需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素都是String，值是ArrayList，每一个ArrayList的元素是String,并遍历。
思路:
1.创建HashMap集合
2.创建ArrayList集合，并添加元素
3.把ArrayList作为元素添加到HashMap集合
4.遍历HashMap集合

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap<String, ArrayList<String>> hm = new HashMap<>();

        //创建ArrayList集合，并添加元素
        ArrayList<String> sgyy = new ArrayList<>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");

        //把ArrayList作为元素添加到HashMap集合
        hm.put("三国演义", sgyy);

        ArrayList<String> xyj = new ArrayList<>();
        xyj.add("孙悟空");
        xyj.add("唐三藏");

        //把ArrayList作为元素添加到HashMap集合
        hm.put("西游记", xyj);

        ArrayList<String> shz = new ArrayList<>();
        shz.add("武松");
        shz.add("鲁智深");

        //把ArrayList作为元素添加到HashMap集合
        hm.put("水浒传", shz);

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

    }
}

案例：统计字符串中每个字符出现的次数。

需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
举例：键盘录入“aababcabcdabcde” 输出:“a(5)b(4)c(3)d(2)e(1)”
分析：
1.我们可以把结果分成几个部分看：a(5)，b(4)，c(3)，d(2)，e(1)
2.每一个部分可以看成是：字符和字符对应的次数组成
3.这样的数据，可以通过HashMap集合来存储，键是字符，值是字符出现的次数。
注：键是字符，类型是Character;键是字符出现的次数，类型是Integer

思路：
1.键盘录入一个数据
2.创建HashMap集合，键是Character，值是是Integer
3.遍历字符串，得到每一个字符
4.拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
如果是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
如果不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
5.遍历HashMap集合，得到的键和值，按照要求进行拼接
6.输出结果

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

public class HashMapDemo {
    public static void main(String[] args) {
        //1.键盘录入一个数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //2.创建HashMap集合，键是Character，值是是Integer
//        HashMap<Character, Integer> hm = new HashMap<>();
        TreeMap<Character, Integer> hm = new TreeMap<>();  //可以对（键）结果进行排序

        //3.遍历字符串，得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);

            //4.拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);
            //如果是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
            if (value == null) {
                hm.put(key, 1);
            } else {
                //如果不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key, value);
            }
        }

        //5.遍历HashMap集合，得到的键和值，按照要求进行拼接
        StringBuilder sb = new StringBuilder();

        Set<Character> keySet = hm.keySet();
        for (Character key : keySet) {
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result = sb.toString();
        //6.输出结果
        System.out.println(result);
    }
}

6.Collections

1.Collections概述和使用

Collections类的概述：针对集合操作的工具类
Collections类的常用方法：
public static <T extends Comparable<? super T>>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 CollectionsDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();

        //添加元素
        list.add(200);
        list.add(23);
        list.add(69);
        list.add(53);
        list.add(396);

        //public static <T extends Comparable<? super T>>void sort(List<T> list)
//        Collections.sort(list);  //[23, 53, 69, 200, 396]
//        Collections.reverse(list);  //[396, 200, 69, 53, 23]
        Collections.shuffle(list);
        System.out.println(list);

    }
}

案例：ArrayList存储学生对象并排序

需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序。
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

思路：
1.定义学生类
2.创建ArrayList集合对象
3.创建学生对象
4.把学生添加到集合
5.使用Collections对ArrayList集合排序
6.遍历集合

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

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

        //3.创建学生对象
        Student s1 = new Student("lufei", 18);
        Student s2 = new Student("suolong", 20);
        Student s3 = new Student("aisi", 23);
        Student s4 = new Student("sabo", 20);

        //4.把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        //5.使用Collections对ArrayList集合排序
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //按年龄从小到大，年龄相同按名字
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        //6.遍历集合
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

案例：模拟斗地主

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。
思路：
1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
2.往牌盒里装牌
3.洗牌，也就是把牌打散，用Collections的shuffle（）方法实现
4.发牌，也就是遍历集合，给三个玩家发牌
5.看牌，也就是三个玩家分别遍历自己的牌。

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

public class PokerDemo {
    public static void main(String[] args) {
        //1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> array = new ArrayList<>();

        //2.往牌盒里装牌
        //定义花色数组
        String[] colors = {"?", "?", "?", "?"};
        //定义点数数组
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String colour : colors) {
            for (String number : numbers) {
                array.add(colour + number);
            }
        }
        array.add("大王");
        array.add("小王");

        //3.洗牌，也就是把牌打散，用Collections的shuffle（）方法实现
        Collections.shuffle(array);

        //4.发牌，也就是遍历集合，给三个玩家发牌
        ArrayList<String> p1 = new ArrayList<>();
        ArrayList<String> p2 = new ArrayList<>();
        ArrayList<String> p3 = new ArrayList<>();
        ArrayList<String> dp = new ArrayList<>();  //底牌

        for (int i = 0; i < array.size(); i++) {
            String poker = array.get(i);   //遍历，获得每一张牌

            if (i >= array.size() - 3) {
                dp.add(poker);  //最后三张是底牌
            } else if (i % 3 == 0) {
                p1.add(poker);
            } else if (i % 3 == 1) {
                p2.add(poker);
            } else if (i % 3 == 2) {
                p3.add(poker);
            }
        }

        //5.看牌，也就是三个玩家分别遍历自己的牌。
        //调用看牌方法
        lookPoker("路飞",p1);
        lookPoker("萨博",p2);
        lookPoker("艾斯",p3);
        lookPoker("底牌",dp);

    }

    //看牌方法           名字，手里的牌
    public static void lookPoker(String name, ArrayList<String> array) {
        System.out.print(name + "的牌是：");
        for (String poker : array) {
            System.out.print(poker + " ");
        }
        System.out.println();
    }

}