java容器练习

Java容器相关练习，最后是知识总结

一基本方法练习，

通过练习ArrayList熟悉容器操作

package org;

import java.util.*;
//前言：
/*
*
* 关系树
* Iterable->map<K,value>/Collection<? extends E>
* Collection<? extends E>  -> list/set
* List-> ArrayList
* set->hashset
*
* */
//List容器练习
//1、初始化 1、<>告诉它是什么类型。
//2、添加 1、add()追加，add(index,value)某一位置插入2、addAll（Collection< extends E>）
//3、删除 1、remove(index)，remove(Obj) ,removeAll(Collection< extends E>) ,clear()
//4、修改 1、set(index,value)
//5、遍历 1、for>for in(没啥)  , iterator (hasnext()) .next()
//6、长度（元素个数），转换 1、换为数组， 建立数组（size()） toArray（[]）  2、数组变为容器，new ArrayList(Array.asList([]));
//7、排序*** sort（CompareTo） Collections.shuffle(list);
//8、查找*** indexof(Obj) lastindexof(Obj)
//9、是否存在 contains(Obj) containsAll(Collection) 是否为空 isEmpty()
//10、截取 subList(from,to)  [from,to)
//11、保留 retainAll retain()  保留里面的，
//12、迭代器 Iterator   hasNext  next()
//13、List.of 返回一个 ArrayList()容器实现类，这个ArrayList是不能增加，删除 类似Array.asList()

//总结：
/*
*
* 1、ArrayList是一个工具
*   1、泛型，存放Object类元素，基本数据类型就不要存放了
*   2、相比较于数据可以批量操作，长度是可变的，所以好的利用效率很高，尽量不要一个一个的操作。
*   3、可以通过迭代器遍历，也可随机存取
*
*
*
* */

public class Test {
    public static void testlist(){
        //几个容器的关系 --接口，接口，实现类
        //Iterable<T> --- Collection<E>  -- List<E> set<E>  ArrayList<E>  Has
        //        List
        //我知道我的实现类实现了我的方法，利用重载机制就行了。所以可以通过实例化实现类，来对接口赋值，
        //我的方法就是我的实现类的方法，还有我的实现类没有重载的，但是我实现的方法。
        List<String> list = new ArrayList<String>();
        //list<E>,的E最好给一个类型，否则只能用公共的方法，公共的就是父类定义的。还要受到权限影响。
        Set set = new HashSet();
        //E里面都是类，不是基本数据类型、
        Map<Integer,String> map = new HashMap<Integer, String>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("张四");

        System.out.println(list.toString());
        set.add(list);//参数类型是list，个数还是一个
        System.out.println(set);
        System.out.println(list.get(0) instanceof String ? true : false);
        System.out.println("添加一群元素到集合中，一定效率高于一个一个添加");
        list.addAll(List.of("java","html","c/c++","servlet","mysql"));
        System.out.println("容器是否有某个元素"+list.contains("mysql"));
        System.out.println("容器是否有某些元素，需要用到容器"+list.containsAll(List.of("java", "html")));


        //输出
        for (String s : list) {
            System.out.println(s+" ");
        }
        System.out.println();
        for(int i = 0;i<list.size();i++){
            System.out.print(list.get(i)+" ");
        }
        //从后往前遍历容器
        for (int i= list.size()-1;i>=0;i--){
            System.out.print(list.get(i)+" ");
        }
        //查找某一个元素
        System.out.print("java的下标是：");
        System.out.print(list.indexOf("java"));
        System.out.print(" ");
        System.out.print(list.lastIndexOf("java"));
        //得到某个位置的元素
        System.out.println("下标为1的元素是："+list.get(1));
        //在某个位置插入元素
        list.add(1,"mysql");
        //清空所有元素
        list.clear();
        //判断容器是否为空
        System.out.println(list.isEmpty());


    }
    public static void testList2(){
        //容器和字符串之间的转换
        //字符串数组
        List<String> list = new ArrayList<String>();
        list.addAll(List.of("赵云","关羽","诸葛亮","曹操","周瑜"));
        String[] strs = new String[list.size()];
        list.toArray(strs);
        //通过Arrays工具输出字符串数组.
        System.out.println(Arrays.toString(strs));

        //字符串数组变为ArrayList
        //同样是利用Arrays  000000000 数组工具类
        List<String> myList = Arrays.asList(strs);//数组变为ArrayList之后，容器就不能增加，删除。
        System.out.println(myList);
        //参数是一个方法（接口），作用是比较两个数的大小，如果前面的值大，返回值是正数，
        //方法一改，如果前面大，返回值是负数，那么结果就是从小到大排序了。  里面是排序算法
        //这里元素就是String类型，泛型的原因
        //返回值是一个int类型

        myList.sort((a,b)-> a.compareTo(b));
        System.out.println("正序排序后"+myList);
        //添加一个负号
        myList.sort((a,b)->-a.compareTo(b));
        System.out.println("倒序排序后"+myList);
        //这是idea给我的方法
        myList.sort(String::compareTo);
        System.out.println("正序排序后"+myList);
        //有点像Array里面的sort方法

        //截取容器
        //List<E> subList(int fromIndex, int toIndex);

        // 下表范围 [2,3)
        myList.subList(2,3);
//        System.out.println(myList);//并没有改变原来的容器
        System.out.println(myList.subList(2,3));
        //截取之后的元素
        System.out.println(myList.subList(myList.indexOf("诸葛亮"), myList.size()-1));

        //截取元素并不能从一个位置截到最后一个位置,
//        String.substring()//String里面有两个方法。
//        System.out.println(myList.subList(myList.indexOf("诸葛亮")));

        //看看一群元素是否都有，不考虑位置
        System.out.println(myList.containsAll(List.of("诸葛亮","赵云")));
        //不允许删除，添加
//        myList.add("张三");
        myList.set(0,"王五");
        System.out.println(myList);
//        myList.remove(0);
        //        System.out.println(myList.retainAll(List.of("关羽")));//保留


    }
    //再次验证一下integer数组
    public static void testList4(){
        //将int[]转为integer[]
        List<Integer> myList = new ArrayList();
        int[] arr = new int[]{1,2,3,4,5,6,7,8,34,2,1};
        Integers integers = new Integers(arr);
        myList.addAll(Arrays.asList(integers.toIntegers()));
        myList.sort((a,b)->a-b);
        System.out.println(myList);
        myList.sort((a,b)->b-a);
        System.out.println(myList);
        //add不同于赋值
        myList.add(10);
        myList.remove(0);
    }

