重生之我是Java小白六

Y 开心599

已于 2024-03-14 22:54:03 修改

阅读量1k

点赞数 35

文章标签： java 开发语言

于 2024-03-14 22:49:22 首次发布

本文链接：https://blog.csdn.net/weixin_65909965/article/details/136633920

版权

一集合

1.1集合的概述

1.面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

2.数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。(集合与数组的区别)

3.集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

3.java中的集合只能存储引用数据类型

4.以后学习集合

1、创建集合对象
2、创建元素对象
3、向集合中添加元素
4、遍历集合

1.2集合的种类

二Collection接口

2.1概述

1.Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的

2.2Collection接口成员方法

看list接口，他是个接口需要借助创建ArrayList对象，来使用学习Collection接口中的方法

看3.3.2

2.3Collection案例

2.3.1.存储自定义对象并遍历 Student(name,age)

1.先转数组遍历

package com.shujia.day12;

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

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

        //创建元素对象
        Student s1 = new Student("张三", 12);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 12);
        Student s4 = new Student("赵六", 13);

        //向集合里面添加元素
        c1.add(s1);
        c1.add(s2);
        c1.add(s3);
        c1.add(s4);

        //遍历集合
        //先转数组遍历
        Object[] array = c1.toArray();
        for (int i=0;i<array.length;i++){
            Student student=(Student) array[i];
            System.out.println(student.getAge()+student.getName());
        }
    }
}
/*
12张三
14李四
12王五
13赵六
 */

2.迭代器遍历

package com.shujia.day12;

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

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

        //创建元素对象
        Student s1 = new Student("张三", 12);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 12);
        Student s4 = new Student("赵六", 13);

        //向集合里面添加元素
        c1.add(s1);
        c1.add(s2);
        c1.add(s3);
        c1.add(s4);

        //遍历集合
        //先转数组遍历
//        Object[] array = c1.toArray();
//        for (int i=0;i<array.length;i++){
//            Student student=(Student) array[i];
//            System.out.println(student.getAge()+student.getName());
//        }
        
        //使用迭代器遍历
        //创建迭代器对象
        Iterator iterator = c1.iterator();
        while (iterator.hasNext()){
            Student student=(Student) iterator.next();
            System.out.println(student.getAge()+student.getName());
        }

    }
}
/*
12张三
14李四
12王五
13赵六
 */

三 list接口

3.1list接口的概述

1.元素有序（存储和取出的顺序一致），且允许重复，并且还有索引

3.2list的成员方法

3.2.1void add(int index,Object element) 指定索引位置添加元素

3.2.2 E remove(int index) 指定位置删除，返回被删除的元素

3.2.3 Object get(int index) 指定索引获取索引位置上的元素

1.获取元素，集合本身不会改变

3.2.4 E set(int index,E element) 指定位置取出元素，并修改该索引的元素

3.2.5ListIterator listIterator() 列表迭代器，List集合特有的迭代器

1.正向遍历 listIterator.hasNext()

2.反向遍历 listIterator.hasPrevious()

想要实现反向遍历九必须先执行一遍正向遍历，因为指针开始在集合的左边

3.2.6ListIterator接口的成员方法

1.boolean hasPrevious()

2.E previous()

看3.2.5

3.3ArrayList类(是list的具体子类)

3.3.1ArrayList类的概述

1.底层数据结构是数组，查询快，增删慢

2.线程不安全，效率高

3.3.1ArrayList的构造方法

1.ArrayList()创建一个集合

3.3.2Collection接口成员方法

1.boolean add(Object e) 向集合中添加元素可以存放任意的引用数据类型

1.返回此集合的字符串表示形式

package com.shujia.day11;

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

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

        //创建一个ArrayList空集合，用Collection接收
        Collection c= new ArrayList();

        //boolean add(E e)
        c.add(10);
        c.add(10.98);
        c.add(true);
        c.add("hello");
        System.out.println("c："+c);//c：[10, 10.98, true, hello]
        
    }
    }

2.boolean remove(Object o) 删除一个元素

1.调用一次只会删除一个元素

2.删除一个不存在的元素不会报错，返回原来的元素

package com.shujia.day11;

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

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

        //创建一个ArrayList空集合，用Collection接收
        Collection c= new ArrayList();

        //boolean add(E e)
        c.add(10);
        c.add(10.98);
        c.add(true);
        c.add("hello");
        System.out.println("c："+c);//c：[10, 10.98, true, hello]

        //删除一个元素
        c.remove(10);
        System.out.println("c："+c);//c：[10.98, true, hello]



    }
    }

3.void clear() 清除集合

package com.shujia.day11;

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

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

        //创建一个ArrayList空集合，用Collection接收
        Collection c= new ArrayList();

        //boolean add(E e)
        c.add(10);
        c.add(10);
        c.add(10.98);
        c.add(true);
        c.add("hello");
        System.out.println("c："+c);//c：[10,10, 10.98, true, hello]

        //删除一个元素 调用一次只会删除一个元素
        c.remove(10);
        System.out.println("c："+c);//c：[10,10.98, true, hello]
        //删除一个不存在的元素不会报错，返回原来的元素
        c.remove(100);
        System.out.println("c："+c);//c：[10,10.98, true, hello]

        //void clear()清除集合
        c.clear();
        System.out.println("c："+c);//[]




    }
    }

4.boolean contains(Object o) 判断集合是否包含某个元素

