day05-迭代器，数据结构,List,Set ,TreeSet集合,Collections工具类

最新推荐文章于 2024-08-26 12:03:45 发布

桀少_Bigdata

最新推荐文章于 2024-08-26 12:03:45 发布

阅读量197

点赞数

分类专栏： Java进阶文章标签： java

本文链接：https://blog.csdn.net/qq_40908729/article/details/119868497

版权

Java进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

目标：Collection集合的遍历方式。

什么是遍历? 为什么开发中要遍历？
    遍历就是一个一个的把容器中的元素访问一遍。
    开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。

Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
Collection集合的遍历方式有三种:
    （1）迭代器。
    （2）foreach(增强for循环)。
    （3）JDK 1.8开始之后的新技术Lambda表达式(了解)

a.迭代器遍历集合。
    -- 方法：
        public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
        E next():获取下一个元素值！
        boolean hasNext():判断是否有下一个元素，有返回true ,反之。
    --流程：
        1.先获取当前集合的迭代器
            Iterator<String> it = lists.iterator();
        2.定义一个while循环，问一次取一次。
          通过it.hasNext()询问是否有下一个元素，有就通过
          it.next()取出下一个元素。
    小结：
        记住！

目标：Collection集合的遍历方式。

 什么是遍历? 为什么开发中要遍历？
 遍历就是一个一个的把容器中的元素访问一遍。
 开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。

 Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
 Collection集合的遍历方式有三种:
     （1）迭代器。
     （2）foreach(增强for循环)。
     （3）JDK 1.8开始之后的新技术Lambda表达式。

 b.foreach(增强for循环)遍历集合。
     foreach是一种遍历形式，可以遍历集合或者数组。
     foreach遍历集合实际上是迭代器遍历的简化写法。
     foreach遍历的关键是记住格式：
        for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){

        }
    小结：
        foreach遍历集合或者数组很方便。
        缺点：foreach遍历无法知道遍历到了哪个元素了，因为没有索引。

目标：常见的数据结构种类

集合是基于数据结构做出来的，不同的集合底层会采用不同的数据结构。
不同的数据结构，功能和作用是不一样的。

什么是数据结构？
    数据结构指的是数据以什么方式组织在一起。
    不同的数据结构，增删查的性能是不一样的。
    不同的集合底层会采用不同的数据结构，我们要知道集合的底层是基于哪种数据结构存储和操作数据的。
        这样才能知道具体场景用哪种集合。

Java常见的数据结构有哪些?
数据存储的常用结构有：栈、队列、数组、链表和红黑树
    a.队列（queue）
       -- 先进先出，后进后出。
       -- 场景：各种排队。叫号系统。
       -- 有很多集合可以实现队列。

    b.栈（stack）
       -- 后进先出，先进后出
       -- 压栈 == 入栈
       -- 弹栈 == 出栈
       -- 场景：手枪的弹夹。


    c.数组
       -- 数组是内存中的连续存储区域。
       -- 分成若干等分的小区域（每个区域大小是一样的）
       -- 元素存在索引
       -- 特点：查询元素快（根据索引快速计算出元素的地址，然后立即去定位）
               增删元素慢（创建新数组，迁移元素）

    d.链表
       -- 元素不是内存中的连续区域存储。
       -- 元素是游离存储的。每个元素会记录下个元素的地址。
       -- 特点：查询元素慢
               增删元素快（针对于首尾元素，速度极快，一般是双链表）

    e.红黑树
         二叉树：binary tree 永远只有一个根节点,是每个结点不超过2个节点的树（tree） 。
         查找二叉树,排序二叉树：小的左边，大的右边，但是可能树很高，性能变差。
         为了做排序和搜索会进行左旋和右旋实现平衡查找二叉树，让树的高度差不大于1
         红黑树（就是基于红黑规则实现了自平衡的排序二叉树）：
            树尽量的保证到了很矮小，但是又排好序了，性能最高的树。

         红黑树的增删查改性能都好！！！

         这些结构，其实Java早就通过代码实现了，我们要知道有这些结构即可!