    public static void testList5(){
        int[] arr = new int[]{1,2,3,4,5,6,7,8,34,2,1};
        Integers integers = new Integers(arr);
        List<Integer> myList = Arrays.asList(integers.toIntegers());
        myList.sort((a,b)->a-b);
        System.out.println(myList);
        myList.sort((a,b)->b-a);
        System.out.println(myList);
        //add不同于赋值
        try {
           myList.add(10);
        }catch (UnsupportedOperationException e){
            System.out.println("不可以添加");
        }
        catch (Exception e){
            System.out.println("未知异常添加失败");
        }

        try{
            myList.remove(0);
        }
        catch (Exception e){
            System.out.println("不能删除第1个元素");
        }
    }


    //迭代器练习
    /*
    *
    * 泛型
    * 1、类型必须是类
    * 2、尽量告诉一下，
    * 3、类型不匹配异常是常有的， java.lang.ClassCastException。
    *       1、迭代器
    *       2、add，添加
    *
    *
    * */

    public static void  testList3(){
        List myList = new ArrayList<>();
        try {
            myList.addAll(List.of(1,3,4,"张四",6,1.12,"李四","赵四"));
        }
        catch (UnsupportedOperationException e){
            System.out.println("多种类型，类型不匹配");
        }
        //迭代器只读吗?,可以修改,添加，删除
        //Iterator 类型可以设置一下，防止意外.
        Iterator<Object> it = myList.iterator();
        System.out.println("第4个元素的类型是Integer吗"+ (myList.get(3) instanceof Integer));
        int count = 0;
        while(it.hasNext()){
            count++;
            try {
                //迭代器不能输出Integer，Double，因为我没有设，默认了
                System.out.println(it.next().toString());
            }
            catch (ClassCastException e){
                //利用try catch可以看看那个元素出问题。
                System.out.printf("第%d个元素出现问题",count);
            }
        }

    }


    public static void main(String[] args){
        testList3();
    }
}

//对象排序
class User{}

//汉字排序
//对象排序， compareTo

二HashSet练习总结

package cn;


import java.util.*;

//集合是新的空间--存放的值是地址
//存储器保证值唯一
//链表，不能随机访问

public class Test {
    {
        coder = 19;//可以设置成一个常量值。
    }

    Void a = null;//Void类，
    private final byte coder;


    public Test() {
        //可以在构造函数中初始化coder
//        coder = 0;
    }
    //String//包装类

    //set练习：
    //1、增加,添加一群 add addAll
    //2、删除,删除一群
    //3、修改，不可直接修改，但是添加时可以覆盖。
    //4、查找，只能遍历，不能随机查找
    //5、排序，不存在
    //6、是否包含
    public static void test1() {
        Set<String> set = new HashSet<String>();
        //测试一 添加
        // 1、hashset里面是有顺序的，不管你按什么怎么添加，它始终在那个位置. 和添加顺序无关。
        String[] strArr = new String[]{"诸葛亮", "汉武帝", "秦始皇", "汉高帝"};
        set.addAll(Arrays.asList(strArr));
        set.addAll(Set.of("张三", "李四", "王五", "赵六"));
        for (String string : set) {
//            System.out.print(string);
        }
        System.out.println();
        //使用迭代器，自动递增
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }


        //2、每个值只存一次，String字符串，包装类是特殊的,他们并不是通过==比较值，而是通过equals比较
        //存的是一个地址,（字符串，new区别很大）
//        System.out.println(set.size());
        String a = new String("刘高源");
        String b = new String("刘高源");

        set.add(a);
        set.add(b);//第二次就不存了，可以通过地址探究，遍历最后的值就是地址
        System.out.println(set.size());
        a = b;
//        b = "李四";//b又出现了,,可以看出字符串常量内存中只有一份。
        b = new String("李四");//字符数组，
        System.out.println("----------------------------------------");
        System.out.printf("a的值是%s%n", a);
        iterator = set.iterator();
        //不能直接比较迭代器
        while (iterator.hasNext()) {
            String temp = iterator.next();
            System.out.println(temp);
            if (a == temp) {
                System.out.println("a的地址存入了");
            }
            if (b == temp) {
                System.out.println("b的地址存入了");
            }
//            if(b==iterator.next()){
//                System.out.println("b的地址存入了");
//            }//越界了
        }

        //for in 效率很慢
        for (String str : set) {
            if (str == a) {
                System.out.println("a的地址存入了");
            }
            if (str == b) {
                System.out.println("b的地址存入了");
            }
        }