package com.shujia.day11;

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

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

        //创建一个ArrayList空集合，用Collection接收
        Collection c= new ArrayList();

        //boolean add(E e)
        c.add(10);
        c.add(10);
        c.add(10.98);
        c.add(true);
        c.add("hello");
        System.out.println("c："+c);//c：[10,10, 10.98, true, hello]

        //删除一个元素 调用一次只会删除一个元素
        c.remove(10);
        System.out.println("c："+c);//c：[10,10.98, true, hello]
        //删除一个不存在的元素不会报错，返回原来的元素
        c.remove(100);
        System.out.println("c："+c);//c：[10,10.98, true, hello]

        //void clear()清除集合
//        c.clear();
//        System.out.println("c："+c);//[]

        //boolean contains(Object o) 判断集合是否包含某个元素
        System.out.println(c.contains(10));//true




    }
    }

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

package com.shujia.day11;

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

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

        //创建一个ArrayList空集合，用Collection接收
        Collection c= new ArrayList();

        //boolean add(E e)
        c.add(10);
        c.add(10);
        c.add(10.98);
        c.add(true);
        c.add("hello");
        System.out.println("c："+c);//c：[10,10, 10.98, true, hello]

        //删除一个元素 调用一次只会删除一个元素
        c.remove(10);
        System.out.println("c："+c);//c：[10,10.98, true, hello]
        //删除一个不存在的元素不会报错，返回原来的元素
        c.remove(100);
        System.out.println("c："+c);//c：[10,10.98, true, hello]

        //void clear()清除集合
//        c.clear();
//        System.out.println("c："+c);//[]

        //boolean contains(Object o) 判断集合是否包含某个元素
        System.out.println(c.contains(10));//true

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




    }
    }

6.int size() 获取集合中的元素个数

package com.shujia.day11;

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

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

        //创建一个ArrayList空集合，用Collection接收
        Collection c= new ArrayList();

        //boolean add(E e)
        c.add(10);
        c.add(10);
        c.add(10.98);
        c.add(true);
        c.add("hello");
        System.out.println("c："+c);//c：[10,10, 10.98, true, hello]

        //删除一个元素 调用一次只会删除一个元素
        c.remove(10);
        System.out.println("c："+c);//c：[10,10.98, true, hello]
        //删除一个不存在的元素不会报错，返回原来的元素
        c.remove(100);
        System.out.println("c："+c);//c：[10,10.98, true, hello]

        //void clear()清除集合
//        c.clear();
//        System.out.println("c："+c);//[]

        //boolean contains(Object o) 判断集合是否包含某个元素
        System.out.println(c.contains(10));//true

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

        //int size() 获取集合中的元素个数
        System.out.println(c.size());//4
    }
    }

7.boolean addAll(Collection c) 将一个集合中的元素添加到另一个集合中

package com.shujia.day11;

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

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

        //创建集合对象
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");
        System.out.println("c1: " + c1);//c1: [java, maven&git, redis, clickhouse, hadoop]


        Collection c2 = new ArrayList();
        c2.add("redis");
        c2.add("clickhouse");
        c2.add("hadoop");
        c2.add("hive");
        System.out.println("c2: " + c2); //c2: [redis, clickhouse, hadoop, hive]

        //boolean addAll(Collection c) 将一个集合中的元素添加到另一个集合中
        c1.addAll(c2);
        System.out.println(c1);//[java, maven&git, redis, clickhouse, hadoop, redis, clickhouse, hadoop, hive]
        System.out.println(c2);//[redis, clickhouse, hadoop, hive]

    }
}

8boolean removeAll(Collection c) 删除相同的部分

package com.shujia.day11;

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

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

        //创建集合对象
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");
        System.out.println("c1: " + c1);//c1: [java, maven&git, redis, clickhouse, hadoop]


        Collection c2 = new ArrayList();
        c2.add("redis");
        c2.add("clickhouse");
        c2.add("hadoop");
        c2.add("hive");
        System.out.println("c2: " + c2); //c2: [redis, clickhouse, hadoop, hive]
        c1.removeAll(c2);//在c1中移除与c2相同部分的元素
        System.out.println(c1);//[java, maven&git]
        System.out.println(c2);//[redis, clickhouse, hadoop, hive]

    }
}

9.boolean containsAll(Collection c) 判断2个集合是否相同

package com.shujia.day11;

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

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

        //创建集合对象
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");
        System.out.println("c1: " + c1);//c1: [java, maven&git, redis, clickhouse, hadoop]


        Collection c2 = new ArrayList();
        c2.add("redis");
        c2.add("clickhouse");
        c2.add("hadoop");
        c2.add("hive");
        System.out.println("c2: " + c2); //c2: [redis, clickhouse, hadoop, hive]
        System.out.println(c1.containsAll(c2));//false



    }
}

10.boolean retainAll(Collection c) 求交集

1.c1.retainAll(c2)

c1与c2做交集交集的结果存储在c1中，c2不变

package com.shujia.day11;

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

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

        //创建集合对象
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");
        System.out.println("c1: " + c1);//c1: [java, maven&git, redis, clickhouse, hadoop]


        Collection c2 = new ArrayList();
        c2.add("redis");
        c2.add("clickhouse");
        c2.add("hadoop");
        c2.add("hive");
        System.out.println("c2: " + c2); //c2: [redis, clickhouse, hadoop, hive]
        //boolean retainAll(Collection c) 求交集
        c1.retainAll(c2);
        System.out.println(c1);//[redis, clickhouse, hadoop]
        System.out.println(c2);//[redis, clickhouse, hadoop, hive]