目标：ArrayList集合

  Collection集合的体系:
                    Collection<E>(接口)
          /                                                \
       Set<E>(接口)                                         List<E>(接口)
        /                  \                               /                     \                  \
      HashSet<E>(实现类)    TreeSet<E>(实现类)          LinkedList<E>(实现类) Vector(线程安全)     ArrayList<E>(实现类)
      /
     LinkedHashSet<E>(实现类)

  Collection集合体系的特点:
     Set系列集合： 添加的元素，是无序，不重复，无索引的。
         -- HashSet：添加的元素，是无序，不重复，无索引的。
         -- LinkedHashSet：添加的元素，是有序，不重复，无索引的。
     List系列集合：添加的元素，是有序，可重复，有索引的。
         -- LinkedList： 添加的元素，是有序，可重复，有索引的。
         -- ArrayList： 添加的元素，是有序，可重复，有索引的。
         -- Vector 是线程安全的，速度慢，工作中很少使用。

     List集合继承了Collection集合的全部功能，同时因为List系列集合有索引，
     因为List集合多了索引，所以多了很多按照索引操作元素的功能:
     ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！
         - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
         - public E get(int index):返回集合中指定位置的元素。
         - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
         - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回更新前的元素值。
    小结：
        List系列集合有序，可重复，有索引的。
        ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！！
        开发中ArrayList集合用的最多！！
     拓展：List系列集合的遍历方式有：4种。

	List系列集合多了索引，所以多了一种按照索引遍历集合的for循环。
    List遍历方式：
    （1）for循环。
    （2）迭代器。
    （3）foreach。
    （4）JDK 1.8新技术。

目标：LinkedList集合。

 Collection集合的体系:
            Collection<E>(接口)
 /                                       \
 Set<E>(接口)                             List<E>(接口)
 /                                   /                    \               \
 HashSet<E>(实现类)                   LinkedList<E>(实现类) Vector(实现类)  ArrayList<E>(实现类)
 /
 LinkedHashSet<E>(实现类)

 Collection集合体系的特点:
     Set系列集合： 添加的元素，是无序，不重复，无索引的。
         -- HashSet：添加的元素，是无序，不重复，无索引的。
         -- LinkedHashSet：添加的元素，是有序，不重复，无索引的。
     List系列集合：添加的元素，是有序，可重复，有索引的。
         -- LinkedList： 添加的元素，是有序，可重复，有索引的。
         -- ArrayList： 添加的元素，是有序，可重复，有索引的。

 LinkedList也是List的实现类：底层是基于链表的，增删比较快，查询慢！！
 LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的
 所以LinkedList除了拥有List集合的全部功能还多了很多操作首尾元素的特殊功能：
     - public void addFirst(E e):将指定元素插入此列表的开头。
     - public void addLast(E e):将指定元素添加到此列表的结尾。
     - public E getFirst():返回此列表的第一个元素。
     - public E getLast():返回此列表的最后一个元素。
     - public E removeFirst():移除并返回此列表的第一个元素。
     - public E removeLast():移除并返回此列表的最后一个元素。
     - public E pop():从此列表所表示的堆栈处弹出一个元素。
     - public void push(E e):将元素推入此列表所表示的堆栈。

小结：
     LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的。
     所以提供了很多操作首尾元素的特殊API可以做栈和队列的实现。

     如果查询多而增删少用ArrayList集合。(用的最多的)
     如果查询少而增删首尾较多用LinkedList集合。

目标：HashSet集合

Collection集合体系的特点:
 Set系列集合： 添加的元素，是无序，不重复，无索引的。
         -- HashSet：添加的元素，是无序，不重复，无索引的。
         -- LinkedHashSet：添加的元素，是有序，不重复，无索引的。
         -- TreeSet: 不重复，无索引，按照大小默认升序排序!! ( 可排序集合 )
     List系列集合：添加的元素，是有序，可重复，有索引的。
         -- LinkedList： 添加的元素，是有序，可重复，有索引的。底层是基于链表存储数据的，查询慢，增删快
         -- ArrayList： 添加的元素，是有序，可重复，有索引的。底层基于数组存储数据的，查询快，增删慢
研究两个问题(面试热点)：
    1）Set集合添加的元素是不重复的，是如何去重复的？
    2）Set集合元素无序的原因是什么？

目标：Set系列集合元素去重复的流程。

集合和泛型都只能支持引用数据类型。

1.对于有值特性的，Set集合可以直接判断进行去重复。
2.对于引用数据类型的类对象，Set集合是按照如下流程进行是否重复的判断。
    Set集合会让两两对象，先调用自己的hashCode()方法得到彼此的哈希值（所谓的内存地址）
    然后比较两个对象的哈希值是否相同，如果不相同则直接认为两个对象不重复。
    如果哈希值相同，会继续让两个对象进行equals比较内容是否相同，如果相同认为真的重复了
    如果不相同认为不重复。

            Set集合会先让对象调用hashCode()方法获取两个对象的哈希值比较
               /                     \
            false                    true
            /                          \
        不重复                        继续让两个对象进行equals比较
                                       /          \
                                     false        true
                                      /             \
                                    不重复          重复了

    需求：只要对象内容一样，就希望集合认为它们重复了。重写hashCode和equals方法。

小结：
    如果希望Set集合认为两个对象只要内容一样就重复了，必须重写对象的hashCode和equals方法。