        System.out.println("添加前set长度是：" + set.size());
        System.out.println("添加Integer后set长度是：" + set.size());
        System.out.println("添加User后set长度是：" + set.size());
    }

    //Integer包装类
    //自动装箱，自动拆箱
    public static void testIntegerSet() {
        Set<Integer> set = new HashSet<Integer>();
        set.addAll(Set.of(1, 2, 3, 4, 5, 6, 7, 9, 32, 12, 67, 34, 54, 23, 31));


        set.add(20);
        System.out.println("添加前set长度是：" + set.size());//长度是16
        set.add(20);
        System.out.println("添加Integer后set长度是：" + set.size());//长度是16

        //自动包装了，其实和add20一样
        set.add(new Integer(20));
        System.out.println("添加Integer后set长度是：" + set.size());//长度是16
        //自动装箱案例
        Integer a = 1;//相当于重新new了一个
        Integer b = a;//共用地址
        b = 10;//重新new了,地址就变了
        System.out.printf("a的值是%d", a);//1

        //1、说明了set会包装类保证值不重复。不管地址是否一样，只要值一样认为是一个。
        //2、自动装箱练习。
    }

    public static void testStringSet() {
        Set<String> set = new HashSet();
        set.add("张三");
        System.out.printf("添加字符串前set容器长度是%d", set.size());//1
        set.add("张三");

        set.add(new String("张三"));
        System.out.printf("添加字符串后set容器长度是%d", set.size());//1
        //字符串类似包装类，这里也是按照那个原则。
        //字符串""也是可看成字符串，类似自动装箱。
    }


    public static void testUserSet() {
        Set<User> set = new HashSet<User>();
        set.addAll(Set.of(new User(), new User(), new User(), new User(), new User()));
        System.out.printf("添加前set长度是：%d\n", set.size());//5
        User u = new User();
        set.add(u);
        set.add(u);
        System.out.printf("添加User后set长度是：%d%n", set.size());//6

        //自定义类，普通的类并不会比较值,Comparable<User>接口，equals方法重写了也不行。
        //set认为只要地址不同就是不同的，地址相同就是同一个，
    }


    //探究字符数组和通过字符数组new出来的字符串之间关系
    //String是通过一个新的byte数组存储的，还有一些其它标志
    /*
     * 分配一个新的 String，
     * 以便它表示当前包含在字符数组参数中的字符序列。
     * 复制字符数组的内容;
     * 对字符数组的后续修改不会影响新创建的字符串。
     * */

    public static void testCharArr() {

        char[] temp = new char[]{'刘', '高', '源'};
        String str1 = new String(temp);
        String str2 = new String(temp);
        temp[0] = '中';
        System.out.println(str1);
        //字符串并不和字符数组共用地址(也就是不能赋值)。也是，他们毕竟不是同一个类型。
        System.out.println(str1 == str2 ? true : false);
//        System.out.println("" instanceof String);//""引起来的字符串常量也是字符串。
    }

    //hashset的删除，修改，查找
    public static void test2() {
        //1、删除remove，removeAll
        HashSet<String> set = new HashSet();
        //删除值为张三的元素
        System.out.println(set.remove("张三"));//false
        set.add("张三");
//        set.add("李四");
//        set.add("王五");
        //批量删除所有值为张三，李四，王五的元素
        //删除一个就返回true
        System.out.println(set.removeAll(List.of("张三", "李四", "王五")));

        //清空所有元素
        set.clear();
        //2修改，没有找到  --- 不能修改
//        set.

        //3查找，没有找到方法

//        System.out.println(set.getClass());
    }

    //迭代器
    //迭代器的遍历---使用迭代器遍历HashSet容器，hasNext() next()
    //迭代器的删除---使用迭代器删除HashSet容器元素 remove()
    //没有迭代器的修改

    public static void test3() {
        HashSet<String> set = new HashSet();
        set.addAll(List.of("卫青","霍去病","汉武帝","张骞"));
        Iterator<String> it = set.iterator();
        String temp ;
        while(it.hasNext()){
//            //通过迭代器删除值为“汉武帝”的元素
            //易错点：原因是:一次循环，应该是一次指针后移
            //这样不仅判断的元素少了，输出的元素也少了
//            if("汉武帝".equals(it.next())){
//                it.remove();
//                continue;
//            }
//            System.out.print(it.next());
            temp = it.next();
            if("汉武帝".equals(temp)){
                it.remove();
                continue;
            }
            System.out.println(temp);
        }
        //HashSet.toString();
        System.out.println(set);
    }

    //补充  List用迭代器删除元素

    public static void testIterator(){
        ArrayList<String> list1 = new ArrayList();
        LinkedList<String> list2 = new LinkedList();
        list1.addAll(List.of("卫青","霍去病","汉武帝","张骞"));
        list2.addAll(List.of("卫青","霍去病","汉武帝","张骞"));
        Iterator<String> it = list1.iterator();
        String temp;
        while(it.hasNext()){
            temp = it.next();
            if("汉武帝".equals(temp)){
                it.remove();
                continue;
            }
            System.out.println(temp);
        }
        System.out.println("-----------------------------");
        it = list2.iterator();
        while(it.hasNext()){
            temp = it.next();
            if("汉武帝".equals(temp)){
                it.remove();
                continue;
            }
            System.out.println(temp);
        }
    }

    public static void test4(){

        List<String> list = List.of("卫青","霍去病","汉武帝","张骞");
//        list.remove(0);
// 不能删除；原因是相当于 List.of("卫青","霍去病","汉武帝","张骞").remove()
        Iterator<String> it = list.iterator();
//        while(it.hasNext()){
//            it.next();
//            it.remove();
//        }
//      //也不能用迭代器删除,迭代器根据对象来的

        list = Arrays.asList(new String[]{"卫青","霍去病","汉武帝","张骞"});
//        list.remove(0);
// 相当于 Arrays.asList(new String[]{"卫青","霍去病","汉武帝","张骞"}.remove()
        it = list.iterator();
//        while(it.hasNext()){
//            it.next();
//            it.remove();
//        }
        //不能删除

        //解决办法，拷贝值,类似字符串处理字符数组

        list = null;
        list.addAll(List.of("卫青","霍去病","汉武帝","张骞"));
        list.remove(0);
        list.addAll(Arrays.asList(new String[]{"卫青","霍去病","汉武帝","张骞"}));
        it = list.iterator();
        while(it.hasNext()){
            it.next();
            it.remove();
        }

        //总结：
        //1、容器是一个独立的存储空间，起到存储元素的作用；
        //2、容器操作可以是容器整体的操作，如addAll，removeAll;也可以是元素的操作，添加，查看（set不可以），删除，修改（set不可以），
        //3、添加是拷贝值
        //4、赋值是共用地址
        //5、迭代器可以实现遍历修改，操作

    }

    //总结，只要容器是可变的的，那么就能删除，也就能用迭代器删除。
    //即容器可以按照可变长，不可变长分类。

    //HashSet其它操作
    public static void test5(){
        HashSet<Integer> set = new HashSet<>();
        //包含元素AAA吗?
        System.out.println(set.contains(1));

        //包含一批元素（容器AAA）吗?
        System.out.println(set.containsAll(List.of("汉武帝", "卫青")));

        //容器是空的吗？
        System.out.println(set.isEmpty());

        set.addAll(List.of(1,2,3,4,5));

        //克隆给数组的操作，
        //问题是，是共用地址，还是在数组原有的里面修改。
        Integer[] test = new Integer[set.size()];//分配合适空间
        Integer[] copy = set.toArray(test);
        System.out.println(Arrays.toString(test));
        test[2] = 6666;
        System.out.println(Arrays.toString(test));
        System.out.println(set);//发现是克隆
        System.out.println(copy==test);//true 返回数组就是实际参数

        //那么如果空间不够，或者空间更多什么结果

//        Integer[] test2 = null;//空指针异常
        Integer[] test2 = new Integer[1];
        copy = set.toArray(test2);
        System.out.println(Arrays.toString(test2));//null
        System.out.println(copy==test2);//false  返回数组是new出来的数组
        Integer[] test3 = new Integer[10];
        copy = set.toArray(test3);
        System.out.println(Arrays.toString(test3));//[1, 2, 3, 4, 5, null, null, null, null, null]
        System.out.println(copy==test3);//true

        //如果空间不够，不会拷贝重新分配一个数组
        //返回值T[] 是一个拷贝后的数组

//        test3 = (Integer[])set.toArray();//这个方法返回值是Object[]数组，
        //Object[]数组是对象，对象之间非继承，实现关系不能强制类型转换。
        //Object[]并不是Integer[]的父类
        Object[] obj = set.toArray();
        copy = new Integer[obj.length];
        for(int i=0;i<obj.length;i++){
            System.out.println(obj[i]);
            copy[i] = (Integer) obj[i];
        }

        System.out.println(Arrays.toString(copy));
    }

    public static void main(String[] args) {
//        test1();//普通添加
//        testIntegerSet();//添加包装类
//        testStringSet();//添加字符串
//        testUserSet();//添加普通类
//        testCharArr();//字符串和字符数组补充
//        test2();//Hash其它操作，删除，
//        test3();//通过迭代器删除
//        testIterator();//练习其它容器的迭代器
//        test4();//探究什么时候可以删除元素，可变长容器。
        test5();//其它操作
//        Map.Entry
    }
}