3.3.3如何遍历一个集合

1.Object[] toArray() 把集合转成数组，可以实现集合的遍历

1.使用方法

Object[] 变量名 = 集合对象名.toArray()

2.遍历集合

package com.shujia.day11;

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

public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList(); // 接口多态
        //向集合中添加元素
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");

        //将集合转成数组
        Object[] array = c1.toArray();
        //遍历数组

        for (int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}
/*
java
maven&git
redis
clickhouse
hadoop
 */

此时什么集合的元素是Object的对象，并不是String，所以不能使用length方法，如果想使用必须转型

package com.shujia.day11;

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

public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList(); // 接口多态
        //向集合中添加元素
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");

        //将集合转成数组
        Object[] array = c1.toArray();
        //遍历数组

        for (int i=0;i<array.length;i++){
            String s=(String) array[i];
            System.out.println(s+":"+s.length());
        }
    }
}
/*
java:4
maven&git:9
redis:5
clickhouse:10
hadoop:6
 */

2.迭代器遍历 Iterator iterator()

1.迭代器，Collection集合特有遍历方式可遍历的序列

2使用方法

Iterator 变量名 = 集合对象名.iterator()

这里的集合对象实际上堆内存是ArrayList的对象，所以调用iterator()底层返回的是一个ArrayList类中的私有成员内部类Itr的对象

使用的还是Itr.next()方法

package com.shujia.day11;

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

public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList(); // 接口多态
        //向集合中添加元素
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");

        Iterator iterator = c1.iterator();
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        
    }
}
/*
java
maven&git
redis
clickhouse
hadoop
 */

但是这样写有个弊端，如果集合里面只有5个元素，而输出了超过5个元素，那么会报错

3.改进使用hasnext()方法

我们应该在取下一个元素之前，先判断一下，下一个位置上有没有元素，如果有，就next()，否则就不获取

package com.shujia.day11;

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

public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList(); // 接口多态
        //向集合中添加元素
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");

        Iterator iterator = c1.iterator();

        //使用hasnext()方法
        if (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        if (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        if (iterator.hasNext()){
            System.out.println(iterator.next());
        } if (iterator.hasNext()){
            System.out.println(iterator.next());
        } if (iterator.hasNext()){
            System.out.println(iterator.next());
        } if (iterator.hasNext()){
            System.out.println(iterator.next());
        } if (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}
/*
java
maven&git
redis
clickhouse
hadoop
 */

这种虽然解决了超过元素数量的问题但是代码太长了

4.再次改进

不知道次数的情况下，获取数据，优先使用while循环

package com.shujia.day11;

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

public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList(); // 接口多态
        //向集合中添加元素
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");

        Iterator iterator = c1.iterator();

        //使用hasnext()方法
//        if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        } if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        } if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        } if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        } if (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}
/*
java
maven&git
redis
clickhouse
hadoop
 */

这里输出的也是Object的对象，如果想使用他九必须转到你想用的类型

5.又有一个问题在遍历迭代器的时候，集合的长度发生了变化(比如说向集合里面添加了元素)，而迭代器不知道，长度不一致，报错。会出现 ConcurrentModificationException 并发修改异常

a.这是错误的案例使用iterator迭代器遍历

package com.shujia.day12;

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

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

        list1.add("hadoop");
        list1.add("hive");
        list1.add("java");
        list1.add("apple");

        System.out.println("list1: " + list1);

        Iterator iterator = list1.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            String s = (String) next;
            if ("java".equals(s)) {
                list1.add("flink");//ConcurrentModificationException
            }
        }
    }
}

b.使用迭代器listIterator即可

这样添加的位置是出现后的位置

package com.shujia.day12;

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

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

        list1.add("hadoop");
        list1.add("hive");
        list1.add("java");
        list1.add("apple");

        System.out.println("list1: " + list1);

        ListIterator listIterator = list1.listIterator();
        while (listIterator.hasNext()) {
            String s=(String) listIterator.next();
            if ("java".equals(s)) {
                listIterator.add("flink");//ConcurrentModificationException
            }
        }
        System.out.println("list1: " + list1);
    }
}
/*
list1: [hadoop, hive, java, apple]
list1: [hadoop, hive, java, flink, apple]
*/

c.使用数组遍历

这种添加是在最后的位置添加

package com.shujia.day12;

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

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

        list1.add("hadoop");
        list1.add("hive");
        list1.add("java");
        list1.add("apple");

        System.out.println("list1: " + list1);

        Object[] array = list1.toArray();
        for (int i=0;i<array.length;i++){
            String s=(String) array[i];
            if ("java".equals(array[i])){
                list1.add("flink");
            }
        }

//        ListIterator listIterator = list1.listIterator();
//        while (listIterator.hasNext()) {
//            String s=(String) listIterator.next();
//            if ("java".equals(s)) {
//                listIterator.add("flink");//ConcurrentModificationException
//            }
//        }
        System.out.println("list1: " + list1);
    }
}
/*
list1: [hadoop, hive, java, apple]
list1: [hadoop, hive, java, apple, flink]
*/

3.3.4 遍历ArraysList集合

package com.shujia.day12;

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

public class ArraysListDemo1 {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList = new ArrayList();

        //创建元素并添加到集合中

        arrayList.add("java");
        arrayList.add("hadoop");
        arrayList.add("hive");
        arrayList.add("Hbase");

