21_Java集合的进阶

Java中的集合进阶

了解：

1、集合知识回顾：

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

2、集合类体系结构（其中Collection、Map、list、Set都是接口【注意list有同名类】）：

一、Colletion（单列）

1、Collection集合概述：

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

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

2、创建Collection集合对象

​ 多态的方式

​ 具体实现类ArrayList

参考代码：

package com.itheima_01;
 
//导包
import java.util.Collection;
import java.util.ArrayList;
 
public class CollectionDemo01 {
    public static void main(String[] args){
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();
 
        //添加元素：boolean add(E e)
        c.add("Hello");
        c.add("World");
        c.add("Java");
 
        //输出集合对象
        System.out.println(c);
    }
}

3、Collection集合常用方法：

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合长度，也就是集合中元素的个数

参考代码：

package com.itheima_01;
/*
测试常用方法:
 boolean add(E e)            添加元素
 boolean remove(Object o)    从集合中移除指定的元素
 void clear()                清空集合中的元素
 boolean contains(Object o)  判断集合中是否在指定的元素
 boolean isEmpty()           判断集合是否为空
 int size()                  集合长度，也就是集合中元素的个数
 
 Alt + 7 可以打开一个类结构窗口
 
 */
//导包
import java.util.Collection;
import java.util.ArrayList;
 
public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> collection = new ArrayList<String>();
 
        //1、boolean add(E e)   添加元素
//        System.out.println(collection.add("张三"));   //判断是否添加成功
//        System.out.println(collection.add("李四"));
//        System.out.println(collection.add("张三"));
 
        //返回值都是true 所以直接这样写，且发现可以有重复元素存在
        collection.add("张三");
        collection.add("李四");
        collection.add("张三");
 
//        //2、boolean remove(Object o)   从集合中移除指定的元素
//        System.out.println(collection.remove("王五"));
//        System.out.println(collection.remove("张三"));
 
//        //3、void clear()  清空集合中的元素
//        collection.clear();
 
//        //4、boolean contains(Object o)  判断集合中是否在指定的元素
//        System.out.println(collection.contains("王五"));
//        System.out.println(collection.contains("张三"));
 
//        //5、boolean isEmpty()  判断集合是否为空
//        System.out.println(collection.isEmpty());
//        collection.clear();
//        System.out.println(collection.isEmpty());
 
        //6、int size()     集合长度，也就是集合中元素的个数
        System.out.println(collection.size());
 
 
        //输出集合对象
        System.out.println(collection);
    }
}

4、Collection集合的遍历：

Iterator：迭代器，集合的专用遍历方式

Iterator<E> iterator();	返回此集合中元素的迭代器，通过集合的iterator()方法得到
//迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Iterator中的常用方法

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

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

参考代码：

package com.itheima_02;
/*
Iterator：迭代器，集合的专用遍历方式
    Iterator<E> iterator();	返回此集合中元素的迭代器，通过集合的iterator()方法得到
    //迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
 
Iterator中的常用方法
 
    E next();	返回迭代器中的下一个元素
    boolean hasNext(); 如果迭代器具有更多元素，则返回true
 */
//导包
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
 
public class IteratorDemo {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> collection = new ArrayList<String>();
 
        //添加元素
        collection.add("hello");
        collection.add("world");
        collection.add("java");
 
        //1、Iterator<E> iterator(); 返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = collection.iterator();
        /*
        public Iterator<E> iterator() {
            return new Itr();
        }
 
         private class Itr implements Iterator<E>{...}
         */
 
        //2、E next();	返回迭代器中的下一个元素
        /*System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());  //NoSuchElementException被各种访问器方法抛出，表示被请求的元素不存在。
        */
 
        //4、boolean hasNext(); 如果迭代器具有更多元素，则返回true
//        if(it.hasNext()){
//            System.out.println(it.next());
//        }
//        if(it.hasNext()){
//            System.out.println(it.next());
//        }
//        if(it.hasNext()){
//            System.out.println(it.next());
//        }
//        if(it.hasNext()) {
//            System.out.println(it.next());
//        }
 
 
        //使用循环实现
        while(it.hasNext()){
//            System.out.println(it.next());
            String s = it.next();
            System.out.println(s);
        }
 
 
//        for(; it.hasNext();){
//            System.out.println(it.next());
//        }
 
    }
}

5、集合的使用步骤：

1、创建集合对象

2、添加元素

​ 2.1、创建元素

​ 2.2、添加元素到集合

​ 合并：添加元素到集合

3、遍历集合

​ 3.1、通过集合对象获取迭代器对象（对象.iterator()）

​ 3.2、通过迭代器对象的hasNext()方法判断是否还有元素

​ 3.3、通过迭代器对象的next()方法获取下一个元素

6、案例：Collection集合存储学生对象并遍历

package com.itheima_03;
/*
定义一个简单的学生类
 */
public class Student {
    private String name;
    private int age;
 
    public Student(){}
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    @Override
    public String toString(){
        return "Student" + "{" +
                "name=" + "'" + this.name + '\'' +
                "age=" + "'" + this.age + '\'' +
                "}";
    }
 
    @Override
    public boolean equals(Object o){
        if(o.toString().equals(this.toString())){
            return true;
        }
        else{
            return false;
        }
    }
 
}

package com.itheima_03;
/*
    使用Collection集合对象存储学生对象并遍历
        注意指明集合 与 迭代器 <> 中的泛型类（需要一致）
 */
 
//导包
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
 
public class CollectionDemo {
    public static void main(String[] args){
        //创建Collection对象
        Collection<Student> collection = new ArrayList<Student>();
 
        //创建学生对象
        Student s1 = new Student("张三", 20);
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 22);
 
        //添加学生对象
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
 
        //获取迭代器对象
        Iterator<Student> it = collection.iterator();
 