class User implements Comparable<User> {

    //没有用
    @Override
    public int compareTo(User o) {
        return -1;
    }

    //没有用
    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

1.3 HashMap存储探究和LinkedList 容器练习

package cn;

//练习Set --- HashSet -- 其实也就是HashMap
//练习list --- LinkedList
/*
*
* 深入理解 HashSet和LinkedList和ArrayList
* 结论：1.HashMap内部应该是散列存储。
* 2.LinkedList是双向循环链表
* 3.ArrayList是一个变长数组。
*
* */

import java.util.*;


public class Test {
    //hash，散列存储，查找，冲突处理
    public  static void test1(){
        // java.util包下
        // Collection --- Set --- HashSet
        Set<String> set = new HashSet<>();
//        set.addAll(List.of("A","B","C","D","E","F"));
//        set.addAll(List.of("AA","BB","C","D","E","F"));
        set.addAll(List.of("AAA","BBB","C","D","E","F"));
//        set.addAll(List.of("AAAA","BBBB","C","D","E","F"));
//        set.addAll(List.of("AAAAA","BBBBB","C","D","E","F"));
//        set.addAll(List.of("AAAAAA","BBBBB","C","D","E","F"));
        set.addAll(List.of("a","b","c","d","e","f"));
        set.addAll(List.of("4","5","6","7","8","9"));

        System.out.println(set);

        List<String> arraylist = new ArrayList<String>(set);
        arraylist.sort((a,b)->-a.compareTo(b));
        System.out.println(arraylist.toString());
        set.clear();
        set.addAll(arraylist);
        System.out.println(set);

        //排序机制
        //简单的：
        //1.如果addAll的顺序一定那么内部的顺序和原来可以不同，但是唯一。
        //其它
        //1.调整addAll的顺序可能set的顺序一样，也可能不一样
        //结论
        //1.取决于元素，也取决于元素添加顺序，取决于相同值元素个数(hash值相同时，往后走可能占下一个元素位置。)
        //      1.有些元素一定在一些元素前面；元素个数比较少，位置足够时
        //      2.有些元素先添加后添加相对位置不一样。
        //      3.如果元素足够多，占相同位置，那么为了让所有元素都存下，所以会有一定算法。
        //处理冲突的方法：用一个链表存放相同位置元素，链表超过一定长度变为红黑树。
        //总结：1、有排序.但是这个排序规则我们不知道，也不需要知道2、存在冲突处理、使用的是红黑树，能处理大量数据。 53         //3、hashmap 查找，添加，删除效率很高。
    }

    //链表集合 java.util.LinkedList;
    //remove()方法和List不匹配。
    /*
    *数据结构：
    *利用LinkedList模拟栈和队列的数据结构
    *
    * */
    public static void test2(){
        //模拟栈的存储结构  --- 就不用递归了，可以无限查找。
        LinkedList<String> list = new LinkedList<>();
//        List<String> list = new LinkedList<>();//不要写成这样，这是一个队列
        //内部是一个双向循环链表.
        //默认在尾添加，从头删除，类似一个栈。所以不能用它直接来模拟栈，但是可以模拟队列。
        //使用addFirst() + remove()模拟栈，
        list.addFirst("李四");
        list.addFirst("张三");
        list.addFirst("王五");
        list.addFirst("李四");//元素可以重复
        if(list.getFirst()==list.getLast()){
            System.out.println("没有额外开辟内存，共用地址");
            //1.因为是共用地址，所以可能会有修改的问题。
            // 遍历时理论上不会重复除了字符串特殊的
            //2.效率很高
        }
        //出栈：
        while(!list.isEmpty()){
            String temp = list.remove();
            System.out.println(temp.toString());
        }
        //模拟队列
        LinkedList<String> list1 = new LinkedList<>();
        list1.add("李四");
        list1.add("张三");
        list1.add("王五");
        list1.add("李四");//元素可以重复

        while(!list1.isEmpty()){
            String temp = list1.remove();//参数是boolean类型 用于判断是否更改，废话，
            System.out.println(temp.toString());
        }

        //其它方法 Collection
        //同样是在最后面添加
        list1.addAll(List.of("A","B","C","D","E","F","G"));
        //最后面添加一个元素
        list1.addLast("A");//和add()一样
    }

    //迭代器遍历
    /*
    * 迭代器内部实现是一个带有头结点的单向链表
    *       1、便利的始终是next，下一个元素。 具体方法，hasNext(),next();
    *               hasNext()，看看下一个元素是否非空。
    *               next()返回下一个元素值，并且指针自动后移一位
    *       2、删除当前元素，remove，可能对有些迭代器不适用。这里没有演示
    * */
    public static void test3(){
        LinkedList<String> list1 = new LinkedList<>(List.of("张三","李四","王五","赵六","算法"));

        Iterator<String> iterator = list1.iterator();
        System.out.println(iterator.getClass());
        while(iterator.hasNext()){
            String temp = iterator.next();
            System.out.println(temp);
        }

    }