        //遍历集合
        //使用迭代器
        ListIterator listIterator = arrayList.listIterator();
        while (true){
            if (listIterator.hasNext()){
                System.out.println(listIterator.next());
            }
        }
    }
}
/*
java
hadoop
hive
Hbase

 */

3.4Vector类

3.4.1概述

1.底层数据结构是数组，查询快，增删慢

2.线程安全，效率低。即使这个是线程安全的，我们今后也不用，后面我们会将不安全的ArrayList变成安全的

3.4.2构造方法 new Vector 创建一个空Vector集合

1. Vector 集合名=new Vector();

3.4.3特有方法

1.public void addElement(E obj) 向集合中添加元素，以后用add()

2.public E elementAt(int index) 根据索引取出元素，以后用get()

3.public Enumeration elements() 这个获取所有元素，跟迭代器terator iterator()用法差不多，以后尽量用这个迭代器

3.5LinkedList类

3.5.1概述

1.底层数据结构是双链表，查询慢，增删快

2.线程不安全，效率高

3.5.2构造方法 new LinkedList 创建空集合

1.LinkedList 集合名=new LinkedList();

3.5.3特有方法

1.public void addFirst(E e)及addLast(E e)

package com.shujia.day12;

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList的集合
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst("aaa");
        linkedList.addFirst("bbb");
        linkedList.addFirst("ccc");
        linkedList.addFirst("ddd");
        System.out.println(linkedList);
    }
}
/*
[ddd, ccc, bbb, aaa]

 */

package com.shujia.day12;

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList的集合
        LinkedList linkedList = new LinkedList();
//        linkedList.addFirst("aaa");
//        linkedList.addFirst("bbb");
//        linkedList.addFirst("ccc");
//        linkedList.addFirst("ddd");
        linkedList.addLast("aaa");
        linkedList.addLast("bbb");
        linkedList.addLast("ccc");
        linkedList.addLast("ddd");
        System.out.println(linkedList);
    }
}
/*
[aaa, bbb, ccc, ddd]

 */

2.public E getFirst()及getLast()

1.获取的是开头or结尾的元素

3.public E removeFirst()及public E removeLast()

1.删除开头或者结尾的元素，并返回这个元素

3.5.4遍历LinkedList集合

package com.shujia.day12;

import java.util.LinkedList;
import java.util.ListIterator;

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

        //创建集合对象
        LinkedList linkedList = new LinkedList();

        //创建元素对象
        Student s1 = new Student("张三", 12);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 12);
        Student s4 = new Student("赵六", 13);

        //将元素添加到集合中
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s4);

        //遍历集合
        //创建迭代器
        ListIterator listIterator = linkedList.listIterator();

        while (true){
            if (listIterator.hasNext()){
                Student student=(Student) listIterator.next();
                System.out.println("姓名："+student.getName()+"----年龄是："+student.getAge());
            }
        }

    }
}
/*
姓名：张三----年龄是：12
姓名：李四----年龄是：14
姓名：王五----年龄是：12
姓名：赵六----年龄是：13
 */

3.6List集合练习

3.6.1去除ArrayList集合中字符串的重复值(字符串的内容相同)

package com.shujia.day12;

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

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

        //创建元素对象并添加到集合中
        arrayList.add("java");
        arrayList.add("hadoop");
        arrayList.add("hive");
        arrayList.add("hbase");
        arrayList.add("数据采集");
        arrayList.add("hive");
        arrayList.add("hadoop");
        arrayList.add("hive");

        //创建一个空集合
        ArrayList arrayList1 = new ArrayList();

        //遍历旧集合，判断集合中是否有重复的元素，如果不是就添加到新集合中
        //创建迭代器
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            String s=(String) listIterator.next();
            if (!arrayList1.contains(s)){
                arrayList1.add(s);

            }
        }
        System.out.println(arrayList1);
        System.out.println(arrayList);
        
    }
}

3.6.2去除ArraysList集合中自定义对象的重复值(对象的成员变量值都相同)

1.使用ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同) 按照上一个去重字符串的逻辑对对象进行去重发现，并没有去重经过简单的分析后发现，if (!list2.contains(t))永远为true,元素才会不断的向新集合中添加 !list2.contains(t)整体永远为true, 意味着list2.contains(t)永远为false 现在应该去看contains()方法的源码

2.通过分析后发现，底层判断元素是否重复，是调用了元素类型中的equals方法来比较的，而我们Teacher类中没有重写equals方法调用的是父亲Object类中的equals方法，而Object类中的equals比较的是地址值，我们的每一个Teacher对象都是new出来的，地址值肯定不一样所以equals比较的结果永远为false 要想达到去重效果，就应该比较对象的成员变量值，而不是比较地址值，我们应该是当对象的成员变量值相同的时候，认为是同一个对象只需要元素的类型中重写equals方法即可，自动生成即可

Teacher类

package com.shujia.day12;

import java.util.Objects;

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

测试类

package com.shujia.day12;

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

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

        //创建元素对象
        Teacher t1 = new Teacher("小虎", 18);
        Teacher t2 = new Teacher("阿彪", 17);
        Teacher t3 = new Teacher("阿凤", 15);
        Teacher t4 = new Teacher("小宁", 17);
        Teacher t5 = new Teacher("小虎", 18);

        //将元素添加到集合中
        list.add(t1);
        list.add(t2);
        list.add(t3);
        list.add(t4);
        list.add(t5);

        //创建一个新空集合
        ArrayList list2 = new ArrayList();

        //遍历旧集合，判断新集合中是否存在该元素，如果有，说明重复，就不添加到新集合中，否则就添加
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Teacher teacher=(Teacher) listIterator.next();
            if (!list2.contains(teacher)){
                list2.add(teacher);
            }
        }
        System.out.println(list2);
    }
}

