Java集合：Collection and Map；ArrayList；LinkList；HashSet；TreeSet；HashMap；TreeMap；Iterator：集合迭代器

        集合介绍：

                        是一组变量类型（容器），跟数组很像。

一，引用集合的原因（必要性）：

                    A：数组的空间长度固定，一旦确定不可以更改。多了浪费，少了报错。
                    B：使用数组操作数据时，效率较低。
                   C:无法获得数组中存储的真实元素个数。
                   D:数组增加删除元素效率低。
                   F:数组没办法满足，无序，不可重复的数据。

二，集合分类：

           Collection：  

                                

            map ： 

三，集合常用实现类介绍：

1，ArraryList：

                 没有自己特有方法（只有父类方法）
         
                 ArraryList：底层源码是数组： 数组空间大小初始值默认是10；当初始空间满后，以1.5倍的空间大小扩增。（变成新数组，新数组是旧数组的1.5倍。）
                                                                                                                                                                        优势：随机访问和遍历的效率高（因为下标）；
                                                                                                                                                                        缺点： 增加和删除效率较低。

   介绍：Vetor（老版本集合：） 

2， LinkList：

                        底层是Linked链表结构。       

                                   优势：擅长做删除和增加操作。内存使用率比较高。    
                                   缺点：随机访问和遍历的效率低；

3， hashSet：
       

                    存储无序唯一元素

                   底层实现是Hash表
                   hashSet的去重原理：

                                         （比较传入对象的属性是否相同） 借助当前元素对象的两个方法：HashCode（），Equals():（重写）首先获得要存入元素的hash值，通过传入的hash值依次比较已有的元素的hash值，如果hash值不同，直接将元素存入集合。 如果hash值相同，再使用equals（）进行两个hash值相同的对象的属性比较。如果属性都相同，拒绝存入集合，如果属性不相同，存入集合。
                  所以想使用HashSet，要对equals和hashCode重写。符合去重原理。

   4，TreeSet：                         

                         存储有序唯一元素。（有序，不是指先进先出的顺序，指根据某个规则进行排序，正序，倒序 a对应97）
                      介绍treeSet的去重排序原理：

                                                   利用比较器对象的比较方法，将要存入的元素与想要存入的元素依次比较如果比较结果为认为是形同元素，如果结果为1，认为是不同元素，且存入比较元素的前方。如果比较结果为-1，认为是不同元素，且结果靠后。

   5，HashMap：

                        HashMap:是Java中最常用的实现了 Map 接口的类之一，它提供了基于键值对存储和快速访问数据的功能。

                        特点：
                                键值对存储：HashMap 存储数据以键值对的形式，其中键唯一，值可以重复或为 null。

                                 无序性：HashMap 不保证键值对的顺序，即不按照任何特定顺序来迭代元素。

                                允许 null 键和 null 值：HashMap 中可以存储 null 值，也可以有一个 null 键。

                                高效的插入和查找操作：HashMap 基于哈希表实现，插入和查找操作的平均时间复杂度为 O(1)，假设哈希函数良好且负载因子适中。

                                 非线程安全：HashMap 不是线程安全的，如果需要在多线程环境中使用，可以考虑使用 ConcurrentHashMap

                      比较HashTable和HashMap： 

6，TreeMap：

                                TreeMap 是 Java 中实现了 SortedMap 接口的类，它基于红黑树（Red-Black tree）实现，用于存储键值对，并且能够根据键进行排序。

                                特点：
                                        有序性：TreeMap 中的键值对是按照键的自然顺序或者通过构造函数提供的 Comparator 进行排序的。默认情况下，键按升序排序。

                                        非线程安全：与 HashMap 类似，TreeMap 也不是线程安全的。如果需要在多线程环境中使用，可以考虑使用 ConcurrentSkipListMap。

                                        不允许 null 键：TreeMap 不允许 null 键，因为它依赖于键的比较或排序。

                                        基于红黑树：TreeMap 的实现基于红黑树数据结构，这种树结构保证了在最坏情况下的时间复杂度为 O(log n)，其中 n 是 TreeMap 中的键值对数量。

                                        支持范围查询：TreeMap 提供了一些方法，如 headMap(), tailMap(), subMap()，允许根据键的范围获取子映射。