目标:Set系列集合元素无序的根本原因。(面试必考)

Set系列集合添加元素无序的根本原因是因为底层采用了哈希表存储元素。

JDK 1.8之前：哈希表 = 数组 + 链表  + （哈希算法）
JDK 1.8之后：哈希表 = 数组 + 链表 + 红黑树  + （哈希算法）
    当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

小结：
    Set系列集合是基于哈希表存储数据的
    它的增删改查的性能都很好！！但是它是无序不重复的！如果不在意当然可以使用！

目标:LinkedHashSet

是HashSet的子类，元素是“有序” 不重复，无索引.

LinkedHashSet底层依然是使用哈希表存储元素的，
但是每个元素都额外带一个链来维护添加顺序！！
不光增删查快，还有序。缺点是多了一个存储顺序的链会占内存空间!!而且不允许重复，无索引。

总结：
     如果希望元素可以重复，又有索引，查询要快用ArrayList集合。（用的最多）
     如果希望元素可以重复，又有索引，增删要快要用LinkedList集合。（适合查询元素比较少的情况，经常要首尾作元素的情况）
     如果希望增删改查都很快，但是元素不重复以及无序无索引，那么用HashSet集合。
     如果希望增删改查都很快且有序，但是元素不重复以及无索引，那么用LinkedHashSet集合。

目标：TreeSet集合

TreeSet: 不重复，无索引，按照大小默认升序排序!!
TreeSet集合称为排序不重复集合，可以对元素进行默认的升序排序。

TreeSet集合自自排序的方式：
    1.有值特性的元素直接可以升序排序。（浮点型，整型）
    2.字符串类型的元素会按照首字符的编号排序。
    3.对于自定义的引用数据类型，TreeSet默认无法排序，执行的时候直接报错，因为人家不知道排序规则。

自定义的引用数据类型的排序实现：
    对于自定义的引用数据类型，TreeSet默认无法排序
    所以我们需要定制排序的大小规则，程序员定义大小规则的方案有2种：
    a.直接为对象的类实现比较器规则接口Comparable，重写比较方法（拓展方式）
         // 如果程序员认为比较者大于被比较者 返回正数！
         // 如果程序员认为比较者小于被比较者 返回负数！
         // 如果程序员认为比较者等于被比较者 返回0！

    b.直接为集合设置比较器Comparator对象,重写比较方法
         // 如果程序员认为比较者大于被比较者 返回正数！
         // 如果程序员认为比较者小于被比较者 返回负数！
         // 如果程序员认为比较者等于被比较者 返回0！
    注意：如果类和集合都带有比较规则，优先使用集合自带的比较规则。

小结：
    TreeSet集合对自定义引用数据类型排序，默认无法进行。
    但是有两种方式可以让程序员定义大小规则：
         a.直接为对象的类实现比较器规则接口Comparable，重写比较方法（拓展方式）
         b.直接为集合设置比较器Comparator对象,重写比较方法
    注意：如果类和集合都带有比较规则，优先使用集合自带的比较规则。

目标：Collections工具类的使用。

java.utils.Collections:是集合工具类
Collections并不属于集合，是用来操作集合的工具类。
Collections有几个常用的API:
     - public static <T> boolean addAll(Collection<? super T> c, T... elements)
         给集合对象批量添加元素！
     - public static void shuffle(List<?> list) :打乱集合顺序。
     - public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
     - public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

目标：引用数据类型的排序。

字符串按照首字符的编号升序排序！

自定义类型的比较方法API:
     - public static <T> void sort(List<T> list):
           将集合中元素按照默认规则排序。
           对于自定义的引用类型的排序人家根本不知道怎么排，直接报错！
           如果希望自定义的引用类型排序不报错，可以给类提供比较规则:Comparable。

     - public static <T> void sort(List<T> list，Comparator<? super T> c):
            将集合中元素按照指定规则排序,自带比较器
            注意：如果类有比较规则，而这里有比较器，优先使用比较器。

目标：可变参数。

可变参数用在形参中可以接收多个数据。
可变参数的格式：数据类型... 参数名称

可变参数的作用：
     传输参数非常灵活，方便。
     可以不传输参数。
     可以传输一个参数。
     可以传输多个参数。
     可以传输一个数组。

可变参数在方法内部本质上就是一个数组。
可变参数的注意事项：
        1.一个形参列表中可变参数只能有一个！！
        2.可变参数必须放在形参列表的最后面！！
小结：
     可变参数的作用：传输参数非常灵活，方便。
     可变参数的注意事项：
     1.一个形参列表中可变参数只能有一个！！
     2.可变参数必须放在形参列表的最后面！！