3.6.3 请用LinkedList模拟栈数据结构的集合，并测试

1.栈：先进后出

2.如果笔试的时候，直接使用LinkedList对象存储元素的话，0分题目的本意是，自己写一个类，类中将LinkedList进行封装，使用自己的类创建对象，底层用的是LinkedList

自己封装的linkedList类

package com.shujia.day12;

import java.util.LinkedList;

public class MyStack {
    //创建linkedList成员变量
    private LinkedList linkedList;
    //构造方法
    public MyStack() {
        linkedList=new LinkedList();//将linkedList的类包装给这个构造方法，等在测试类直接用
    }
    //手动添加linkedList中的addFirst方法 这是入栈
    public void myAdd(Object o){
        linkedList.addFirst(o);
    }
    //手动添加移除的方法 这是出栈
    public Object myGet(){
       return linkedList.removeFirst();
    }

    //获取linkedList的长度
    public int getLength(){
        return linkedList.size();
    }
}

测试类

package com.shujia.day12;

public class LinkedListText {
    public static void main(String[] args) {
        //创建自己的集合类对象
        MyStack myStack = new MyStack();
        //向集合中添加元素
        myStack.myAdd("java");
        myStack.myAdd("hello");
        myStack.myAdd("hadoop");
        myStack.myAdd("hive");

        //遍历集合
        int length=myStack.getLength();
        for (int i=0;i<length;i++){
            System.out.println(myStack.myGet());
        }
    }
}

3.6.4 集合的嵌套遍历

package com.shujia.day13;

import java.util.ArrayList;

class Student{
    String name;
    int age;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ListText1 {
    public static void main(String[] args) {
        //这里是先创建一个班级集合ArrayList<Student>，然后再把这个封装成一个年级集合ArrayList<ArrayList<Student>>
        ArrayList<ArrayList<Student>> nianJi = new ArrayList<>();
        
        //创建班级集合
        ArrayList<Student> class1 = new ArrayList<>();
        ArrayList<Student> class4 = new ArrayList<>();
        ArrayList<Student> class3 = new ArrayList<>();
        ArrayList<Student> class2 = new ArrayList<>();
        //创建班级对象并添加到集合中
        class1.add(new Student("hdd",19));
        class1.add(new Student("jdd",18));
        class2.add(new Student("add",20));
        class2.add(new Student("pdd",20));
        class3.add(new Student("gdd",20));
        class3.add(new Student("ydd",20));
        class4.add(new Student("zdd",20));
        class4.add(new Student("mdd",20));

        //再把班级集合添加到年级集合中
        nianJi.add(class1);
        nianJi.add(class2);
        nianJi.add(class3);
        nianJi.add(class4);

        //遍历年级集合
        for (ArrayList<Student> students : nianJi) {
            System.out.println(students);
        }

    }
}
/*
[Student{name='hdd', age=19}, Student{name='jdd', age=18}]
[Student{name='add', age=20}, Student{name='pdd', age=20}]
[Student{name='gdd', age=20}, Student{name='ydd', age=20}]
[Student{name='zdd', age=20}, Student{name='mdd', age=20}]
 */

3.6.5获取10个1-20之间的随机数，要求不能重复

package com.shujia.day13;

import java.util.ArrayList;
import java.util.Random;

public class ListText2 {
    public static void main(String[] args) {
        Random random = new Random();

        //创建集合
        ArrayList<Integer> integers = new ArrayList<>();
        while (integers.size()!=10){
            int num=random.nextInt(20)+1;
            if (!integers.contains(num)){
                integers.add(num);
            }
        }
        System.out.println(integers);
    }
}

3.6.6键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值

package com.shujia.day13;

import java.util.ArrayList;
import java.util.Scanner;

public class ListText3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //创建集合对象
        ArrayList<Integer> integers = new ArrayList<>();
        //向集合中添加元素
        while (true){
            System.out.println("请输入几个个随机整数");
            int num =scanner.nextInt();
            if (num!=0){
                integers.add(num);
            }else {
                break;
            }
        }
        //遍历集合
        //设置默认最大值
        Integer maxNum=integers.get(0);
        for (Integer integer : integers) {
            if (integer>maxNum){
                maxNum=integer;
            }
        }
        System.out.println(maxNum);
    }
}

四 set接口

4.1概述

1.元素无序（存储和取出的顺序不一致），且唯一

4.2HashSet类

4.2.1概述

1.不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变。

2.HashSet如何保证元素唯一性

a.底层数据结构是哈希表(元素是链表的数组)

b.哈希表依赖于哈希值存储

4.2.2 构造方法HashSet()

1.HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。

package com.shujia.day13;

import java.util.HashSet;

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

        //向集合中添加元素
        hashSet.add("haa");
        hashSet.add("hdd");
        hashSet.add("hag");
        hashSet.add("haa");
        hashSet.add("hff");
        hashSet.add("has");

        //遍历集合
        for (String string : hashSet) {
            System.out.println(string);
        }
    }
}
/*
haa
hdd
hff
has
hag
 */

不难看出，向set集合中添加元素是无序的且不能重复的

4.2.3添加功能依赖于int hashCode() boolean equals(Object obj) （去重）