四，集合中的方法

         1，集合共有方法     

                

 size()

size() 方法返回集合中元素的数量。

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");

int size = list.size(); // size 等于 3
System.out.println("List size: " + size);

isEmpty()

isEmpty() 方法判断集合是否为空。

Set<Integer> set = new HashSet<>();
boolean empty = set.isEmpty(); // empty 等于 true，因为集合是空的

List<String> nonEmptyList = new ArrayList<>();
boolean notEmpty = nonEmptyList.isEmpty(); // notEmpty 等于 false，因为列表不为空

contains(Object obj)

contains(Object obj) 方法判断集合是否包含指定元素。

Set<String> set = new HashSet<>();
set.add("apple");
set.add("banana");

boolean containsApple = set.contains("apple"); // containsApple 等于 true
boolean containsOrange = set.contains("orange"); // containsOrange 等于 false

clear()

clear() 方法清空集合中的所有元素。

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);

System.out.println("Before clear: " + numbers); // 输出 [1, 2, 3]

numbers.clear(); // 清空列表

System.out.println("After clear: " + numbers); // 输出 []

addAll(Collection  c)

addAll(Collection c) 方法将另一个集合的所有元素添加到当前集合中。

List<String> list1 = new ArrayList<>();
list1.add("apple");
list1.add("banana");

List<String> list2 = new ArrayList<>();
list2.add("cherry");
list2.add("date");

list1.addAll(list2); // 将 list2 的所有元素添加到 list1 中

System.out.println("Combined list: " + list1); // 输出 [apple, banana, cherry, date]

  2，list特有的方法 ： 

                        注：   list的实现类ArrayList 和LinkedList具有list和集合共有的方法。              

创建List：

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");

访问元素：

String fruit = list.get(0); // 获取第一个元素

String fruit = list.get(1); // 获取第二个元素

添加元素：

list.add("date"); // 将元素添加到列表末尾

删除元素：

list.remove("banana"); // 删除指定元素

3，set特有的方法

                注：HashSet和MapSet具有set和集合共有的方法。

创建Set：

Set<String> set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("cherry");

添加元素：

set.add("date");

删除元素：

set.remove("banana");

4，map特有的方法：

创建Map：

Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map.put("cherry", 3);

访问元素：

int value = map.get("apple"); // 获取键为"apple"的值

添加或修改元素：

map.put("date", 4);

删除元素：

map.remove("banana");

四，遍历集合：

1遍历Collection型集合：

public class Test02 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        col.add("abc");
        col.add(9.8);
        //对集合遍历（对集合中元素进行查看）
        //方式1：普通for循环
        /*for(int i= 0;i<col.size();i++){
            col.
        }*/
        //方式2：增强for循环
        for(Object o:col){
            System.out.println(o);
        }
        System.out.println("------------------------");
        //方式3：iterator()
        Iterator it = col.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

2，遍历MAp集合：

//第一种
        Collection<Sutdent> values = map.values();
        Iterator<Sutdent> iterator2= values.iterator();
        while(iterator2.hasNext())
        {
            Sutdent stu=iterator2.next();
            System.out.println(stu);
        }
        //第二种,汇总key值
        Set<Integer> integers = map.keySet();
        Iterator<Integer> iterator1=integers.iterator();
        while(iterator1.hasNext()){
        Integer key=iterator1.next();
        Sutdent stu=map.get(key);
        System.out.println(stu);

    }
        //第三种
        Set<Map.Entry<Integer, Sutdent>> entries = map.entrySet();//汇总键值对Entry:汇总捆绑值。
        Iterator<Map.Entry<Integer, Sutdent>> iterator3 = entries.iterator();
        while (iterator3.hasNext()){
            Map.Entry<Integer, Sutdent> next = iterator3.next();
            Sutdent stu=next.getValue();
            System.out.println(stu);
        }
        //第四种
        Collection<Sutdent> values1 = map.values();
        for (Sutdent stu   :  values1){
            System.out.println(stu);
            /**
             * 增强性for循环，可以在不知道下标的情况下，遍历集合和数组
             * 普通下标，必须知道下标
             * for（集合/数组中元素类型  代号  ：想要遍历的数组/集合）{
             *                    操作代号；
             *                       }
             */
        }
    }