    //其他操作
    //1、添加/插入,（1）最后添加：add(E);addLast(E);addAll(Collection<E>) (2)第一个位置插入:addFirst(E) （3）某一个位置插入元素add(index,E); addAll(index,collection<E>)
    //2、删除,(1)删除第一个位置元素 remove(),removeFirst();(2)删除最后一个位置元素，removeLast(3)删除某一位置元素remove(index)(4)删除某个元素remove(Obj)(5)删除一群元素removeAll(Collection);
    //3、修改,(1)修改set(index,E)(2)清空clear();
    //4、查找,(1)查找第一个元素，getFirst()(2)查找最后一个元素getLast()(3)查找某个位置元素get(index);
    //5、将其它Collection容器变为LinkedList 构造方法，或者清空之后，addAll（）;
    //LinkedList的插入，删除速度快于ArrayList，但是查找，特别是修改速度很慢，所以必要时候可以将LinkedList转换为ArrayList；

    public static void test4(){
        LinkedList<String> list = new LinkedList<>();
        list.clone();
        //同样是在最后面添加  index=0
        list.addAll(List.of("A","B","C","D","E","F","G"));
        //最后面添加一个元素
        list.addLast("A");//和add()一样
        //toString
        System.out.println(list.toString());
        //长度，得到某个位置元素
        //得到某个位置元素
        System.out.println(list.get(list.size() - 1));
        //得到第一个位置元素
        System.out.println(list.getFirst().toString());
        //得到最后一个元素
        System.out.println(list.getLast().toString());
        //是否含有某个元素  --- 和地址无关
        System.out.println(list.contains("A"));//true
        System.out.println(list.contains(new String("A")));//true
        //查找某个元素位置
        System.out.println(list.indexOf("B"));
        System.out.println(list.lastIndexOf("A"));
        System.out.println(list.lastIndexOf("aaa"));
        //删除某个元素
        list.remove("AAA");
        list.remove(1);


    }

    public static void main(String[] args){
        test4();
    }
}

1.5 HashSet模拟

package com.testhashset;

//HashSet底层是一个HashMap
//也就是说HashSet添加删除，查看都是通过HashMap实现的，那么它是怎么实现的？


import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

/*
*
* 启发：
* 1、容器套容器案例(一个容器的成员属性可以是容器）
*       用一个map作为实际存储容器。
*       需要理解map的用法
* 2、
*
* */

public class Test {

    //构造方法--实际是map的方法
        //1.构造时，对应初始化存储容器 map
        //2.有一个Object类私有最终常量，用于map添加元素

    public static void test(){
        //无参初始化
        HashSet<String> mySet = new HashSet<>();
        //设置初始容量大小
        HashSet<String> mySet1 = new HashSet<>(10);
        //拷贝一个实例化容器
        HashSet<String> mySet2 = new HashSet<>(mySet1);
        //
        HashSet<String> mySet3 = new HashSet<>(10,10.1f);

        Object temp = new Object();

        //无参初始化
        HashMap<String,Object> myMap = new HashMap<>();
        HashMap<String,Object> myMap1 = new HashMap<>(10);
        //HashSet里面的map只能一个一个添加
        //HashSet参数是一个实例化map
        HashMap<String,Object> myMap2 = new HashMap<>(myMap);
        HashMap<String,Object> myMap3 = new HashMap<>(10,10.1f);

    }

    //Hashset add/addAll添加操作
    //其实就是map的put操作
    //Hashset add返回值类型是boolean，表示是否成功添加
    //Hashmap  put返回值类型是一个V,返回原来对象
    //Hashset addAll 返回值是boolean ，表示是否至少添加一个元素

    public static void test1(){
        HashSet<String> set1 = new HashSet<>(10);
        Object obj = new Object();
        HashMap<String,Object> myMap = new HashMap(10);

        System.out.println(set1.add("张三"));//true
        System.out.println(myMap.put("张三", obj)==null);//false
        System.out.println(set1.add("张三"));//false
        System.out.println(myMap.put("张三", obj)==null);//false

        System.out.println(set1.addAll(List.of("李四", "张三")));//true
        boolean flag = false;
        for (String s :List.of("李四","王五","赵六")){
            flag = flag||myMap.put(s, obj)==null;
        }
        System.out.println(flag);//true
    }

    //Hashset remove()removeAll()删除操作 clean()清空
    //其实就是map的remove clean()清空操作

    public static void test2(){
        HashSet<String> set = new HashSet<>(10);
        Object obj = new Object();
        HashMap<String,Object> map = new HashMap(10);
        set.add("张三");
        map.put("张三",obj);

        System.out.println(set.remove("张三"));//true
        //就是通过key删除
        System.out.println(map.remove("张三")==null?false:true);//true

        set.addAll(List.of("张三","李四"));
        System.out.println(set.removeAll(List.of("张三", "李四", "王五")));//true

        for (String s :List.of("张三","李四")){
            map.put(s,obj);
        }

        //不能直接删除一群，只能一个一个操作

        boolean flag = false;
        for (String s :List.of("张三", "李四", "王五")){
            flag = flag||map.remove(s)!=null;//true
        }
        System.out.println(flag);//true

        set.clear();
        map.clear();
    }

    //HashSet contains() containsAll()方法
    //也是map的对key的操作
    //同样不能一次判断群

    public static void test3(){
        HashSet<String> set = new HashSet<>(10);
        Object obj = new Object();
        HashMap<String,Object> map = new HashMap(10);
        set.add("张三");
        set.addAll(List.of("李四","王五"));
        map.put("张三",obj);
        for (String s :List.of("李四","王五")){
            map.put(s,obj);
        }

        //判断是否包含某个元素
        System.out.println(set.contains("张三"));//true
        System.out.println(map.containsKey("张三"));//true


        boolean flag = true;
        //判断是否包含一群元素，必须都有
        for (String s :List.of("张三", "李四", "王五")){
            flag = flag&&map.containsKey(s);
        }
        System.out.println(set.containsAll(List.of("张三", "李四", "王五")));//true
        System.out.println(flag);

        flag = true;
        System.out.println(set.containsAll(List.of("张三", "李四", "王五", "赵六")));//false
        for (String s :List.of("张三", "李四", "王五", "赵六")){
            flag = flag&&map.containsKey(s);
        }
        System.out.println(flag);//false

    }

    //HashSet不存在修改操作,HashMap也不存在修改

    public static void main(String[] args) {
//        test();//构造方法测试
//        test1();//add/addAll方法模拟
//        test2();//remove/removeAll方法模拟
        test3();
    }
}