1.HashSet中要想保证元素唯一，就要保证元素类中要重写equals和hashCode方法。

package com.shujia.day13;

import java.util.HashSet;

class Student1{
    String name;
    int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student1> set = new HashSet<>();

        //创建元素对象
        Student1 s1 = new Student1("hdd", 18);
        Student1 s2 = new Student1("aaa", 16);
        Student1 s3 = new Student1("kkk", 18);
        Student1 s4 = new Student1("hdd", 18);
        Student1 s5 = new Student1("xxx", 17);

        //将元素添加到集合中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

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

    }
}
/*
Student1{name='aaa', age=16}
Student1{name='hdd', age=18}
Student1{name='hdd', age=18}
Student1{name='kkk', age=18}
Student1{name='xxx', age=17}
 */

不难看出这样并没有去重，重写int hashCode() boolean equals(Object obj)即可

package com.shujia.day13;

import java.util.HashSet;
import java.util.Objects;

class Student1{
    String name;
    int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

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

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

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student1> set = new HashSet<>();

        //创建元素对象
        Student1 s1 = new Student1("hdd", 18);
        Student1 s2 = new Student1("aaa", 16);
        Student1 s3 = new Student1("kkk", 18);
        Student1 s4 = new Student1("hdd", 18);
        Student1 s5 = new Student1("xxx", 17);

        //将元素添加到集合中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

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

    }
}
/*
Student1{name='xxx', age=17}
Student1{name='kkk', age=18}
Student1{name='hdd', age=18}
Student1{name='aaa', age=16}
 */

4.3LinkedHashSet类

4.3.1概述

1.元素有序唯一

2.由链表保证元素有序

3.由哈希表保证元素唯一

4.是Hashset的子类

5.双向链表结构

6.他是有序的

4.3.2使用

package com.shujia.day13;

import java.util.LinkedHashSet;

public class LinkedHashSetDemo1 {
    public static void main(String[] args) {
        LinkedHashSet<Integer> integers = new LinkedHashSet<>();

        integers.add(33);
        integers.add(11);
        integers.add(32);
        integers.add(33);
        integers.add(90);
        integers.add(45);
        integers.add(29);

        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}
/*
33
11
32
90
45
29
 */

可以看出去重了，但是元素是有顺序的

4.4TreeSet类

4.4.1概述

1.底层数据结构是红黑树（可排序的），线程不安全，效率高

4.4.2自动排序

1.使用TreeSet存储字符串对象，并遍历

1.通过观察源码发现，因为我们创建TreeSet集合对象的时候，使用的是无参构造方法所以底层创建TreeMap的时候也是无参构造方法，comparator是null，不走比较器排序走的是自然排序。

2.部分源代码

  Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t; // "java"
                cmp = k.compareTo(t.key); // 1
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);

3.答案

不难看出，去重并排序了

package com.shujia.day13;

import java.util.TreeSet;

public class TreeSetDemo1 {
    public static void main(String[] args) {
        //创建TreeSet集合，用无参方法
        TreeSet<String> treeSet = new TreeSet<>();
        //创建元素对象并添加到集合中
        treeSet.add("java");
        treeSet.add("hadoop");
        treeSet.add("redis");
        treeSet.add("clickhouse");
        treeSet.add("hbase");
        treeSet.add("java");

        //遍历集合
        for (String s : treeSet) {
            System.out.println(s);
        }
    }
}
/*
clickhouse
hadoop
hbase
java
redis
 */

2.TreeSet集合存储自定义对象，并遍历

1.与存储字符串的区别

1.我们按照存储字符串一样的逻辑存储自定义对象，运行的时候报错了 ClassCastException： com.shujia.day13.Student2 cannot be cast to java.lang.Comparable 原因是因为，我们现在使用的时候自然排序方式，需要元素的类实现Comparable接口，才可以进行转型

2.改进

1.定义类的时候实现Comparable接口，里面传入的参数必须是该类

class 类名 implements Comparable<类名>

2.重写 Comparable接口的coampreTo方法，

重写后的coampreTo方法的参数就是接口里面传入的是啥类型，他就是啥类型的参数

3.coampreTo方法里面的返回值计算

this 代表待插入的

参数类型名表示已经存在的

比较最好用三元比较符

4.代码

package com.shujia.day13;

import java.util.TreeSet;

class Student2 implements Comparable<Student2>{
    String name;
    int age;

    public Student2() {
    }

    public Student2(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Student2 o) {
        int i=this.age-o.age;
        return (i==0) ? this.name.compareTo(o.name) : i;
    }
}
public class TreeSetDemo2 {
    public static void main(String[] args) {
        //创建无参集合对象
        TreeSet<Student2> treeSet1 = new TreeSet<>();

        //创建对象
        Student2 student1 = new Student2("hdd",18);
        Student2 student2 = new Student2("ldd",19);
        Student2 student3 = new Student2("mmm",20);
        Student2 student4 = new Student2("hdd",18);
        Student2 student5 = new Student2("xxx",18);

        //添加元素到集合
        treeSet1.add(student1);
        treeSet1.add(student2);
        treeSet1.add(student3);
        treeSet1.add(student4);
        treeSet1.add(student5);

        //遍历集合
        for (Student2 student21 : treeSet1) {
            System.out.println(student21);
        }

    }
}
/*
Student2{name='hdd', age=18}
Student2{name='xxx', age=18}
Student2{name='ldd', age=19}
Student2{name='mmm', age=20}
 */