        //遍历学生对象
        while(it.hasNext()){
            Student stu = it.next();
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

二、List集合概述和特点

1、List集合概述：

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

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

2、List集合特点：

​ 有序：存储和取出的元素顺序一致

​ 可重复：存储的元素可以重复

参考代码：

package com.itheima_01;
/*
List集合特点：
 
		有序：存储和取出的元素顺序一致
 
		可重复：存储的元素可以重复
 */
//导包
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
 
public class ListDemo01 {
    public static void main(String[] args){
        //创建集合对象
        List<String> list = new ArrayList<String>();
 
        //添加元素
        list.add("元素1");
        list.add("元素2");
        list.add(1, "元素2");
 
        //直接输出集合对象 从输出看Arraylist中重写toString()方法
//        System.out.println(list);
 
        //采用迭代器方式进行遍历
        Iterator<String> it = list.iterator();
 
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

3、List集合特有方法（相较于其父接口类Collcetion）

方法名	说明
void add(int index, E element)	在此集合中指定位置插入指定元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index, E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

参考代码：

package com.itheima_01;
/*
 void add(int index, E element)  在此集合中指定位置插入指定元素
 E remove(int index)             删除指定索引处的元素，返回被删除的元素
 E set(int index, E element)     修改指定索引处的元素，返回被修改的元素
 E get(int index)                返回指定索引处的元素
 */
 
//导包
import java.util.List;
import java.util.ArrayList;
 
public class ListDemo02 {
    public static void main(String[] args){
        //创建集合对象
        List<String> list = new ArrayList<String>();
 
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
 
//        //1、void add(int index, E element)  在此集合中指定位置插入指定元素
//        list.add(2, "javase");
//        list.add(4, "javaee");
 
//        //2、E remove(int index)             删除指定索引处的元素，返回被删除的元素
//        list.remove(2);
 
//        //3、 E set(int index, E element)     修改指定索引处的元素，返回被修改的元素
//        System.out.println(list.set(2, "javase"));
 
//        //4、E get(int index)                返回指定索引处的元素
//        System.out.println(list.get(1));
 
        //for遍历集合
        for(int i = 0; i < list.size(); i++){
            String str = list.get(i);
            System.out.println(str);
        }
 
 
//        //输出集合
//        System.out.println(list);
    }
}

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

package com.itheima_02;
/*
定义一个简单的学生类
 */
public class Student {
    private String name;
    private int age;
 
    public Student(){}
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    @Override
    public String toString(){
        return "Student" + "{" +
                "name=" + "'" + this.name + '\'' +
                "age=" + "'" + this.age + '\'' +
                "}";
    }
 
    @Override
    public boolean equals(Object o){
        if(o.toString().equals(this.toString())){
            return true;
        }
        else{
            return false;
        }
    }
}

package com.itheima_02;
/*
使用List集合存储并遍历学生类
 */
//导包
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
 
public class ListDemo {
    public static void main(String[] args){
        //创建集合对象
        List<Student> list = new ArrayList<Student>();
 
        //创建学生对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
 
        //添加集合对象
        list.add(s1);
        list.add(1, s2);
        list.add(s3);
 
//        //使用迭代器遍历
//        Iterator<Student> it = list.iterator();
//        while(it.hasNext()){
//            Student s = it.next();
//            System.out.println(s.getName() + "," + s.getAge());
//        }
 
 
        //使用for循环遍历
        for(int i = 0; i < list.size(); i++){
            Student stu = list.get(i);
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

5、并发修改异常：

1、并发修改异常：

ConcurrentModificationException

2、产生原因：

迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，所以抛出了异常

3、解决方案：

用for循环遍历，然后用集合对象进行添加操作即可

应为使用 get(int index) 方法获取数组元素时不会对预期修改值和实际修改值进行判断

参考代码：

package com.itheima_03;
/*
需求：
    我有一个集合：List<String> list = new ArrayList<String>();
    里面有三个元素：list.add("hello"); list.add("world"); list.add("java");
    遍历集合：的到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javase"元素，请用代码实现
 */
//导包
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
 
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"这个元素，如果有，我就添加一个"javase"元素，请用代码实现
//        Iterator<String> it = list.iterator();
//        while (it.hasNext()) {
//            String s = it.next();
//            if(s.equals("world")){
//                list.add("javase");
//            }
//        }
 
        for(int i = 0; i < list.size(); i++){
            String s = list.get(i);
            if(s == "world"){
                list.add("javase");
            }
            System.out.println(s);
        }
 
        System.out.println(list);
 
    }
}

!!此为txt文件
public interface List<E>{
    Iterator<E> iterator();
    boolean add(E e);
}
 
public abstract class AbstractList<E>{//ArrayList的抽象父类
    protected int modCount = 0;
}
 
public class ArrayList<E> extends AbstractList<E> implements List<E>{
 
    public E get(int index) {
            Objects.checkIndex(index, size);
            return elementData(index);
    }
 
    //调用add方法后会使得 modCount的值加1 在下一次与expectdeModCount对比时就会抛出异常
    public boolean add(E e) {
            modCount++;
            add(e, elementData, size);
            return true;
    }
 
    public Iterator<E> iterator() {
            return new Itr();
    }
 
    private class Itr implements Iterator<E> {
            int expectedModCount = modCount;  //一开始从抽象父类中继承都为0
            /*
                    modCount：实际修改的集合的次数
                    expectdeModCount：预期修改集合的次数
            */
            public E next() {
                checkForComodification();
                int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length)
                    throw new ConcurrentModificationException();
                cursor = i + 1;
                return (E) elementData[lastRet = i];
            }
 
            //产生的原因：使用迭代器取出元素时 每一次都要进行此判断
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
    }
}

6、ListIterator

1、ListIterator：列表迭代器：

​ 通过List集合的 listIterator() 方法得到，所以说它是List集合特有的迭代器

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

2、ListIterator中常用的方法：

​ E next()：返回迭代器中的下一个元素

​ boolean hasNext()：如果迭代器具有更多元素，则返回true

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

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

​ void add(E e)：将指定元素插入列表中

参考代码：

package com.itheima_04;
 
/*
E next()：返回迭代器中的下一个元素
 
	boolean hasNext()：如果迭代器具有更多元素，则返回true
 
	E previous() ：返回列表中的上一个元素
 
	boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
 
	void add(E e)：将指定元素插入列表中
 */
//导包
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
 
public class Listiterator {
    public static void main(String[] args){
        //创建集合对象
        List<String> list = new ArrayList<String>();
 
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
 
//        //创建列表迭代器对象 一般直接用Iterator
//        ListIterator<String> li = list.listIterator();
//
//        //正向遍历
//        while(li.hasNext()){
//            String s = li.next();
//            System.out.println(s);
//        }
//
//        System.out.println("----------------");
//
//        //逆向遍历  了解即可
//        while(li.hasPrevious()){
//            String s = li.previous();
//            System.out.println(s);
//        }
 
        //获取列表迭代器
        ListIterator<String> li = list.listIterator();
        while(li.hasNext()){
            String s = li.next();
            if(s.equals("world")){
                //此处使用的是列表迭代器对象中的add方法 而没有使用集合对象的add方法
                li.add("javase");
            }
        }
 
        System.out.println(list);
    }
}

public interface List<E>{
    Iterator<E> iterator();
 
    ListIterator<E> listIterator();
 
    boolean add(E e);
}
 
public abstract class AbstractList<E>{//ArrayList的抽象父类
    protected int modCount = 0;
}
 
public class ArrayList<E> extends AbstractList<E> implements List<E>{
 
    public Iterator<E> iterator(){
        return new Itr();
    }
 
    private class Itr implements Iterator<E> {
            ...
    }
 
    public ListIterator<E> listIterator() {
            return new ListItr(0);
    }
 
    private class ListItr extends Itr implements ListIterator<E> {
 
            public void add(E e) {
                checkForComodification();
 
                try {
                    int i = cursor;
                    ArrayList.this.add(i, e);
                    cursor = i + 1;
                    lastRet = -1;
                    //！！！实际修改值重新赋值给预期修改值
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    }
 
 
}

7、增强for循环

1、增强for循环：简化数组和Collection集合的遍历

​ 实现iterator接口的类允许其对象成为增强for语句的目标

​ 它是JDK5之后出现的，其内部原理是一个iterator迭代器

2、增强for格式：

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

8、List集合存储学生对象用三种方式遍历

package com.itheima_06;
/*
使用三种方式存储并遍历 List集合中存储的学生对象
 */
 
//导包
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
 
public class ListDemo {
    public static void main(String[] args){
        //创建List集合对象
        List<Student> list = new ArrayList<Student>();
 
        //创建Student对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
 
        //添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
 
        //使用迭代器进行遍历
        Iterator<Student> it = list.iterator();
 
        while(it.hasNext()){
            Student stu = it.next();
            System.out.println(stu.getName() + "," + stu.getAge());
        }
 
        System.out.println("--------");
 
        //使用常见for循环遍历
        for(int i = 0; i < list.size(); i++){
            Student stu = list.get(i);  //list中有，Collection中没有
            System.out.println(stu.getName() + "," + stu.getAge());
        }
 
        System.out.println("---------");
 
        //使用增强for循环遍历
        for(Student stu : list){
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

9、数据结构：

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合

通常情况下，精心选择的数据结构可以带来更高的运行效率

1、常见数据结构之栈：

操作受限的线性表，栈一端封闭（不可在此进行进栈和出栈的操作），另一端可操作，所以就意味着栈是先进后出的。

可操作端：栈顶

不可操作端：栈底

元素进入栈中：压栈/进栈

元素离开栈中：弹栈/出栈

2、常见数据结构之队列：

操作受限的线性表，队列一端规定只能进，另一端规定只能出（类似于排队），所以说队列是先进先出的。

只能出的一端：队头

只能进的一端：队尾

元素进入队列中：入队

元素离开队列中：出队

3、常见的数据结构之数组（线性表之顺序表）：

操作不受限（针对于前两种）的线性表（查询快，增删慢）

优点：通过数据对应的索引进行访问，查询速度快

缺点：

​ 删除数据时，要将原始数据删除，同时还需要每个数据前移，删除效率低

​ 添加数据时，添加位置后的每一个数据后移，再添加元素，添加效率极低

4、常见的数据结构之链表（线性表之链表）：

操作不受限（针对于前两种）的线性表（增删快，查询慢）

结点：与顺序表不同之处在于，链表的内存空间不是连续的！是通过指针进行关系连接的，所以链表是以结点为单位。

结点（C语言中一般使用结构体实现，在结构体中一部分变量用于存放数据，另一部分指针变量用于存放地址）

​ 数据域：用于存放元素，可以是基本数据类型，也可以是自定义数据类型

​ 指针与：用于指向下一个元素结点的空间地址值

一般来说为了使得，首元结点（第一个结点）与后续元素结点处于相同地位，我们又引入了头结点的概念。

当头结点指针域为null则表示该链表为空。

在链表中添加数据：

​ 先确定好位置，然后先保存前一个结点中的地址值（即后一个结点位置），再用添加结点的地址值覆盖此数值，最后将保存的地址值赋值给添加结点的指针域即可添加一个元素（效率高）

在链表中删除数据：

​ 先确定好位置，保留一下数据，再将这个数据对应的指针域的值赋值给前一个元素的指针域，清理空间即可（效率高）

在链表中查找数据：

​ 只能从头结点开始：顺藤摸瓜，依次查找比对（效率慢）

10、List集合子类特点：

List集合常用子类：ArrayList（顺序表）、LinkedList（链表）

ArrayList：底层数据结构是数组，查询快，增删慢

LinkList：底层数据结构是链表，查询慢，增删快

练习：

分别使用ArrayList和LinkList完成存储数据字符串并遍历

参考代码：

package com.itheima_07;
/*
List集合常用子类：ArrayList（顺序表）、LinkedList（链表）
 
ArrayList：底层数据结构是数组，查询快，增删慢
 
LinkList：底层数据结构是链表，查询慢，增删快
 
 
 
练习：
 
分别使用ArrayList和LinkList完成存储数据字符串并遍历
 
 */
//导包
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Iterator;
 
public class ListDemo {
    public static void main(String[] args){
        //创建对象
        ArrayList<String> arraylist = new ArrayList<String>();
 
        //添加元素
        arraylist.add("hello");
        arraylist.add("world");
        arraylist.add("java");
 
        //迭代器遍历
        Iterator<String> it = arraylist.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
 
        System.out.println("------");
 
        //加强for循环遍历
        for(String s : arraylist){
            System.out.println(s);
        }
 
        System.out.println("------");
 
        //普通for循环遍历
        for(int i = 0; i < arraylist.size(); i++){
            String s = arraylist.get(i);
            System.out.println(s);
        }
 
        System.out.println("以上都是ArrayList集合的遍历");
 
        //创建LinkedList对象
        LinkedList<String> linkedlist = new LinkedList<String>();
 
        //添加元素
        linkedlist.add("java");
        linkedlist.add("javase");
        linkedlist.add("javaee");
 
        //迭代器遍历
        Iterator<String> it2 = linkedlist.iterator();
        while(it2.hasNext()){
            String s = it2.next();
            System.out.println(s);
        }
 
        System.out.println("--------");
 
        //加强for循环遍历
        for(String s : linkedlist){
            System.out.println(s);
        }
 
        System.out.println("--------");
 
        //普通for循环遍历
        for(int i = 0; i < linkedlist.size(); i++){
            String s = linkedlist.get(i);
            System.out.println(s);
        }
    }
}

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

package com.itheima_08;
 
public class Student {
    private String name;
    private int age;
 
    public Student(){
 
    }
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    @Override
    public String toString(){
        return "Student" + "{" +
                "name=" + "'" + this.name + '\'' +
                "age=" + "'" + this.age + '\'' +
                "}";
    }
 
    @Override
    public boolean equals(Object o){
        if(o.toString().equals(this.toString())){
            return true;
        }
        else{
            return false;
        }
    }
}

package com.itheima_08;
/*
通过ArrayList来实现三种遍历
 */
//导包
import java.util.ArrayList;
import java.util.Iterator;
 
public class ArrayListDemo {
    public static void main(String[] args){
        //创建ArrayList对象
        ArrayList<Student> arraylist = new ArrayList<Student>();
 
        //创建Student对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
 
        //添加元素
        arraylist.add(s1);
        arraylist.add(s2);
        arraylist.add(s3);
 
        //创建迭代器对象
        Iterator<Student> it = arraylist.iterator();
        while(it.hasNext()){
            Student stu = it.next();
            System.out.println(stu.getName() + "," + stu.getAge());
        }
 
        System.out.println("--------");
 
        //加强for
        for(Student stu : arraylist){
            System.out.println(stu.getName() + "," + stu.getAge());
        }
 
        System.out.println("--------");
 
        //普通for
        for(int i = 0; i < arraylist.size(); i++){
            Student stu = arraylist.get(i);
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

package com.itheima_08;
 
//导包
import java.util.LinkedList;
import java.util.Iterator;
 
public class LinkedListDemo {
    public static void main(String[] args){
        //创建LinkedList对象
        LinkedList<Student> linkedlist = new LinkedList<Student>();
 
        //创建Student对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
 
        //添加元素
        linkedlist.add(s1);
        linkedlist.add(s2);
        linkedlist.add(s3);
 
        //迭代器遍历
        Iterator<Student> it = linkedlist.iterator();
        while(it.hasNext()){
            Student stu = it.next();
            System.out.println(stu.getName() + "," + stu.getAge());
        }
 
        System.out.println("--------");
 
        //使用加强for循环
        for(Student stu : linkedlist){
            System.out.println(stu.getName() + "," + stu.getAge());
        }
 
        System.out.println("--------");
 
        //使用普通for循环
        for(int i = 0; i < linkedlist.size(); i++){
            Student stu = linkedlist.get(i);
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

12、Linkedlist集合的特有功能：

方法名	说明
public void addFirst(E e)	在列表开头插入指定的元素
public void addLast(E e)	将指定元素追加到此列表中的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

package com.itheima_09;
/*
 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){
        //创建LinkList集合对象
        LinkedList<String> linkedlist = new LinkedList<String>();
 
        //添加元素
        linkedlist.add("List");
        linkedlist.add("ArrayList");
 
        //1、public void addFirst(E e)  在列表开头插入指定的元素
        linkedlist.addFirst("Collection");
 
        //2、public void addLast(E e)   将指定元素追加到此列表中的末尾
        linkedlist.addLast("LinkedList");
 
        //3、public E getFirst()        返回此列表中的第一个元素
        System.out.println("单列集合体系的根是：" + linkedlist.getFirst());
 
        //4、public E getLast()         返回此列表中的最后一个元素
        System.out.println("目前使用的是其子类体系中的：" + linkedlist.getLast());
 
        //5、public E removeFirst()     从此列表中删除并返回第一个元素
        System.out.println("删除了：" + linkedlist.removeFirst());;
 
        //6、public E removeLast()      从此列表中删除并返回最后一个元素
        System.out.println("又删除了：" + linkedlist.removeLast());
 
        //输出元素
        System.out.println("目前还有的元素：" + linkedlist);
    }
}

三、Set集合（数学集）概述和特点

1、Set集合特点：

​ 不包含重复元素的集合

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

2、Set集合练习：

​ 存储字符串并遍历

参考代码：

package com.itheima_01;
/*
1、Set集合特点
 
	不包含重复元素的集合
 
	没有带索引的方法，所以不能使用普通for循环遍历
 
	HashSet 对集合的迭代顺序不作任何保证
 */
//导包
import java.util.Set;   //Set是一个接口 不能直接实现对象 要通过多态来创建
import java.util.HashSet;
 
public class SetDemo {
    public static void main(String[] args){
        //创建Set集合对象
        Set<String> set = new HashSet<String>();
 
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        set.add("hello");
 
        //增强for遍历元素
        for(String s : set){
            //从输出来看 就是无序的，自然没有索引一说
            //同时，里面不允许出现重复元素
            System.out.println(s);
        }
    }
}

3、哈希值：

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

Object类中有一个方法可以获取对象的哈希值

​ public int hashCode(); 返回对象的哈希码值

对象的哈希值特点

​ 同一个对象多次调用hashCode()方法返回的哈希值是相同的

​ 默认情况下，不同对象的哈希值是不同的，而且重写hashCode()方法，可以实现不同对象的哈希值相同（但是此时哈希值相同并不代表元素的内容相同）

参考代码：

package com.itheima_02;
/*
哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
 
Object类中有一个方法可以获取对象的哈希值
 
	public int hashCode();	返回对象的哈希码值
 */
//导包
import java.util.Set;
import java.util.HashSet;
 
public class HashDemo {
    public static void main(String[] args){
        //创建学生对象
        Student stu = new Student("张三", 19);
 
        //使用Object超类中的 public int hashCode();	返回对象的哈希码值
        //同一个对象 多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(stu.hashCode());     //1435804085
        System.out.println(stu.hashCode());     //1435804085
 
        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写可以使得 不同对象的哈希值相同
        Student stu2 = new Student("李四", 20);
        System.out.println(stu2.hashCode());    //1784662007
 
        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
    }
}

4、HashSet集合概述和特点：

HashSet集合特点

​ 底层数据结构是哈希表

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

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

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

HashSet集合练习

​ 存储字符串并遍历

参考代码：

package com.itheima_03;
/*
HashSet集合特点
 
	底层数据结构是哈希表
 
	对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
 
	没有带索引的方法，所以不能使用普通for循环遍历
 
	由于是Set集合，所以是不包含重复元素的集合
 */
 
//导包
import java.util.Set;
import java.util.HashSet;
 
public class HashDemo {
    public static void main(String[] args){
        //创建集合对象
        HashSet<String> hashset = new HashSet<String>();
 
        //添加元素
        hashset.add("hello");
        hashset.add("world");
        hashset.add("java");
        hashset.add("world");
 
        //遍历
        for(String s : hashset){
            System.out.println(s);
        }
    }
}

5、HastSet集合保证元素唯一性源码分析

//创建集合对象
HashSet<String> hashset = new HashSet<String>();
//添加元素
hashset.add("hello");
hashset.add("world");
hashset.add("java");
hashset.add("world");
 
--------------------------------------------
 
 
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
 
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
 
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
 
//hash值和元素的hashCode()方法相关
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果哈希表未初始化，就对其进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
 
    //根据对象的哈希值计算对象的存储位置，如果该位置没有元素，就存储元素
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        /*
            存入的元素和以前的元素比较哈希值
                如果哈希值不同，第一个if判断直接短路，继续向下执行，把元素添加到集合
                如果哈希值相同，会调用对象的equals()方法进行比较
                    如果返回false，继续向下执行，把元素添加到集合
                    如果返回true，说明元素重复，不存储
        */
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

HashSet集合存储元素：

​ 要保证元素的唯一性，需要重写 hashCode() 和 equals()

​ （重写hashCode()方法后，会出现元素内容不同，但是其哈希值相同的情况）

6、常见数据结构之哈希表

哈希表

​ JDK8之前，底层采用数组 + 链表实现，可以说是一个元素为链表的数组

​ JDK8后，在长度比较长的时候，底层实现了优化

元素的在数组中的存储位置根据其 哈希值 % 16 来确定，对于计算结果相同的数据先比较自身与前面存储元素的哈希值，如果不同直接存储（与前面存好的元素构成链表），如果相同就比较内容，内容相同即不存，内容不同即存。

7、案例：HashSet集合存储学生对象并遍历：

package com.itheima_04;
/*
    定义一个简单学生类
 */
public class Student {
    private String name;
    private int age;
 
    public Student(){}
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    //重写了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;
    }
}

package com.itheima_04;
/*
    定义一个HashSet集合存储学生对象并遍历
 */
import java.util.HashSet;
import java.util.Iterator;
 
public class HashSetDemo {
    public static void main(String[] args){
        //创建HashSet对象
        HashSet<Student> hashSet = new HashSet<Student>();
 
        //创建学生对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
        Student s4 = new Student("王五", 20);
 
        //添加元素
        hashSet.add(s1);
        hashSet.add(s2);
        hashSet.add(s3);
        hashSet.add(s4);
 
        //增强for循环遍历
        for(Student stu : hashSet){
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

8、LinkedHashSet集合概述和特点：

LinkedHashSet集合特点：

​ 哈希表和链表实现的Set接口，具有可预测的迭代次序

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

​ 有哈希表保证元素唯一，也就是说没有重复的元素

LinkedHashSet集合练习：

存储字符串并遍历

参考代码：

package com.itheima_05;
/*
LinkedHashSet集合特点：
 
	哈希表和链表实现的Set接口，具有可预测的迭代次序
 
	由链表保证元素有序也就是说元素的存储和取出顺序是一致的（！！注意区分这并不等于排好了序）
 
	有哈希表保证元素唯一，也就是说没有重复的元素
 */
//导包
import java.util.LinkedHashSet;
 
public class LinkedHashSetDemo {
    public static void main(String[] args){
        //创建对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
 
        //添加元素
        linkedHashSet.add("Set");
        linkedHashSet.add("HashSet");
        linkedHashSet.add("LinkedHashSet");
        linkedHashSet.add("HashSet");
 
 
        //遍历元素
        for(String s : linkedHashSet){
            System.out.println(s);
        }
    }
}

9、TreeSet集合概述和特点：

TreeSet排序元素规则：

​ 使用无参构造方法：其添加元素需要实现 Comparable<>接口，并重写了其中 compareTo() 方法才可以使用

​ 使用有参构造方法：传入的参数就相当于排序规则，以下采用匿名内部类的形式，这个匿名内部类实现的Comparator比较器接口并重写了其中的 compare() 方法

TreeSet集合特点：

​ 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定规则进行排序，具体排序方式取决于构造方法

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

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

​ 间接实现了Set接口，没有带索引的方法，索引不能使用普通for循环遍历

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

TreeSet集合练习：

​ 存储整数并遍历

参考代码：

package com.itheima_06;
/*
TreeSet集合特点：
 
	元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定规则进行排序，具体排序方式取决于构造方法
 
			TreeSet()：	根据其元素的自然排序进行排序
 
			TreeSet(Comparator comparator)：	根据指定的比较器进行排序
 
	间接实现了Set接口，没有带索引的方法，索引不能使用普通for循环遍历
 
	由于是Set集合，所以不包含重复元素的集合
 */
//导包
import java.util.TreeSet;
 
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        //<>中只能存储引用类型 所以要使用基本类型对应的封装类
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
 
        //无序添加Integer元素  JDK5之后可以自动装箱 手动需要使用方法valueOf()方法来实现
        treeSet.add(10);
        treeSet.add(40);
        treeSet.add(30);
        treeSet.add(50);
        treeSet.add(Integer.valueOf(20));   //手动装箱
        treeSet.add(Integer.valueOf(30));   //不包含重复元素
 
        //遍历集合
        for(Integer i : treeSet){
            //从输出可以看出 通过无参构造方法进行了自然排序 如：0, 1, 2...
            System.out.println(i);
        }
    }
}

10、自然排序Comparable的使用：

自然排序：即使用TreeSet集合中的无参构造方法，对于需要添加到集合中的类元素需要实现Comparable接口（那么同时也需要重写compareTo()方法），然后就能够根据我们重写的规则进行排序

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

要求：

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

结论：

​ 用TreeSet集合存储自定义对象，无参构造方法使用的时自然排序对于元素进行排序的

​ 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(To)方法

​ 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

参考代码：

package com.itheima_07;
 
public class Student implements Comparable<Student>{	//此类实现了Comparable<>接口
    private String name;
    private int age;
 
    public Student(){}
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    @Override
    public int compareTo(Student s){
//        return 0; //返回值为0 表示这些元素都是重复的（只有一个元素）
//        return 1; //返回值为1 表示后一个元素比前一个元素大（排序正序）
//        return -1; //返回值为-1 表示后一个元素比前一个元素小（排序逆序）
 
        //按照年龄从小到大进行排序
        int num = this.age - s.age;
//        int num = s.age - this.age;
 
        //年龄相同，按照姓名的字母顺序排序(String类实现了comparable<>接口中 重写了 compareTo方法)
        int result = num == 0 ? this.name.compareTo(s.name) : num;
        return result;
    }
}

package com.itheima_07;
/*
存储学生对象并遍历，创建TreeSet集合使用无参构造方法
 
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
 */
//导包
import java.util.TreeSet;
 
public class TreeSetDemo {
    public static void main(String[] args){
        //创建集合对象
        TreeSet<Student> treeSet = new TreeSet<Student>();
 
        //创建学生对象
        Student s1 = new Student("zhangsan", 19);
        Student s2 = new Student("lisi", 20);
        Student s3 = new Student("wangwu", 21);
        Student s4 = new Student("zhaoliu", 22);
 
        //测试年龄相同情况下
        Student s5 = new Student("kuangtu", 22);
        //测试相同元素
        Student s6 = new Student("kuangtu", 22);
 
        //添加元素
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
 
        //遍历集合
        for(Student stu : treeSet){
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

11、比较器排序Comparator的使用：

比较器排序：即使用TreeSet集合的有参构造方法，Comparator<>接口做参数，需要传入一个它的实现类，形式可以是匿名内部类，在其中重写compareTo()方法

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

要求：

​ 按照年龄从小到大进行排序，年龄相同，按照姓名的字母顺序排序

结论：

​ 用TreeSet集合存储自定义对象，带参构造方法使用的时比较排序对元素进行排序的

​ 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(To1, To2)方法，在这个作用域this指向的是这个匿名内部类

​ 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

参考代码：

package com.itheima_08;
 
public class Student {
    private String name;
    private int age;
 
    public Student(){}
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}

package com.itheima_08;
/*
储存学生对象并遍历，创建TreeSet集合使用<strong>带参构造方法</strong>
 
要求：
 
	按照年龄从小到大进行排序，年龄相同，按照姓名的字母顺序排序
 */
//导包
import java.util.Comparator;
import java.util.TreeSet;
 
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象    此处相当于传递了一个 Comparator<>接口的实现类
        TreeSet<Student> treeSet = new TreeSet<Student>(new Comparator<Student>(){
            @Override
            public int compare(Student s1, Student s2){ //使用了匿名内部类 此处this指向这个内部类
                //使用自然排序时 this.age - s.age 此处变为s1 s2
                int num = s1.getAge() - s2.getAge();
                int result = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return result;
            }
        });
 
        //创建学生对象
        Student s1 = new Student("zhangsan", 19);
        Student s2 = new Student("lisi", 20);
        Student s3 = new Student("wangwu", 21);
        Student s4 = new Student("zhaoliu", 22);
 
        //测试年龄相同情况下
        Student s5 = new Student("kuangtu", 22);
        //测试相同元素
        Student s6 = new Student("kuangtu", 22);
 
        //添加元素
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
 
        //遍历集合
        for(Student stu : treeSet){
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

12、案例成绩排序(要求使用TreeSet有参构造方法来实现)：

package com.itheima_09;
/*
    定义一个简单学生类
        里面包含学生姓名、语文成绩、数学成绩
 */
public class Student {
    private String name;
    private double chScore;
    private double mathScore;
 
    public Student(){}
 
    public Student(String name, double chScore, double mathScore){
        this.name = name;
        this.chScore = chScore;
        this.mathScore = mathScore;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getChScore() {
        return chScore;
    }
 
    public void setChScore(double chScore) {
        this.chScore = chScore;
    }
 
    public double getMathScore() {
        return mathScore;
    }
 
    public void setMathScore(double mathScore) {
        this.mathScore = mathScore;
    }
}

package com.itheima_09;
/*
    使用TreeSet的 有参构造 来进行学生成绩的排序
    需求：
        按照总分从高到低出现
 */
//导包
import java.util.TreeSet;
import java.util.Comparator;
 
public class TreeSetDemo {
    public static void main(String[] args){
        //创建集合对象
        TreeSet<Student> treeSet = new TreeSet<Student>(new Comparator<Student>(){
            @Override
            public int compare(Student s1, Student s2){
                int sum = (int)((s2.getChScore() + s2.getMathScore()) - (s1.getChScore() + s1.getMathScore()));
                //在成绩相同的情况下判断 姓名字母的自然排序
                int result = sum == 0 ? s1.getName().compareTo(s2.getName()) : sum;
                return result;
            }
        });
 
        //创建学生对象
        Student s1 = new Student("zhangsan", 78, 79);
        Student s2 = new Student("lisi", 91, 99);
        Student s3 = new Student("wangwu", 68, 77);
        Student s4 = new Student("zhaoliu", 88, 78);
 
        //测试重复数据
        Student s5 = new Student("zhaoliu", 88, 78);
        //测试成绩相同时的数据
        Student s6 = new Student("kuangtu", 91, 99);
 
        //添加学生对象
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
 
        //遍历学生对象
        for(Student stu : treeSet){
            double sum = stu.getChScore() + stu.getMathScore();
            System.out.println(
                    "姓名：" + stu.getName() + " " +
                    "语文成绩：" + stu.getChScore() + " " +
                    "数学成绩：" + stu.getMathScore() + " " +
                    "总分：" +  sum
            );
        }
    }
}

13、案例：不重复随机数

需求：编写一个程序，获取10个1~20之间的随机数，要求随机数不能重复，并在控制台输出

package com.itheima_10;
/*
    思路：
        1、创建Set集合对象
        2、创建随机数对象
        3、判断集合的长度是不是小于十
               是，产生一个随机数，添加到元素
               继续判断...
        4、遍历集合
 */
//导包
import java.util.Set;
import java.util.HashSet;
import java.util.Random;
import java.util.LinkedHashSet;
import java.util.TreeSet;
 
public class SetDemo {
    public static void main(String[] args){
        //创建Set集合对象 注意此处的元素对象是int的包装类 Integer
//        Set<Integer> set = new HashSet<Integer>();   //添加与输出顺序不一致 无序
//        Set<Integer> set = new LinkedHashSet<Integer>();  //可以根据结果查看有效插入的顺序
        //无参构造 会进行自然排序(我们需要知道 Integer能这样用 就实现了Comparable<> 并重写了compareTo()方法)
        Set<Integer> set = new TreeSet<Integer>();
 
        //创建随机数对象
        Random r = new Random();
 
        //判断集合对象的长度是否小于十
        while(set.size() < 10){
            int number = r.nextInt(20) + 1;    //1 ~ 20之间 闭区间
            set.add(number);   //自动装箱
        }
 
        //遍历集合
        for(Integer i : set){
            System.out.println(i);
        }
    }
}

四、泛型

1、泛型概述：

​ 是JDK5中引入的特性，他提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

​ 一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型如何理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

简单来讲：就是将变量的数据类型 参数化 然后再根据 传入的数据类型 用来表示这个参数表示的数据类型（参考C++模板：函数模板和类模板）

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

2、泛型定义格式：

<类型>：指定一种类型的格式。这里可以看成时形参
<类型1, 类型2...>：指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成是形参

将来具体调用时侯给定的类型可以看成是实参，并且实参的类型只能是引用数据类型（Java）

3、泛型的好处：

​ 把运行时异常 提前到了 编译时异常（即添加的元素类型不一致）

​ 避免了强制类型转换（提前就确定好了元素类型）

package com.itheima_01;
/*
    需求：Collection集合存储字符串并遍历
    得出泛型使用的好处：
            把运行时异常 提前到了 编译时异常（即添加的元素类型不一致）
            避免了强制类型转换（提前就确定好了元素类型）
 */
//导包
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class GenericDemo {
    public static void main(String[] args){
        //创建Collection集合对象  当我们没有传入类型时 默认为 Object类 类型
        //超类 被所有类直接或者间接继承可以用于表示所有引用类型
//        Collection c = new ArrayList();
        Collection<String> c = new ArrayList<String>();
 
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        //在没有使用泛型时，添加类型都被视为Object类型 所以数据都能够存入
        //但是如果我们又在 遍历时将Object进行了向下转型，那么程序就会隐含数据类型转换异常
//        c.add(100);   添加了<>的使用后 就无法进行指明类型以外的添加
 
 
        //遍历集合
//        Iterator it = c.iterator();
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
//            Object o = it.next();
//            System.out.println(o);
 
            //向下转型 将父类对象 转换为 子类引用
//            String s = (String)it.next();   //ClassCastException
            String s = it.next();
            System.out.println(s);
        }
    }
}
 

4、泛型类：

泛型类的定义格式

格式：修饰符 class 类名<类型>{}
示例：public class Generic<T>{}	//此处T可以是任意的合法标识符，常见的如T、E、K、V等形式的参数常用于表示泛型

参考代码：

package com.itheima_02;
/*
    测试类
 */
public class GenericDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        System.out.println(s.getName());
 
        Teacher t = new Teacher();
        t.setAge(30);
        //只能够接收 规定好的类型
//        t.setAge("30");
        System.out.println(t.getAge());
 
        System.out.println("--------");
 
        //使用泛型类后 我们只用了一个类 就可以根据传入的类型来实现不同类型的传递
        Generic<String> g = new Generic<String>();
        g.setT("李四");
        System.out.println(g.getT());
 
        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(10);
        System.out.println(g2.getT());
 
        Generic<Boolean> g3 = new Generic<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

5、泛型方法：

泛型方法定义格式：

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

参考代码：

package com.itheima_03;
/*
用于查看普通类、泛型类、泛型方法的区别
 */
 
//普通类
/*public class Generic(){
    public void show(String s){
        System.out.println(s);
    }
 
    public void show(Integer i){
 
    }
 
    public void show(Character c){
        System.out.println(c);
    }
 
    public void show(Boolean b){
        System.out.println(b);
    }
}*/
 
/*//泛型类
public class Generic<T> {
    public void show(T t){
        System.out.println(t);
    }
}*/
 
//泛型方法
public class Generic{
    public <T> void show(T t){
        System.out.println(t);
    }
}

package com.itheima_03;
/*
    测试类：用于测试泛型方法
 */
public class GenericDemo {
    public static void main(String[] args){
        //普通类问题：需要在类中重载多次方法
        /*Generic g = new Generic();
        g.show("张三");
        g.show(66);
        g.show('A');
        g.show(true);*/
 
        //为了避免 运行时类型转换错误 使用泛型前先表明类型是个好习惯
 
        //泛型类问题：需要每次实例化对象时都指明泛型类
        /*Generic<String> g1 = new Generic<String>();
        g1.show("李四");
 
        Generic<Integer> g2 = new Generic<Integer>();
        g2.show(66);
 
        Generic<Character> g3 = new Generic<Character>();
        g3.show('A');
 
        Generic<Double> g4 = new Generic<Double>();
        g4.show(13.14);
 
        Generic<Boolean> g5 = new Generic<Boolean>();
        g5.show(true);*/
 
        Generic g = new Generic();
        g.show("王五");
        g.show('B');
        g.show(88);
        g.show(true);
        g.show(13.14);
        g.show(13.148F);
        g.show(12222222222L);
    }
}

6、泛型接口：

泛型接口的定义格式：

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

参考代码：

package com.itheima_04;
/*
    定义一个泛型类
 */
public interface Generic <T>{
    void show(T t);
}

package com.itheima_04;
/*
定义一个泛型类来实现泛型接口
 */
public class GenericImpl<T> implements Generic<T>{
    @Override
    public void show(T t){
        System.out.println(t);
    }
}

package com.itheima_04;
/*
    测试类
 */
public class GenericDemo {
    public static void main(String[] args){
        //使用多态的形式 实现泛型接口实例化对象
        Generic<String> generic = new GenericImpl<String>();
        generic.show("张三");
        generic.show("李四");
        generic.show("王五");
        generic.show("赵六");
 
        Generic<Integer> generic2 = new GenericImpl<Integer>();
        generic2.show(10);
        generic2.show(20);
        generic2.show(30);
 
        Generic<Character> generic3 = new GenericImpl<Character>();
        generic3.show('a');
        generic3.show('b');
        generic3.show('c');
    }
}

7、类型通配符：

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

​ 类型通配符：<?>

​ List<?>：表示元素类型未知的list，它的元素可以匹配任何的类型

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

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

​ 类型通配符上限：<? extends 类型>

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

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

​ 类型通配符下限：<? super 类型>

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

参考代码：

package com.itheima_05;
/*
    为了表示各种泛型List的父类，可以使用类型通配符
	类型通配符：<?>
	List<?>：表示元素类型未知的list，它的元素可以匹配任何的类型
	这种带通配符List仅表示它是各种泛型List的父类，并不能把元素添加到其中
 
如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
	类型通配符上限：<? extends 类型>
	List<? extends Number>：它表示的类型是Number或者其子类型
 
除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
	类型通配符下限：<? super 类型>
	List<? super Number>：它表示的类型是Number或者其父类型
 */
//导包
import java.util.List;
import java.util.ArrayList;
 
public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符     可以匹配任何的数据类型
        List<?> list = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("--------");
 
        //类型通配符上限：<? extends 类型>    此时限定了上限是Number
//        List<? extends Number> list4 = new ArrayList<Object>(); //Object是Number的父类
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
//        List<? extends Number> list7 = new ArrayList<Character>(); //Character不在Number的子类体系中
        List<? extends Number> list8 = new ArrayList<Short>();
 
        //类型通配符下限：<? super 类型>
        List<? super Number> list9 = new ArrayList<Object>();
        List<? super Number> list10 = new ArrayList<Number>();
//        List<? super Number> list11 = new ArrayList<Integer>();    //Integer是Number的子类
 
    }
}

8、可变参数：

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

​ 格式：修饰符 返回值类型 方法名(数据类型...变量名){}

​ 范例：public static int sum(int...a){}

可变参数的注意事项

​ 这里的变量其实是一个数组

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

参考代码：

package com.itheima_06;
/*
    测试类：测试可变参数
 */
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));
 
    }
 
   /* //注意：
    public static int sum(int b, int...a){  //使用可变参数需要其它参数时要写在前面
        return 0;
    }*/
 
    public static int sum(int...a){ //此处的a可以是任意的合法标识符
//        System.out.println(a);    //从输出上来看是数组
//        return 0;
        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;
//    }
}

9、可变参数的使用：

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)	//返回一个包含任意数量元素的不可变集合

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

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

通过修饰符与返回值类型之间的泛型我们可以看出，这几个方法都是泛型方法。

参考代码：

package com.itheima_07;
/*
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 ArgsDemo01 {
    public static void main(String[] args){
/*
        //一、public static <T> List<T> asList(T...a)	//返回由指定数组支持的"固定大小"的列表
        List<String> list = Arrays.asList("hello", "world", "java");
 
//        list.add("javase");       //UnsupportedOperationException 抛出以表示不支持请求的异常
//        list.remove("world");     //UnsupportedOperationException
        list.set(1, "javase");      //可以运行：因为修改元素不会改变列表的大小
 
 
        System.out.println(list);
*/
 
       /* //二、public static <E> List<E> of(E...elements)	//返回包含任意数量元素的"不可变"列
        List<String> list = List.of("hello", "world", "java", "world");
//        list.add("javase");     //UnsupportedOperationException
//        list.remove("java");    //UnsupportedOperationException
//        list.set(1, "hello");   //UnsupportedOperationException
 
        System.out.println(list);*/
 
        //public static <E> Set<E> of(E...elements)	//返回一个包含任意数量元素的不可变集合
        //IllegalArgumentException 抛出表示一种方法已经通过了非法或不正确的参数
//        Set<String> set = Set.of("hello", "world", "java", "world");  //Set集合中不可以有重复元素
        Set<String> set = Set.of("hello", "world", "java");
//        set.add("javase");  //UnsupportedOperationException
//        set.remove("world");    //UnsupportedOperationException
 
        System.out.println(set);
    }
}

五、Map

1、Map集合概述：

Interface Map<K, V>	//K: 键的类型;	V: 值得类型

将建映射到值得对象；不能包含重复的键；每一个键可以映射到最多一个值，例如学生的学号和姓名

键是唯一的，值不是；但是它们之间是一一对应的

2、创建Map集合的对象

​ 多态的方式

​ 具体的实现类HashMap

参考代码：

package com.itheima_01;
/*
    测试Map集合创建对象
 */
//导包
import java.util.Map;
import java.util.HashMap;
 
public class MapDemo01 {
    public static void main(String[] args){
        //创建Map集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("001", "张三");
        map.put("002", "李四");
        map.put("003", "王五");
        map.put("003", "赵六");   //从输出结果来看，"003" 对应的原有映射被替换了
        //可见put第一次传入键值是添加 第二次传入键值是修改
 
        //输出集合对象
        //HashMap中重写了 toString方法，用等号将键值与映射相连接
        System.out.println(map);
    }
}

3、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()	集合的长度，也就是集合中键值对的个数

参考代码：

package com.itheima_01;
/*
 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.Map;
import java.util.HashMap;
 
public class MapDemo02 {
    public static void main(String[] args){
        //创建Map集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        //一、V put(K key, V value)                添加元素
        map.put("左", "右");
        map.put("上", "下");
        map.put("前", "后");
 
//        //二、V remove(Object key)                 根据键删除 键值对 元素
//        String s = map.remove("前");
//        System.out.println(s);  //返回被删除键值对应的值
//        System.out.println(map.remove("里"));    //没有对应的键值返回null
 
//        //三、void clear()                         移除所有的 键值对 元素
//        map.clear();      使用时要 提醒用户
 
//        //四、boolean containsKey(Object key)      判断集合是否包含指定的键值
//        System.out.println(map.containsKey("左"));
//        System.out.println(map.containsKey("里"));
 
//        //五、boolean containsValue(Object value)  判断集合是否包含指定的值
//        System.out.println(map.containsValue("下"));
//        System.out.println(map.containsValue("外"));
 
//        //六、boolean isEmpty()                    判断集合是否为空
//        System.out.println(map.isEmpty());
//        //清空后 调isEmpty()方法后返回值为true
//        map.clear();
//        System.out.println(map.isEmpty());
 
        //七、int size()                           集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());
 
 
        //输出集合对象
        System.out.println(map);
    }
}

4、Map集合的获取功能:

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有的键值
Collection values()	获取所有值的集合
Set<Map.Entry<K, V>> entrySet()	获取所有 键值对 对象

参考代码：

package com.itheima_01;
/*
 V get(Object key)       根据键获取值
 Set<K> keySet()         获取所有的键值
 Collection<V> values()  获取所有值的集合
 */
//导包
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.Collection;
 
public class MapDemo03 {
    public static void main(String[] args) {
        //创建对象
        Map<String, String> map = new HashMap<String, String>();
 
        //添加元素
        map.put("左", "右");
        map.put("上", "下");
        map.put("前", "后");
 
//        //一、V get(Object key)       根据键获取值
//        System.out.println(map.get("左"));
//        System.out.println(map.get("里"));   //键在集合中不存在（当键对应的值是null时也输出null）
 
//        //二、Set<K> keySet()         获取所有的键值(通过Set接口来储所有存唯一键值)
//        Set<String> keySet = map.keySet();
//        System.out.println(keySet);
//
//        //结合两个方法通过 加强for循环来遍历Map键值对应的值
//        for(String s : keySet){
//            System.out.println(map.get(s));
//        }
 
        //三、Collection<V> values()  获取所有的集合
        Collection<String> collection = map.values();
        for(String s : collection){
            System.out.println(s);
        }
    }
}

5、Map集合的遍历（方式1）:

​ 获取所有键的集合，使用前面的：keySet()方法实现

​ 遍历键的集合，获取到每一个键，使用增强for实现

​ 每次根据键值去找值，使用get(Object key)方法实现

参考代码：

package com.itheima_02;
/*
获取所有键的集合，使用前面的：keySet()方法实现
遍历键的集合，获取到每一个键，使用增强for实现
每次根据键值去找值，使用get(Object key)方法实现
 */
//导包
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
 
public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        //添加元素
        map.put("上", "下");
        map.put("左", "右");
        map.put("前", "后");
        map.put("里", "外");
 
        //遍历Map集合
        //获取所有键的集合
        Set<String> keySet = map.keySet();
        //遍历所有键
        for(String key : keySet){
            //根据键值获取每一个值
            String value = map.get(key);
            System.out.println(value);
        }
    }
}

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

​ 获取所有 键值对 对象的集合：

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

​ 遍历键值对对象的集合，得到每一个键值对对象：

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

​ 根据键值对对象获取键值和值

​ 用getKey()得到键

​ 用getValue()的到值

参考代码：

package com.itheima_02;
/*
获取所有 键值对 对象的集合：
 
	使用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<String, String>();
 
        //添加元素
        map.put("上", "下");
        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);
        }
    }
}

6、案例：HashMap集合存储学生对象并遍历:

需求：键是学号（String），值是学生对象

package com.itheima_03;
/*
    创建一个学生对象
 */
public class Student {
    private String name;
    private int age;
 
    public Student(){}
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    public void show(){
        System.out.println(this.getName() + "," + this.getAge());
    }
 
    @Override
    public String toString(){
        return "Student{" +
                "name=" + "'" + this.name + '\'' +
                "age=" + "'" + this.age + '\'' +
                "}";
    }
}

package com.itheima_03;
/*
    使用HashMap集合，键是学号（String）, 值是学生对象（Student）, 存储三个数据并遍历
 */
//导包
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
 
public class HashMapDemo {
    public static void main(String[] args){
        //创建集合对象
        HashMap<String, Student> hashMap = new HashMap<String, Student>();
 
        //创建学生对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
 
        //添加集合元素
        hashMap.put("001", s1);
        hashMap.put("002", s2);
        hashMap.put("003", s3);
 
        //遍历集合(方式一)
        //1、获取keySet(键值集合)
        Set<String> keySet = hashMap.keySet();
        //2、使用加强for循环获取 每一个键值
        for(String key : keySet){
            Student value = hashMap.get(key);
            System.out.println("学号：" + key + " 姓名：" + value.getName() + " 年龄：" + value.getAge());
        }
 
        System.out.println("--------");
 
        //遍历集合(方式二)
        //1、获取键值对对象集合
        Set<Map.Entry<String, Student>> entrySet = hashMap.entrySet();
        //2、使用加强for循环获取 每一个键值对对象
        for(Map.Entry<String, Student> entry : entrySet){
            String key = entry.getKey();
            Student value = entry.getValue();
            System.out.println("学号：" + key + " 姓名：" + value.getName() + " 年龄：" + value.getAge());
        }
    }
}

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

需求：键是学生对象（自定义类型，如何保证其唯一性），值是学生居住地址（String）

package com.itheima_04;
/*
    创建一个学生对象
 */
public class Student {
    private String name;
    private int age;
 
    public Student(){
 
    }
 
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public int getAge() {
        return age;
    }
 
    //关键在于，使用自定义类型做key 在HashMap中为了确保其唯一性需要重写 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;
    }
}

package com.itheima_04;
/*
    定义一个测试类测试
 */
//导包
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class HashMapDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashMap<Student, String> hashMap = new HashMap<Student,String>();
 
        //创建学生对象
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 20);
 
        //添加集合元素
        hashMap.put(s1, "重庆");
        hashMap.put(s2, "北京");
        hashMap.put(s3, "上海");
 
        //遍历集合(方式一)
        //1、获取keySet(键值集合)
        Set<Student> keySet = hashMap.keySet();
        //2、使用加强for循环获取 每一个键值
        for(Student key : keySet){
            String value = hashMap.get(key);
            System.out.println("姓名：" + key.getName() + " 年龄：" + key.getAge() + " 住址：" + value);
        }
 
        System.out.println("--------");
 
        //遍历集合(方式二)
        //1、获取键值对对象集合
        Set<Map.Entry<Student, String>> entrySet = hashMap.entrySet();
        //2、使用加强for循环获取 每一个键值对对象
        for(Map.Entry<Student, String> entry : entrySet){
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println("姓名：" + key.getName() + " 年龄：" + key.getAge() + " 住址：" + value);
        }
    }
}

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

package com.itheima_05;
/*
    需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap,每一个HashMap的键和值都是String，并遍历
 */
//导包
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class HashMapDemo {
    public static void main(String[] args){
        //创建一个ArrayList集合对象
        ArrayList<HashMap<String, String>> arrayList = new ArrayList<HashMap<String, String>>();
 
        //创建HashMap对象
        HashMap<String, String> hashMap1 = new HashMap<String, String>();
        HashMap<String, String> hashMap2 = new HashMap<String, String>();
        HashMap<String, String> hashMap3 = new HashMap<String, String>();
 
        //添加hashMap1元素
        hashMap1.put("a100", "张三");
        hashMap1.put("a101", "李四");
        hashMap1.put("a102", "王五");
 
        //添加hashMap2元素
        hashMap2.put("b100", "小明");
        hashMap2.put("b101", "小红");
        hashMap2.put("b102", "小白");
 
        //添加hashMap3元素
        hashMap3.put("c100", "天天");
        hashMap3.put("c101", "友友");
        hashMap3.put("c102", "蹦蹦");
 
        //添加ArrayList对象
        arrayList.add(hashMap1);
        arrayList.add(hashMap2);
        arrayList.add(hashMap3);
 
        //遍历ArrayList集合
        for(int i = 0; i < arrayList.size(); i++){  //使用简单for循环进行遍历（ArrayList实现类List接口可以使用下标索引的方法）
            HashMap<String, String> temp = arrayList.get(i);//通过一个间接变量来接收Array集合中的值
//            //遍历ArrayList中HashMap元素（方式一）
//            for(String key : temp.keySet()){    //通过HashMap对象中的keySet方法来获取其键值集合
//                String value = temp.get(key);
//                if(i == 0){
//                    System.out.println("a校区 - " + "学号：" + key + " 姓名：" + value);
//                }
//                else if(i == 1){
//                    System.out.println("b校区 - " + "学号：" + key + " 姓名：" + value);
//                }
//                else if(i == 2){
//                    System.out.println("c校区 - " + "学号：" + key + " 姓名：" + value);
//                }
//            }
 
            //遍历ArrayList中HashMap元素（方式二）
            Set<Map.Entry<String, String>> set = temp.entrySet();
            for(Map.Entry<String, String> entry : set){
                String key = entry.getKey();
                String value = entry.getValue();
                if(i == 0){
                    System.out.println("a校区 - " + "学号：" + key + " 姓名：" + value);
                }
                else if(i == 1){
                    System.out.println("b校区 - " + "学号：" + key + " 姓名：" + value);
                }
                else if(i == 2){
                    System.out.println("c校区 - " + "学号：" + key + " 姓名：" + value);
                }
            }
        }
    }
}

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

package com.itheima_06;
/*
    需求：创建一个HashMap集合，存储三个元素，每一个键值对元素的键是String，
    值是ArrayList,每一个ArrayList的元素是String，并遍历
 */
//导包
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class HashMapDemo {
    public static void main(String[] args){
        //创建HashMap集合对象
        HashMap<String, ArrayList<String>> hashMap = new HashMap<String, ArrayList<String>>();
 
        //创建ArrayList集合对象 并添加元素
        ArrayList<String> arrayList1 = new ArrayList<String>();
        arrayList1.add("a");
        arrayList1.add("b");
        arrayList1.add("c");
        //System.out.println(arrayList1);
 
        ArrayList<String> arrayList2 = new ArrayList<String>();
        arrayList2.add("d");
        arrayList2.add("e");
        arrayList2.add("f");
 
        ArrayList<String> arrayList3 = new ArrayList<String>();
        arrayList3.add("g");
        arrayList3.add("h");
        arrayList3.add("i");
 
        //添加HashMap集合对象
        hashMap.put("前三个", arrayList1);
        hashMap.put("中三个", arrayList2);
        hashMap.put("后三个", arrayList3);
 
//        //遍历HashMap集合（方式一）
//        for(String key : hashMap.keySet()){ //依次从keySet集合中获取对应的键值
//            ArrayList<String> value = hashMap.get(key); //更具键值获取对应 值
//
//            System.out.print(key + "：");
//            for(int i = 0; i < value.size(); i++){  //遍历HashMap中的ArrayList值
//                System.out.print(value.get(i));
//            }
//            System.out.println();
//        }
 
        //遍历HashMap集合（方式二）
        //获取键值对集合对象
        Set<Map.Entry<String, ArrayList<String>>> entrySet = hashMap.entrySet();
        //依次获取键值对对象
        for(Map.Entry<String, ArrayList<String>> entry: entrySet){
            //获取键值对的键值和值
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
 
            System.out.print(key + "：");
            //遍历值
            for(int i = 0; i < value.size(); i++){
                System.out.print(value.get(i));
            }
            System.out.println();
        }
    }
}

10、案例：统计字符串每个字符出现的次数：

可以尝试使用TreeMap的无参构造方法来实现可以进行键值自然排序

package com.itheima_07;
/*
    需求:
        键盘录入一个字符串，要求统计字符串出现的次数
        举例：键盘录入"aababcabcdabcde" 在控制台输出："a(5)b(4)c(3)d(2)e(1)"
    思路：
        1、键盘录入一个字符串
        2、创建HashMap集合，键是Character，值是Integer
        3、遍历字符串，得到每一个字符
        4、拿到的每一个字符作为键 到HashMap集合中去找对应的值，看其返回值
            如果返回值是null，说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
            如果返回值不是null，说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应值
        5、遍历HashMap集合，得到键和值，按要求进行拼接
        6、输出结果
 */
//导包
import java.util.Scanner;
import java.util.HashMap;
import java.util.Set;
 
public class HashMapDemo {
    public static void main(String[] args){
        //创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();
 
        //创建HashMap集合
        HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();
 
        //遍历字符串并获取对应字符
        for(int i = 0; i < str.length(); i++){
            Character c = str.charAt(i);    //拿到对应的字符作为键值进行值的查询(自动装箱)
            if(hashMap.get(c) == null){ //如果结果为：null 说明集合对象中无字符为键值 value=1
                hashMap.put(c, 1);
            }
            else if(hashMap.get(c) != null){ //结果不为：null 说明集合对象中存在当前字符 value++
                Integer value = hashMap.get(c);
                value++;
                hashMap.put(c, value);  //存在此元素 put()表示修改
            }
        }
 
        //遍历HashMap集合 （按照题目要求输出）
        Set<Character> keySet = hashMap.keySet();
        for(Character key : keySet){
            Integer value = hashMap.get(key);
            System.out.print(key + "(" + value + ")");	//也可以使用StringBulider类来拼接
        }
        System.out.println();
    }
}

六、Collections

1、Collections概述和使用：

Collections类的概述：

​ 是针对集合操作的工具类

Collections类的常用方法

public static <T extends Comparable<? super T>> void sort(List<T> list);	//将指定的列表按升序排序
public static void reverse(List<?> list);		//反转指定列表中元素的顺序
public static void shuffle(List<?> list);		//使用的默认的随机源随机排列指定的列表

参考代码：

package com.itheima_01;
/*
Collections类的概述：
	是针对集合操作的工具类
 
Collections类的常用方法
    public static <T extends Comparable<? super T>> void sort(List<T> list);	//将指定的列表按升序排序
    public static void reverse(List<?> list);		//反转指定列表中元素的顺序
    public static void shuffle(List<?> list);		//使用的默认的随机源随机排列指定的列表
 */
//导包
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
 
public class CollectionsDemo {
    public static void main(String[] args){
        //创建集合对象
        List<Integer> list = new ArrayList<Integer>();
 
        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
 
        //public static <T extends Comparable<? super T>> void sort(List<T> list);	//将指定的列表按升序排序
//        Collections.sort(list);
 
        //public static void reverse(List<?> list);		//反转指定列表中元素的顺序
//        Collections.reverse(list);
 
        //public static void shuffle(List<?> list);		//使用的默认的随机源随机排列指定的列表
        Collections.shuffle(list);  //常用于洗牌
 
        System.out.println(list);
    }
}

2、案例：ArrayList存储学生对象并遍历：

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

package com.itheima_02;
/*
    定义一个简单的学生类
 */
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 void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
//    @Override
//    public int compareTo(Student student){
//        int num = this.age - student.age;
//        int result = num == 0 ? this.name.compareTo(student.name) : num;
//        return result;
//    }
}

package com.itheima_02;
/*
    需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序，
    要求按年龄从大到小排序，年龄相同时按照姓名的字母顺序进行排序
 */
//导包
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
 
public class ArrayListDemo {
    public static void main(String[] args){
        //创建Arraylist集合对象
        ArrayList<Student> arrayList = new ArrayList<Student>();
 
        //创建学生对象
        Student s1 = new Student("zhangsan", 18);
        Student s2 = new Student("lisi", 19);
        Student s3 = new Student("wangwu", 18);
        Student s4 = new Student("zhaoliu", 20);
 
        //添加学生对象到集合中
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
 
        //使用Collections集合工具类对ArrayList集合进行排序
//        Collections.sort(arrayList);  //底层使用自然排序实现，自定义类型要重写方法
//        for(int i = 0; i < arrayList.size(); i++){
//            System.out.println(arrayList.get(i).getName() + "," + arrayList.get(i).getAge());
//        }
 
        //使用新方法，参数含比较器
        //sort(List<T> list, Comparator<? super T> c)
        Collections.sort(arrayList, new Comparator<Student>(){
            @Override
            public int compare(Student s1, Student s2){
                int num = s1.getAge() - s2.getAge();
                int result = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return result;
            }
        });
 
        //遍历
        for(int i = 0; i < arrayList.size(); i++){
            System.out.println(arrayList.get(i).getName() + "," + arrayList.get(i).getAge());
        }
    }
}

3、案例：模拟斗地主：

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌

思路：

​ 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现

​ 往牌盒里面装牌

​ 洗牌，也就是把牌打散，用Collections的shuffle()方法实现

​ 发牌，也就是遍历集合，给三个玩家发牌

​ 看牌，也就是三个玩家分别遍历自己的牌

package com.itheima_03;
/*
创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
 
往牌盒里面装牌
 
洗牌，也就是把牌打散，用Collections的shuffle()方法实现
 
发牌，也就是遍历集合，给三个玩家发牌
 
看牌，也就是三个玩家分别遍历自己的牌
 */
//导包
import java.util.ArrayList;
import java.util.Collections;
 
public class PokerDemo {
    public static void main(String[] args) {
        //创建一个牌盒
        ArrayList<String> array = new ArrayList<String>();
 
        //创建花色数组    此处花色用中文表示
        String[] colors = {"方块", "梅花", "红桃", "黑桃"};
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        //往牌盒里面装牌
        for(String color : colors){
            for(String number : numbers){
                array.add(color + number);
            }
        }
        array.add("小王");
        array.add("大王");
 
        //洗牌，也就是把牌打散，用Collections的shuffle()方法实现
        Collections.shuffle(array);
 
        System.out.println("查看牌序：" + array);
 
        //发牌
        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> bottom = new ArrayList<String>();
 
        /*for(int i = 0; i < array.size() - 5; i+=3){//可见下标 % 3 == 0
            player1.add(array.get(i));
        }
        for(int i = 1; i < array.size() - 4; i+=3){//可见下标 % 3 == 1
            player2.add(array.get(i));
        }
        for(int i = 2; i < array.size() - 3; i+=3){// 可见下标 % 3 == 2
            player3.add(array.get(i));
        }
 
        for(int i = 0; i < 3; i++){
            Collections.reverse(array);
            bottom.add(array.get(i));
        }*/
 
        //优化后
        for(int i = 0; i < array.size(); i++){
            String s = array.get(i);
            if(i >= array.size() - 3){
                bottom.add(s);
            }
            else if(i % 3 == 0){
                player1.add(s);
            }
            else if(i % 3 == 1){
                player2.add(s);
            }
            else if(i % 3 == 2){
                player3.add(s);
            }
        }
 
 
        //看牌
        System.out.println("玩家一：" + player1);
        System.out.println("玩家二：" + player2);
        System.out.println("玩家三：" + player3);
        System.out.println("底牌：" + bottom);
    }
}

4、案例：模拟斗地主升级版：

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序

package com.itheima_03;
/*
    需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序
 */
//导包
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Set;
import java.util.Collections;
import java.util.TreeSet;
 
public class PokerDemo02 {
    public static void main(String[] args){
        //创建HashMap集合对象
        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();
        ArrayList<Integer> keyList = new ArrayList<Integer>();
 
        //将牌存入牌盒
        String[] colors = {"方块", "梅花", "红桃", "黑桃"};
        String[] numbers  = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
 
        int index = 0;
        for(String number : numbers){   //使用点数去匹配花色，使得相同点数的下标索引相近
            for(String color : colors){
                hashMap.put(index, color + number);
                index++;
            }
        }
 
        hashMap.put(index++, "大王");
        hashMap.put(index++, "小王");
 
 
        //使用ArrayList集合存储键值进行洗牌
        //获取键值集合
        Set<Integer> keySet = hashMap.keySet();
        for(Integer key : keySet){
            keyList.add(key);
        }
 
        //洗牌
        Collections.shuffle(keyList);
 
        //发牌并齐牌
        TreeSet<Integer> player1 = new TreeSet<Integer>();
        TreeSet<Integer> player2 = new TreeSet<Integer>();
        TreeSet<Integer> player3 = new TreeSet<Integer>();
        TreeSet<Integer> bottom = new TreeSet<Integer>();
 
        for(int i = 0; i < keyList.size(); i++){    //遍历集合
            if(i >= keyList.size()-3){
                bottom.add(keyList.get(i));
            }
            else if(i % 3 == 0){
                player1.add(keyList.get(i));
            }
            else if(i % 3 == 1){
                player2.add(keyList.get(i));
            }
            else if(i % 3 == 2){
                player3.add(keyList.get(i));
            }
        }
 
        //看牌
        System.out.print("玩家一：");
        lookPoker(player1, hashMap);
        System.out.print("玩家二：");
        lookPoker(player2, hashMap);
        System.out.print("玩家三：");
        lookPoker(player3, hashMap);
        System.out.print("底牌：");
        lookPoker(bottom, hashMap);
 
    }
 
    //定义一个通过键值看牌的方法
    public static void lookPoker(TreeSet<Integer> t, HashMap<Integer, String> hashMap){
        int flag = 0;
        System.out.print("[");
        for(Integer i : t){
            flag++;
            if(flag != t.size()){
                System.out.print(hashMap.get(i) + ",");
            }
            else if (flag == t.size()){
                System.out.print(hashMap.get(i));
            }
        }
        System.out.println("]");
    }
}