 1.6HashMap效率测试

package com.testhashmap;

/*
*
* HashMap存储结构用在HashSet里面了。
*
* 1、概述：
*       1、数组的散列存储能够实现通过关键字找到值，但是随着元素个数增加，冲突概率增加，产生冲突需要解决，否则影响查找，
*           冲突解决可以采用拉链法，建立一个链表存储多余元素
*       2、但是链表查找效率低，于是有了红黑树。在链表个数超过一定数量的时候链表会变成一个红黑树，有了红黑树，我丝毫看不到链表的优势，除了实现简单。
* 2、怎么证明确实是
*       1、哈希函数
*       2、冲突处理
*       3、红黑树。
*
*       方法，通过比较LinkedList,ArrayList 增删改查的时间，估算用的是什么了。
*
*
* */

import java.util.*;

public class TestHashMap {
    public static void  test1(){
        HashMap<User,Integer> map = new HashMap<>();
        ArrayList<User> list1 = new ArrayList<>();
        LinkedList<User> list2 = new LinkedList<>();

        //首先是10000个作为初始化的元素
        for(int i =0;i<10000;i++){
            list1.add(new User());
            map.put(new User(),i);//无所谓，也可以单独拿出来写
        }
        //拷贝list1
        list2.addAll(list1);

        //插入的用时对比---就拿添加为例，因为map只有put

        //100000次
        long begin = System.currentTimeMillis();
        for(int i = 0;i<100000;i++){
            map.put(new User(),i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        for(int i = 0;i<100000;i++){
            list1.add(new User());
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        for(int i = 0;i<100000;i++){
            list2.addLast(new User());
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);

        //list并不一定每次都是在最后面添加
        //这里添加10万个Hashmap用时52毫秒，速度已经很好了
        //那么先试一下让list随机插入的后果。 就在10000的位置插入

        for(int i = 0;i<100000;i++){
            list1.add(10000,new User());
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin); //
        begin = System.currentTimeMillis();
        for(int i = 0;i<100000;i++){
            list2.add(10000,new User());
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);//
        begin = System.currentTimeMillis();
        for(int i = 0;i<100000;i++){
            map.put(new User(),i);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);//

        //总结如果是每次都是在最后面添加那么不用考虑了，数组Arraylist
        //如果数据量很大，别用ArrayList和LinkedList,最少不要用LinkedList
        //HashMap还是一如既往的稳定 31毫秒
    }

    public static void test2(){
        //补充元素150000
        HashMap<Integer,Integer> map = new HashMap<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        LinkedList<Integer> list2 = new LinkedList<>();
        for(int i =0;i<150000;i++){
            list1.add(i);
            map.put(i,i);
        }
        list2.addAll(list1);

        //删除 10000 - 100000的元素
        long begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            map.remove(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-begin);

        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list1.remove(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list2.remove(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);


        begin = System.currentTimeMillis();
        map.clear();
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        list1.clear();
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        list2.clear();
        end = System.currentTimeMillis();
        System.out.println(end-begin);
    }
    //一言难尽

    //查找 -- 找某个位置的元素应该是ArrayList快

    public static void test3(){
        HashMap<Integer,Integer> map = new HashMap<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        LinkedList<Integer> list2 = new LinkedList<>();
        for(int i =0;i<150000;i++){
            list1.add(i);
            map.put(i,i);
        }
        list2.addAll(list1);

        //查找 10000 - 100000的元素
        long begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            map.containsKey(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-begin);

        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list1.contains(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list2.contains(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
    }
    //总结：Hash是真的牛，全能，显然就是用了Hash函数+红黑树（难点）
    //删除和查找，LinkedList就离谱，越来越菜。

    //神装大佬吊打2个小弟

    //修改操作
    public static void test4(){
        HashMap<Integer,String> map = new HashMap<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        LinkedList<Integer> list2 = new LinkedList<>();
        for(int i =0;i<150000;i++){
            list1.add(i);
            map.put(i,"1");
        }
        list2.addAll(list1);

        long begin = System.currentTimeMillis();
        Set<Integer> integers = map.keySet();
//        for(int i = 100000;i>=10000;i--){
//
////          String temp =  map.get(i); temp = " "+i;//因为String类型和包装类存在自动包装机制，所以难为它了
//
//        }
        //由于没有合适方法，内部还是通过迭代器一个一个找，所以这一轮认输算了。
        //再试一下
        //entries 是一个Set容器，但是元素也是一个容器，
//        Set<Map.Entry<Integer, String>> entries = map.entrySet();
//        for(int i = 100000;i>=10000;i--){
//
//        }
        //迭代器--这样就慢了
        //突然发现迭代器也改不了,


        long end = System.currentTimeMillis();
        System.out.println(end-begin);

        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list1.set(i,i+1);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list2.set(i,i+1);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
    }
    public static void test5(){
        HashMap<Integer,User> map = new HashMap<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        LinkedList<Integer> list2 = new LinkedList<>();
        for(int i =0;i<150000;i++){
            list1.add(i);
            map.put(i,new User());
        }
        list2.addAll(list1);

        long begin = System.currentTimeMillis();
        Set<Integer> integers = map.keySet();
        for(int i = 100000;i>=10000;i--){
            map.get(i).value = i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end-begin);

        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list1.set(i,i+1);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
        begin = System.currentTimeMillis();
        for(int i = 100000;i>=10000;i--){
            list2.set(i,i+1);
        }
        end = System.currentTimeMillis();
        System.out.println(end-begin);
    }

    public static void main(String[] args) {
//        test1();//添加和插入测试，
//        test2();//删除测试
//        test3();//查找测试
        test5();
    }
}

//随意定义一个类，这个类存值。

class User{
    public int value;
//    public String value;
}

2.1 TreeMap练习1

package com.day17;

import java.util.TreeMap;

public class TestTreeMap {
    //key是有序的，当然也是唯一的。
    public static void test1( ){
        //String类的比较器
        TreeMap<String,String> map1 = new TreeMap<>();
        map1.put("1","1");
        map1.put("2","1");
        map1.put("3","1");
        map1.put("4","1");
        map1.put("5","1");
        map1.put("11","1");
        map1.put("111","1");
        map1.put("1111","1");
        map1.put("11111","1");
        //{1=1, 11=1, 111=1, 1111=1, 11111=1, 2=1, 3=1, 4=1, 5=1}
        System.out.println(map1);
    }

    public static void testComparable(){
        TreeMap<Student,String> map1 = new TreeMap<>();
        Integer i = 1;
        for(;i<=10;i++){
            try {
                map1.put(new Student(i,i.toString()),i.toString());
            }catch (ClassCastException e){
                System.out.printf("添加第%d个元素异常%n",i);
            }
        }
        System.out.println(map1);
    }
    public static void main(String[] args){
//        test1();
        testComparable();
    }


    //原理就是一个比较器。不能排序的（Comp没有给我们默认实现）自己写排序，
    //乱序--二分排序，（数组）
    //怎么让自定义类型排序
        //初始化时传递Comparator接口实现类--
            //--初始化可以初始化常量
            //comparator.compare(k1, k2) 不能为映射中的任何键 k1 和 k2 抛出 ClassCastException(强制类型转换异常)
        //初始化不初始化接口实现类
            //插入map的所有键（KEY）必须实现可比较的接口Comparable<Student>。
            // 此外，所有这些键必须相互可比：k1.compareTo（k2）不能为映射中的任何键k1和k2抛出ClassCastException。

}


class Student implements Comparable<Student>{
    private int id;
    private String name;
    Student(){

    }
    Student(int id, String name){
        this.id = id;
        this.name = name;
    }
    @Override
    public int compareTo(Student o) {
        if(o==null){
            return -1;
        }
        return this.id-o.id;
    }
    @Override
    public String toString(){
        return "{"+this.id+","+this.name+",}";
    }
}

2.2TreeMap练习2Map集合遍历

package com.testtreemap;

import java.util.*;
import java.lang.String;
public class TestTreeMap {
    //HashMap已经神装了，干嘛还要TreeMap
    //TreeMap有什么特有的
            //发现内部有一个比较器，优化了红黑树的比较，也就是说这次是真的可以随心所欲实现没有重复值了
            //key一样时，后者value替代前者,但是key地址就不替代了。

    //构造方法，比较器
    //添加元素
    public static void test1(){
        //说明：
        //1、String类已经实现了Comparable<String>接口（自然比较器,可以比较的，不要把接口名字写错误，），所以它有接口方法compareTo(String);
        //2、强制类型转换。我可以变成接口实现类啊，用接口实现类就是用我。我是多种实现的一个。
//        TreeMap<String, Integer> map = new TreeMap<>((a,b)->a.compareTo(b));
        //因为方法中存在的强制类型转换，所以没有必要写
        TreeMap<String,Integer> map = new TreeMap<>();
        map.put("张三",1);
        map.put("李四",2);
        map.put("王五",3);
        map.put("张三",4);
        //相同key时，后面的或默认把前面的value覆盖了
        //这点不同于HashMap
        System.out.println(map);
    }

    //添加一群元素

    public static void test2(){
        TreeMap<String,Integer> map = new TreeMap<>();
        //果然，map也可以putall
        map.putAll(Map.of("张三",1,"李四",2));

    }


    //Treemap集合遍历
    //也适用于HashMap

    //Map.Entry内部类
    /*
    *
    * 1、Map.Entry就是实例化Map的类的元素类型，所有Map.Entry的具体集合组成了Map集合。
    * 猛一下子没有明白过来。
    *       内部类就是专门定义的数据结构（类型+操作）。
    * 2、迭代器泛型元素类型的就是集合元素类型。
    *       迭代器就是容器本身产生的为了遍历元素用的，所以类型应该匹配。
    *第一次遇到内部类。
    * 易错点：
    * 1.认为Map.Entry是一个类似Map一样的容器。
    *       原因：没有正确理解泛型，理解容器。
    *           并不是泛型类并不一定是容器，容器也不一定是泛型的。
    *案例
    * 迭代器（流技术）有点像数据库中的resultSet
    *
    * */

    public static void test3(){

        TreeMap<String,Integer> map = new TreeMap<>();
        map.putAll(Map.of("张三",1,"李四",2,"王五",3,"赵六",4));
        //通过迭代器遍历
        Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<String, Integer> entry = it.next();
            System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
        }
        //通过TreeMap的keySet()方法
        //返回值是key的集合，类型是Set集合，
        // Set是一个接口，实际对象是TreeMap返回的一个Set接口的实例化对象。
        Set<String> keys = map.keySet();
        Iterator<String> it1 = keys.iterator();
        //遍历所有key对象。
        while(it1.hasNext()){
            System.out.println("key="+it1.next());
        }

        //通过TreeMap的Values()
        //返回是一个values集合,类型是Collection
        //Collection也是一个接口，实际对象是TreeMap返回的一个Collection 接口的实例化对象。
        Collection<Integer> values = map.values();
        Iterator<Integer> it2 = values.iterator();
        //遍历所有values对象
        //自动拆箱
        while(it2.hasNext()){
            System.out.println("value="+it2.next());
        }

        //也可用for：in语句，也可遍历容器
        for (int i:values){
            System.out.println("value="+i);
        }

        for(String key:keys){
            System.out.println("key="+key);
        }
    }

    public static void main(String[] args) {
//        test1();
//        test2();
        test3();
    }
}

 

补充 1.TreeMap内部排序机制模拟

package cn;

import java.util.Comparator;

public class FX2 <E>{

    public E[] es;
//    Comparable comparable=null;// 易错点，不能要这个，不能两个数比较
    private final Comparator<E> comparator;

    //方法中可以直接用?，更加灵活
    FX2(){
        comparator = null;
    }

    FX2(Comparator<E> comparator){
        this.comparator = comparator;
    }


    //冒泡排序
    //升序
    void sort(){
        if(es==null||es.length==0){
            return;
        }
        if(comparator!=null){
            boolean flag=false;
            for (int i=0,len=es.length;i<len;i++){
                flag=true;
                for (int j =0;j<len-i-1;j++){
                    if (comparator.compare(es[j],es[j+1])>0){
                        flag = false;
                        E e = es[j];
                        es[j] = es[j+1];
                        es[j+1] = e;
                    }
                    if (flag){
                        break;
                    }
                }
            }
        }
        else{
            System.out.println(es[0] instanceof Comparable);
            //强制类型转换可能存在异常  -- 或者判断一下es是否是
            try {
                System.out.println((Comparable) es[0]);
            }
            catch(ClassCastException e){
                e.printStackTrace();
                System.out.println("强制类型转换异常，您传递的类没有实现Comparable接口，请实现接口，或者在传递比较器");
                return ;
            }

            boolean temp = false;
            for (int i = 0,len = es.length;i<len;i++){
                temp = true;
                for (int j = 0;j<len-1-i;j++){
                    if(((Comparable)es[j]).compareTo(es[j+1])>0){
                        temp = false;
                        E t = es[j];
                        es[j] = es[j+1];
                        es[j+1] = t;
                    }
                }
                if(temp){
                    break;
                }
            }
        }
    }

}

 

补充：

1.Map实现类虽然不能修改，但是可以添加key相同的元素达到修改。

2.Map的元素类型是Map.Entry

3.HashMap操作是以key的HashCode，和equals方法为基础的

 

个人总结

1、TreeMap它的特点是什么，它是怎么实现的？
    TreeMap；
    特点：
    1、继承抽象类AbstractMap，抽象类继承Map接口,是一个实例化对象。
    2、有一个私有的，常量成员属性 Comparator类型的自然比较器comparator。
         即：private final Comparator<? super K> comparator;
    3、key顺序可控。
    实现原理：
       控制put
        1、通过私有常量比较器接口通过比较每一个对象，如果对象和已有对象值相等那么就会覆盖前面的value保证key不会重复
        多态--使用接口就是使用实现类
        a、可以在初始的时候传递实例化对象，给接口赋值。这样用接口就使用实例化对象的方法。
        b、key类可以实现Comparable<E>接口，这样添加元素的时候会自动使用key
           a、b确实有，它内部通过if else实现了。

        反之，如果不仅没有在初始时候初始化化是有最终比较器接口（手动赋值为null），而且Key也没有实现接口
        那么比较器是自动调用的，put会抛出类转换异常ClassCastException
            如果key实现了比较器，且初始化传递了参数，那么会先用初始化的比较器，内部的就不用了。

2、HashSet存储利用了HashMap，为什么要用到HashMap，它的特点是什么？应用场景
    2.1
    1、HashMap实现了Map接口，1、采用数值（散列存储）+链表/红黑树（冲突处理）快速实现存取，删除，查找。2、Key值不能重复（HashMap相同地址的元素后者Value覆盖前者，但是key地址不覆盖），所以Key元素还是保留前者。
    2、HashMap实现原理不同于TreeMap，操作起来更加简单。

    HashSet用HashMap数据结构后能干什么？
    可以利用Hash存储结构存放元素，
    可以利用HashMap的操作实现删除，添加， 查找。

    2.2
    HashMap实现原理
        1、散列存储
                关键字，存储地址，存储表（容器）
                1、散列函数的定义域必须包含全部需要存储的关键字，值域范围依赖于散列表的大小或地址范围
                2、散列函数计算出来的地址应该能等概率、均匀地分布在整个地址空间，减少冲突发生。
                3、散列函数应尽量简单，能够在较短的时间内计算出任意关键字对应的散列地址
                    hash函数（其中一个）
                        1、直接定址法，没有冲突（线性函数）
                        2、除留余数法（关键），（存在冲突）
                        3、数字分析法，分部不均匀的
                        4、平方取中法
                        5、折叠法

        2、冲突处理，
                拉链法：链表+红黑树
        3、存储顺序/hash函数
            1、一定有序，有序是基础，但是我们不需要研究。
            2、这个顺序并不是A一定在B前面，1一定在2前面，就是和平常排序不同。

    2.3 HashSet特点
    建立关键字和存储地址的映射关系
    底层使用哈希表实现
    元素不可重复
    排列无序（准确说，应该是其不保证有序。迭代器在遍历HashSet时，大多情况下是无序的，但也可能由于巧合，使其输出恰好为有序，这也是允许的。所以你的程序不应该依赖这个巧合的有序情况，而应该按照无序这种普适的情况进行处理）
    存取速度快
    线程不安全

    2.4HashSet应用场景
        集合，元素不能重复，
    String，包装类都会自动打包

3、LinkedList容器内部机制，它的特点是什么？
    LinkedList是一个双向循环链表
    插入删除快，可以模拟数据结构栈和队列，
4、ArrayList容器内部机制，它的特点是什么？
    ArrayList是一个变长（动态）数组
    随机存储，比较灵活，数值长度可变，但是删除，插入用时比较长。
5、HashMap存储原理，它的特点是什么？
    存储原理见2.
    特点
    1、key上元素不能重复，否则保留前者key值，后者value值替代前者。
    2、插入，删除，查找速度都很快

6、简述一下迭代器的特点和作用。
    特点：
    1、每个容器实现类都可返回一个迭代器，迭代器我们就不用new了。
    2、利用了流技术，一般只能往后遍历。
    3、迭代器也用到了泛型。元素类型就是容器元素类型。

    作用
    1、迭代器的作用是帮助容器快速遍历，查找，删除元素。

7、简述一下Map.Entry内部类的特点和作用。
    7.1特点：
    1、是Map接口的内部类。
    2、利用泛型，但不是容器。

    7.2
    1、专门为所有Map对象定义的一个数据结构，方便内部成员使用。
    2、一个元素不仅存储了key值，还同时存储了value值
        可同时对key，value操作。

8、一个异常
ClassCastException//类型转换异常，
出现原因：
1、泛型中设置了，强制类型转换失败，
2、既没有实例化比较器，也没有实现Comparable接口

2022/9/23
集合遍历
　　第一种方式：迭代器
　　第二种方式：内置的方法，foreach方法
　　第三种：可以利用流
　　第四种：可以用for:in循环，
总结：
1.时刻记住遍历的底层元素是谁就行了，还有就是记住转换关系
　　底层元素就是泛型指定的元素
2.Map遍历的需要先变为Set<Map.Entry<Key,Value>>：然后按照遍历Set集合的方式遍历元素。不能直接遍历元素
3.Set,List遍历元素类型就是泛型的元素类型，可以直接遍历元素。


集合和mybatis
　　list集合作为方法返回值
　　List集合作为返回值可以接收多行查询的结果（List集合遍历，添加元素速度最快，并且是一个长度可变的数组）
　　map集合作为方法的返回值，
　　map元素是键值对，所以map可以看做抽象的实体类

集合和ajax请求
　　作为参数
　　Map可以作为参数，作用等同于实体类，非常灵活
　　作为返回值
　　map集合返回给前端，前端收到的是一个json对象。这和传统的字符串不一样，非常方便。 key和Value类型都是Object
　　list集合返回给前端，前端收到的是一个Object数组。
总结：map，list是一个非常好的数据结构，