4.4.5比较器排序(实现Comparator接口)

1.方法

1.在创建TreeSet集合时使用有参构造方法，传入一个类型

TreeSet<集合中的类型> 集合名 = new TreeSet<>(new Comparator<实现该接口的对象>(){

重写compare方法

2.在compare方法中，前面的表示待插入的，后面的表示已经存在的

3.代码

package com.shujia.day13;

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

class Student3 {
    String name;
    int age;

    public Student3() {
    }

    public Student3(String name, int age) {
        this.name = name;
        this.age = age;
    }

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


}

public class TreeSetDemo3 {
    public static void main(String[] args) {
        //创建有参TreeSet集合
        TreeSet<Student3> treeSet1 = new TreeSet<>(new Comparator<Student3>() {
            @Override
            public int compare(Student3 o1, Student3 o2) {
                int i=o1.age-o2.age;
                return (i==0) ? o1.name.compareTo(o2.name) : i;
            }
        });
        //创建对象
        Student3 student1= new Student3("hdd",18);
        Student3 student2= new Student3("ldd",19);
        Student3 student3 = new Student3("mmm",20);
        Student3 student4 = new Student3("hdd",18);
        Student3 student5 = new Student3("xxx",18);

        //添加元素到集合
        treeSet1.add(student1);
        treeSet1.add(student2);
        treeSet1.add(student3);
        treeSet1.add(student4);
        treeSet1.add(student5);
        for (Student3 student31 : treeSet1) {
            System.out.println(student31);
        }
    }
}
/*
Student2{name='hdd', age=18}
Student2{name='xxx', age=18}
Student2{name='ldd', age=19}
Student2{name='mmm', age=20}

 */

2.与选择排序的选择

1、如果要使用自然排序，在创建TreeSet对象的时候，使用无参构造方法，但是要保证元素的类实现Comparable接口，重写compareTo方法。

2、如果要使用比较器排序，在创建TreeSet对象的时候，使用有参构造方法，传入一个实现了Comparator接口的子类对象，重写compare方法

3经典例题

1.键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台

package com.shujia.day13;

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

/*
键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台

 */
class Student4{
    private String name;
    private int chinese;
    private int math;
    private int english;

    public Student4() {
    }

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

    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 getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    @Override
    public String toString() {
        return "Student4{" +
                "name='" + name + '\'' +
                ", chinese=" + chinese +
                ", math=" + math +
                ", english=" + english +
                '}';
    }
    public int getSum(){
        return chinese+math+english;
    }
}

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

        //创建集合
        TreeSet<Student4> treeSet = new TreeSet<>(new Comparator<Student4>() {
            @Override
            public int compare(Student4 o1, Student4 o2) {
                //比总分
                int i1=o2.getSum()-o1.getSum();
                //总分相同相同，但是语文成绩不相同
                int i2=(i1==0) ? o2.getChinese()-o1.getChinese():i1;
                总分相同相同，但是语文成绩相同,数学成绩不相同
                int i3=(i2==0)?o2.getMath()-o2.getMath():i2;
                //总分相同相同，但是语文成绩相同,数学成绩相同，姓名不同
                return (i3==0)?o2.getName().compareTo(o1.getName()):i3;
            }
        });

        //创建元素对象
        Scanner sc = new Scanner(System.in);
        Student4 student4;
        for (int i=1;i<6;i++){
            System.out.println("请输入第"+i+"学生的信息");
            System.out.println("姓名是：");
            String name=sc.next();
            System.out.println("语文成绩是：");
            int chinese=sc.nextInt();
            System.out.println("数学成绩是：");
            int math=sc.nextInt();
            System.out.println("英语成绩是：");
            int english=sc.nextInt();
            student4=new Student4(name,chinese,math,english);
            treeSet.add(student4);

        }
        //遍历集合
        for (Student4 student41 : treeSet) {
            System.out.println(student41.getName()+"\t"+student41.getChinese()
                    +"\t"+student41.getMath()
                    +"\t"+student41.getEnglish()
                    +"\t"+student41.getSum());
        }
    }
}
/*
zxy	100	100	100	300
kkk	90	90	80	260
ddd	90	80	90	260
jjj	80	90	90	260
hdd	80	90	90	260
*/

五 Map接口

5.1Map接口的概述

1.将键映射到值的对象

2.一个映射不能包含重复的键

3.每个键最多只能映射到一个值，但是值可以重复

5.2Map接口与Collection接口的区别

1.Map是双列的,Collection是单列的

2.Map的键唯一,Collection的子体系Set是唯一的

3.Map集合的数据结构值针对键有效，跟值无关

Collection集合的数据结构是针对元素有效

5.3Map接口的成员方法

5.3.1.V put(K key,V value) 向集合中添加一对键值对

1.如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值

2.添加元素进去会根据键来排序

package com.shujia.day14;

import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //通过HashMap来创建Map的集合
        HashMap<Integer, String> map = new HashMap<>();
        System.out.println(map.put(1001, "hdd"));
        System.out.println(map.put(1002, "jdd"));
        System.out.println(map.put(1003, "ldd"));
        System.out.println(map.put(1003,"kdd"));
        System.out.println(map);
    }
}
/*
null
null
null
ldd
{1001=hdd, 1002=jdd, 1003=kdd}
 */

5.3.2V remove(Object key)

1.根据键删除整个键值对，因为键是唯一的，返回键对应的值

5.3.3void clear() 清除整个Map

