Java基础02-数据结构List和Set集合

Posted bruce1993

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java基础02-数据结构List和Set集合相关的知识,希望对你有一定的参考价值。

1. 数据结构基础篇

1.1 什么是数据结构 ?

 

 

?

 
技术图片
数据结构

? 数据结构就是计算机存储、组织数据的方式 。

? 指的是相互之间存在着特定关系的一种或多种的数据元素集合。

1.2 为什么要学习数据结构?

? 通常情况下,精心选择合适的数据结构可以带来更高的运行或存储的效率。

? 数据结构往往同高效的检索算法和索引技术有关。

1.3 数据结构-栈

  • 栈:栈(stack)又名堆栈,是一种运算受限的线性表。

  • 受限:限定仅在表尾进行插入和删除操作的线性表(这一端被称为栈顶,另一端称为栈底)。

     
    技术图片
    栈底和栈顶

     

  • 特性: 先进后出。

    • 进栈(压栈):如下图

       
      技术图片
      出栈入栈

       

    • 出栈(弹栈):如下图

       
      技术图片
      出栈和入栈

       

1.4 数据结构-队列

  • 队列:是一种受限的特殊线性表。
  • 受限:只允许在表的前端(队头)进行删除操作,后端(队尾)进行插入操作。
  • 特性:先进先出
     
    技术图片
    队列

1.5 数据结构-数组

  • 数组:一组有序的(索引有序并且从0开始)类型相同的元素集合。
  • 特性:有序、同类型、长度固定。
  • 应用效果:
    • 查询快。
      • 从数组索引0开始查找,根据指定位置的偏移量可快速获取数据。
    • 增删慢。
      • 数组的长度是固定的,若删除或增加一格元素,则会先创建一个新的数据,再把原数组的数据根据操作复制到新数组中。

1.6 数据结构-链表(单链表)

 
技术图片
链表
  • 链表:是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
  • 特点:
    • 由一系列结点(链表中的每一个元素称为结点)组成。
    • 结点可以在运行时动态生成。
    • 每个结点包括两个部分
      • 一个是存储数据元素的数据域
      • 另一个是存储下一个结点地址的指针域。
  • 应用效果:
    • 查询慢:链表的地址不是连续的,每次查找都得从头开始查找。
    • 增删快:增删操作不会影响链表的整体结构。

1.7 数据结构-红黑树

 
技术图片
红黑树
  • 红黑树(对称二叉B树):一种自平衡二叉查找树。
  • 应用效果:
    • 查询速度快。
      • 在进行插入和删除操作时通过特定操作保持二叉查找树的平衡,从而获得较高的查找性能

2. List集合

2.1 List集合介绍

? List作为Collection集合的子接口,不但继承了Collection接口中的全部方法,而且还增加了一些根据元素索引来操 作集合的特有方法,如下:

  • 方法:

    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 list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        // public void add(int index, E element) : 将指定的元素,添加到该集合中的指定位置上。
        list.add(1,"d");
        System.out.println(list); // [a, d, b, c]
        // public E get(int index) :返回集合中指定位置的元素。
        System.out.println(list.get(2)); // b
        // public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
        list.remove(1);
        System.out.println(list); // [a, b, c]
        // public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素
        list.set(1,"B");
        System.out.println(list); // [a, B, c]
  • 特点:

    • 存取顺序一致,并且有索引。
    • 元素内容可重复。

2.2 List集合实现类-ArrayList

? java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢,查找快,用于日常开发中使用最多的功能为 查询数据、遍历数据,所以 ArrayList 是最常用的集合。

? 许多程序员开发时非常随意地使用ArrayList完成任何需求,并不严谨,这种用法是不提倡的。

2.3 List集合实现类-LinkedList

  • 介绍:java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

    LinkedList是一个双向链表,那么双向链表是什么样子的呢,如图


     
    技术图片
    链表
  • 常用方法

    • 方法:

      实际开发中对一个集合元素的添加与删除经常涉及到首尾操作,而LinkedList提供了大量首尾操作的方法。

      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) :将元素推入此列表所表示的堆栈。

      public boolean isEmpty() :如果列表不包含元素,则返回true。

    • 代码:

          LinkedList list = new LinkedList();
          list.add("a");
          list.add("b");
          // public void addFirst(E e) :将指定元素插入此列表的开头。
          list.addFirst("A");
          // public void addLast(E e) :将指定元素添加到此列表的结尾。
          list.addLast("B");
          System.out.println(list); // [A, a, b, B]
          // public E getFirst() :返回此列表的第一个元素。
          System.out.println(list.getFirst()); // A
          // public E getLast() :返回此列表的最后一个元素。
          System.out.println(list.getLast()); // B
          // public E removeFirst() :移除并返回此列表的第一个元素。
          list.removeFirst();
          // public E removeLast() :移除并返回此列表的最后一个元素。
          list.removeLast();
          System.out.println(list); //[a, b]
          // public E pop() :从此列表所表示的堆栈处弹出一个元素。
          list.pop();
          System.out.println(list); // [b]
          // public void push(E e) :将元素推入此列表所表示的堆栈。
          list.push("a");
          System.out.println(list); // [a, b]
          // public boolean isEmpty() :如果列表不包含元素,则返回true。
          System.out.println(list.isEmpty()); // false

3. Set集合

3.1 Set集合介绍

  • 继承了Collectin集合
  • 没有扩充方法
  • 与List集合不同的是会保证集合中元素的唯一性。