1.没有返回值

5.3.4 boolean containsKey(Object key) 判断集合中是否存在这个键

5.3.5 boolean containsValue(Object value) 判断集合中是否存在这个值

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

5.3.7 int size()返回集合中有多少键值对

5.3.8 V get(Object key) 根据键返回对应的值

1如果给一个不存在的键会返回一个null

5.3.9 Set<K> keySet() 获取所有的键组成一个set集合返回

5.3.10 Collection<V> values() 获取所有的值返回一个collection集合

5.3.11 Set<Map.Entry<K,V>> entrySet() 返回一个个的键值对，用set集合接收

5.4遍历一个Map集合

5.4.1.获取所有的键

package com.shujia.day14;

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

/*
        Map集合遍历的方式：
        1、先获取所有的键，遍历键获取对应的值
 */
public class MapDemo3 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1001, "尚平");
        map1.put(1003, "乔丹");
        map1.put(1002, "黄杰");
        map1.put(1004, "卢鹏");
        map1.put(1005, "张跃");
        System.out.println("map1: " + map1);
        System.out.println("-------------------------");
        //获取所有的键
        Set<Integer> keySet = map1.keySet();
        for (Integer key : keySet) {
            //根据键获取对应的值
            String value = map1.get(key);
            System.out.println(key + "--" + value);
        }
    }
}

5.4.2 获取键值对

1.entrySet里面有方法可以直接获取键，跟值的方法

getKey()与getValue()

5.5.HashMap类

5.5.1概述

1.键是哈希表结构，可以保证键的唯一性

2.要想保证HashMap中的键(对象类型)唯一根据分析得出，键的类型要重写hashCode()方法和equals方法

package com.shujia.day14;

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

class Student1{
    private String name;
    private int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class HashMapDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        HashMap<Student1, String> map = new HashMap<>();

        //创建元素对象
        Student1 s1 = new Student1("小红", 16);
        Student1 s2 = new Student1("小红2", 15);
        Student1 s3 = new Student1("小红3", 18);
        Student1 s4 = new Student1("小红4", 19);
        Student1 s5 = new Student1("小红", 16);

        //向集合中添加元素
        map.put(s1, "打篮球");
        map.put(s2, "踢足球");
        map.put(s3, "打排球");
        map.put(s4, "打台球");
        map.put(s5, "打羽毛球");
        //遍历集合
        Set<Map.Entry<Student1, String>> entries = map.entrySet();
        for (Map.Entry<Student1, String> entry : entries) {
            Student1 key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + ": " + value);
        }
    }
}
/*
Student1{name='小红2', age=15}: 踢足球
Student1{name='小红', age=16}: 打羽毛球
Student1{name='小红3', age=18}: 打排球
Student1{name='小红4', age=19}: 打台球
 */

5.6 LinkedHashMap

5.6.1概述

1.底层数据结构是哈希表和双链表

2.取出的顺序与添加的顺序一致(去重但是没有排序)

package com.shujia.day14;

import java.util.LinkedHashMap;

public class LinkedHashMapDemo1 {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<>();

        map.put("1001","shujia1");
        map.put("1002","shujia2");
        map.put("1003","shujia3");
        map.put("1002","shujia4");
        map.put("1007","shujia5");
        map.put("1005","shujia6");
        map.put("1004","shujia7");

        System.out.println(map);
        //{1001=shujia1, 1002=shujia4, 1003=shujia3, 1007=shujia5, 1005=shujia6, 1004=shujia7}
    }
}

5.7 TreeMap类

5.7.1概述

1.键是红黑树结构，可以保证键的排序和唯一性

5.7.2 遍历TreeMap集合

1.TreeMap无参构造方法

1.<key,value>key不是对象的引用数据类型

package com.shujia.day14;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapDemo1 {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();

        map.put(1004,"张三");
        map.put(1005,"李四");
        map.put(1002,"王五");
        map.put(1001,"赵六");
        map.put(1004,"王二麻");

//        System.out.println(map);
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for (Map.Entry<Integer, String> integerStringEntry : entrySet) {
            System.out.println(integerStringEntry.getKey()+integerStringEntry.getValue());
        }

    }
}
/*
1001赵六
1002王五
1004王二麻
1005李四
 */

2.<key,value>key是对象的引用数据类型

1.写对象key的时候类要继承Comparable<key> 接口，重写compareTo(key o)方法(自然排序)

2.TreeMap有参构造方法

1.在创建TreeMap集合对象时，使用匿名内部类实现 Comparator接口，搞清o1是待插入的，o2是已经存在的

package com.shujia.day14;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMapDemo2 {
    public static void main(String[] args) {
        TreeMap<Student1, String> map = new TreeMap<>(new Comparator<Student1>() {
            @Override
            public int compare(Student1 o1, Student1 o2) {
                int i1 = o1.getAge() - o2.getAge();
                //隐藏条件：年龄一样的时候，姓名不一定一样
                return (i1 == 0) ? o1.getName().compareTo(o2.getName()) : i1;
            }
        });

        map.put(new Student1("张三",18),"打游戏");
        map.put(new Student1("张三2",17),"打游戏2");
        map.put(new Student1("张三3",13),"打游戏3");
        map.put(new Student1("张三4",17),"打游戏4");
        map.put(new Student1("张三5",19),"打游戏5");
        map.put(new Student1("张三",18),"打游戏6");
        System.out.println(map);
    }
}

class Student1 {
    private String name;
    private int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

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