3.2 Set集合实现类-HashSet

  • HashSet介绍

    • 集合中的元素存取是无序的

    • 集合中的元素是不重复的

    • HashSet 是根据对象的哈希值来确定元素在集合中的存储位置,因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于: hashCode 与 equals 方法。

    • 代码:

          Set set = new HashSet();
          set.add("张三");
          set.add("李四");
          set.add("李四");
          set.add("王五");
          set.add("赵六");
          System.out.println(set);  // [李四, 张三, 王五, 赵六]
  • 哈希值

    • 一个十进制的逻辑地址。

    • 所有的对象都继承里Object中的HashCode方法

    • 代码:

          System.out.println("a".hashCode());  // 97
          System.out.println("b".hashCode()); // 98
          System.out.println("张三".hashCode()); // 774889
          System.out.println("李四".hashCode()); // 842061
          int[]arr1={1,2,3};
          System.out.println(arr1.hashCode()); //1355531311
  • HashSet存储数据的结构

    • 结构:数组+链表/红黑树

      ? 在JDK1.8之前,哈希表底层采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。

      ? 但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而JDK1.8中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找 时间。

    • 图解存储结构

       
      技术图片
      Set

       

  • 图解元素唯一性原理流程图
     
    技术图片
    流程图
  • 小结:

    总而言之,JDK1.8引入红黑树大程度优化了HashMap的性能,那么对于我们来讲保证HashSet集合元素的唯一, 其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象,那么保证其唯一, 就必须复写hashCode和equals方法建立属于当前对象的比较方式。

  • HashSet存储自定义类型对象

    • 要求:自定义人物类型(含有姓名、年龄),用HashSet集合存储,若对象的姓名和年龄一致则在集合中不允许重复

    • 代码:

      /*人物类*/
      public class People {
        private String name;
        private int age;
        public People(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;
          People people = (People) o;
          return age == people.age &&
                  name.equals(people.name);
        }
        @Override
        public int hashCode() {
          return Objects.hash(name, 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;
        }
      }
      
      // 入口类
      public class Main {
        public static void main(String[] args) {
          People p1 = new People("张三",10);
          People p2 = new People("李四",12);
          People p4 = new People("李四",12);
          People p3 = new People("王五",10);
      
          HashSet set = new HashSet();
          set.add(p1);
          set.add(p2);
          set.add(p3);
          set.add(p4);
          System.out.println(set.size()); // 3
        }
      }

3.3 Set集合实现类-LinkedHashSet

  • 组织结构:哈希表(数组+链表/红黑树) + 链表(记录存取顺序)

  • 特点:

    • 元素唯一性
    • 元素存取有序。
  • 代码:

        LinkedHashSet set = new LinkedHashSet();
        set.add("张三");
        set.add("李四");
        set.add("李四");
        set.add("王五");
        set.add("赵六");
        System.out.println(set);  // [张三, 李四, 王五, 赵六]

3.4 其他扩展-可变参数

  • 格式:

    修饰符 返回值类型 方法名(参数类型... 形参名){ }
    等价于
    修饰符 返回值类型 方法名(参数类型[]形参名){ }
  • 代码:

      public static void main(String[] args) {
        System.out.println(add(1,2,3));  // 6
        System.out.println(add(1,200,300,400));  // 901
      }
    
      public  static int add(int...num) {
        int sum = 0;
        for (int i = 0; i < num.length; i++) {
          sum += num[i];
        }
        return sum;
      }
  • 原理:在编译成class文件时,源代码中的可变参数会自动变成数组。

  • 注意事项:

    • 可变参数类型要一致
    • 可变参数要放在参数列表最后

4. Collections

4.1 Collection介绍和使用

? java.utils.Collections 是集合工具类,用来对集合进行操作 。常用的方法如下:

  • 方法:

    public static <T> boolean **addAll(Collection<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> )** :将集合中元素按照指定规则排序。

  • 代码:

        ArrayList<Integer> list = new ArrayList<>();
        //public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
        Collections.addAll(list, 1, 3, 4, 5, 6, 8, 7);
        System.out.println(list); // [1, 3, 4, 5, 6, 8, 7]
        //public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
        Collections.shuffle(list);
        System.out.println(list); // 随机顺序[5, 4, 6, 3, 7, 1, 8]
        //public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
        Collections.sort(list);
        System.out.println(list); // 默认升序[1, 3, 4, 5, 6, 7, 8]
        //public static <T> void sort(List<T> list,Comparator<? super T> ) :将集合中元素按照指定规则排序。
        Collections.sort(list, new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
            return o2-o1;
          }
        });
        System.out.println(list);
  • 注意事项:

    • 若要对自定义对象进行排序时,使用 sort(List<T> list)时,自定义类型需要实现Comparable接口,并且要重新CompareTo方法

    • 代码:

      public class People implements Comparable<People> {
        private String name;
        private int age;
      
        public People(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 int compareTo(People o) {
          return this.age - o.age;  // 升序
         // return o.age-this.age; 降序
      
        }
      }

以上是关于Java基础02-数据结构List和Set集合的主要内容,如果未能解决你的问题,请参考以下文章

Java基础知识(JAVA集合框架之List与Set)

java 基础关于 list 集合问题

Java基础——集合体系结构

Java基础知识之集合

Java基础知识盘点- 集合篇

java基础-集合