05-Collection

  • 时间:
  • 分类: JAVA

Collection

1、复习数组和集合的区别

1.1、数组特点

    1. 长度不能变化
    2. 可以存放基本数据类型也可以存放引用数据类型

1.2、集合的特点

    1. 长度可以变化
    2. 只能存储引用数据类型

2、Collection集合

2.1、介绍

​ Collection是单列集合的顶层接口，Collection种定义单列集合种的共性内容

2.2、List体系特点

    1. 有索引
    2. 元素可以重复
    3. 存储和取出有顺序

2.3、Set体系特点

    1. 没有索引
    2. 元素不可以重复
    3. 存储和取出没有顺序

2.4、Collection常用功能

2.4.1、添加元素

  • boolean add(E e) 添加元素

2.4.2、清空集合

  • void clear() 清空集合,删除集合中的所有元素2.4.3、是否包含指定的元素

2.4.3、判断是否包含指定元素

  • boolean contains(Object o) 是否包含指定的元素,如果包含返回true

2.4.4、判断集合是否为空

  • boolean isEmpty() 判断集合是否为空,如果为空返回true

2.4.5、删除元素

  • boolean remove(Object o) 根据内容删除元素

2.4.6、获取集合的长度

  • int size() 获取集合的长度

2.4.7、集合转化成数组

  • public Object[] toArray() 把集合中的元素，存储到数组中

2.5、示例代码

 public class Demo02 {

    public static void main(String[] args) {

        // 我们现在要学习Collection接口中的方法

        Collection<String> coll = new ArrayList<>();



        // boolean add(E e) 添加元素

        coll.add("王宝强");

        coll.add("谢霆锋");

        coll.add("贾乃亮");

        coll.add("陈羽凡");



        // void clear() 清空集合,删除集合中的所有元素

        // coll.clear();



        // boolean contains(Object o) 是否包含指定的元素,如果包含返回true

        System.out.println(coll.contains("王宝强")); // true

        System.out.println(coll.contains("王力宏")); // false



        // boolean isEmpty() 判断集合是否为空,如果为空返回true

        // System.out.println(coll.isEmpty());



        // boolean remove(Object o) 根据内容删除元素

        coll.remove("王宝强");



        // int size() 获取集合的长度

        System.out.println("长度: " + coll.size());



        // public Object[] toArray() 把集合中的元素，存储到数组中

        Object[] arr = coll.toArray();

        for (int i = 0; i < arr.length; i++) {

            Object obj = arr[i];

            System.out.println(obj);

        }



        System.out.println(coll);

    }

}

2、迭代器

2.1、为什么要迭代器

  • List接口有索引，我们可以通过for循环+get方法来获取数据，但是Set接口这边没有索引，不能通过for循环+get方法来获取数据。
    • 解决办法：Collection接口设计了一种通用的方式方便所有的集合来获取数据，就是迭代器(Iterator)

2.2、迭代器的常用方法

2.2.1、判断是否有元素，如果有返回true

  • boolean hashNext()判断是否有元素，如果有返回true

2.2.2、获取一个元素

  • E next()获取一个元素

2.3、如何获取迭代器

  • 集合.iterator()获取迭代器
  • 所有的集合都可以调用iterator()方法获取迭代器

2.4、迭代器的使用步骤

    1. 获取迭代器
    2. 循环判断是否有元素
    3. 获取元素

2.5、示例代码

 public class Demo03 {

    public static void main(String[] args) {

        // 创建集合

        Collection<String> coll = new ArrayList<>();

        coll.add("贾乃亮");

        coll.add("陈羽凡");

        coll.add("王宝强");

        coll.add("武大郎");



        // 使用迭代器遍历数据

        // 1.获取迭代器

        Iterator<String> itr = coll.iterator();

        // 2.循环判断是否有下一个元素

        while (itr.hasNext()) {

            // 3.有元素,获取一个元素

            String next = itr.next();

            System.out.println(next);

        }    }}

3、增强for循环

3.1、概念

​ 是JDK1.5推出的新特性，一般也称为加强for循环，foreach循环

3.2、格式

  • for(数据类型 变量名 : 数组或集合){}

3.3、好处

  • 简化代码

3.4、缺点

  • 无法操作索引

3.5、遍历集合的原理

  • 增强for遍历集合的底层利用的是迭代器

3.6、遍历数组的原理

  • 增强for遍历数组底层利用的是普通for循环

3.7、示例代码

 public class Demo05 {

    public static void main(String[] args) {

        Collection<String> coll = new ArrayList<>();

        coll.add("李小璐");

        coll.add("白百何");

        coll.add("张柏芝");

        coll.add("马蓉");



        // 增强for遍历集合,底层是迭代器

        for (String str: coll) {

            System.out.println(str);

        }



        // 判断存在才删除

        while (coll.contains("白百何")) {

            coll.remove("白百何");

        }



        System.out.println("--------------------------------------");

        // 增强for遍历数组,底层是普通for循环

        int[] arr = new int[] {11, 22, 33};

        for (int number: arr) {

            System.out.println(number);

        }

    }

}

4、常用数据结构

4.1、栈

  • 先进后出

4.2、队列

  • 先进先出

4.3、数组

  • 查询快，增删慢

4.4、链表

  • 查询慢，增删相对快

4.5、二叉树

  • 二叉树每个节点最多只有2个子节点

4.6、二叉查找树

  • 要求
    • 每一个节点上最多有两个子节点
    • 左子树上所有节点的值都小于根节点的值
    • 右子树上所有节点的值都大于根节点的值
  • 好处
    • 提高查询数据的性能
  • 弊端
    • 二叉查找树倾斜，退化成链表，查询速度变慢

4.7、平衡二叉树

  • 要求
    • 任意节点的左右两个子树的高度相差不超过1
    • 任意节点的左右两个子树都是一棵平衡二叉树
  • 好处
    • 提高查询数据的性能
  • 弊端
    • 平衡二叉树的子树高度相差不超过1，要求很严格，每次添加或删除数据的时候都可能导致树不平衡，需要进行旋转，查询效率高，增删效率低

4.8、红黑树

4.8.1、规则

  • 每一个节点是红色或者黑色，根节点必须是黑色
  • 如果一个节点没有子节点或者父节点，这些Nil视为叶节点，每个叶节点(Nil)是黑色的
  • 如果某一个节点是红色，那么它的子节点必须是黑色（不能出现两个红色节点相连的情况）
  • 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点
    • demo：
  • 红黑树的要求比平衡二叉树更加宽松，保证最短路径到最长路径的数量不超过两倍
    • demo：
    • ​

4.8.2、好处

  • 红黑树的要求比平衡二叉树更加宽松，保证最短路径到最长路径的数量不超过两倍，添加或删除元素时进行旋转的概率更低，增高了增删效率
  • 查询效率较高，增删效率高

5、List体系

5.1、特点

    1. 有索引
    2. 元素可以重复
    3. 存储和取出有顺序
  • demo：

5.2、List集合特有方法

5.2.1、往指定索引位置添加元素

  • void add(int index, E element) 往指定索引位置添加元素5.2.2、获取指定索引的元素

5.2.2、获取指定索引的元素

  • E get(int index) 获取指定索引的元素

5.2.3、修改指定索引位置的元素

  • E set(int index, E element) 修改指定索引位置的元素

5.2.4、通过索引删除元素

  • E remove(int index) 通过索引删除元素

5.3、ArrayList原理

    1. ArrayList集合底层是数组，查询快，增删慢

    2. ArrayList内部使用Object[] elementData；来存储数据

    3. 刚创建ArrayList，elementData数组为0

    4. 第一次添加数据时elementData长度为10

    5. 当数据超过10个，扩容，容量是以前的1.5倍

      eg：10， 15， 22， 33

5.4、LinkedList

5.4.1、LinkedList特有方法

5.4.1.1、在最前面添加一个数据
  • void addFirst(E e) 在最前面添加一个数据
5.4.1.2、在最后面添加一个数据
  • void addLast(E e) 在最后面添加一个数据5.4.1.3、获取第一个元素
5.4.1.3、
  • E getFirst() 获取第一个元素
5.4.1.4、获取最后一个元素
  • E getLast() 获取最后一个元素
5.4.1.5、删除第一个元素
  • E removeFirst() 删除第一个元素
5.4.1.6、删除最后一个元素
  • E removeLast() 删除最后一个元素

5.4.2、LinkedList原理

  • LinkedList底层是双向链表，具有查询慢，增删快

6、Set体系

6.1、特点

    1. 没有索引
    2. 元素不可以重复
    3. 存储和取出没有顺序
  • demo

6.2、Set体系特有方法

  • Set体系没有特殊方法，都是使用来自Collection中的方法

6.3、HashSet

6.3.1、HashSet 基本使用

  • demo：


    •  public class Demo11 {
      
    public static void main(String[] args) {
      
        // 创建HashSet
      
        Set<String> set = new HashSet<>();
      

      
        // 添加数据
      
        set.add("郭富城");
      
        set.add("刘德华");
      
        set.add("张学友");
      
        System.out.println(set.add("黎明"));
      
        System.out.println(set.add("黎明"));
      
        System.out.println(set.add("黎明"));
      

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

6.3.2、HashSet存储Student

  • 放在HashSet中的元素如果要去除重复,需要重写hashCode()和equals()方法hashCode相同,equals为true的就认为是重复.不存储

6.3.3、哈希表结构

  • JDK1.8之前
  • JDK1.8Z之后

6.3.4、哈希表存储元素过程

    1. 根据hashCode值计算元素存放的位置
    2. 如果这个位置没有元素，直接存储
    3. 如果这个位置有元素，调用equals比较
    4. equals()为false，存储
    5. equals()为true，不存储（认为是相同的元素）

6.4、LinkedHashSet

6.4.1、特点

  • 有序
  • 不重复
  • 无索引

6.4.2、底层原理

  • 底层数据结构依然是哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序
  • demo

6.5、TreeSet

6.5.1、特点

  • 不重复
  • 无索引
  • 会排序

6.5.2、底层原理

  • TreeSet集合底层是基于红黑树的数据实现排序的，增删改查性能都较好
  • TreeSet集合是一定要排序的
      1. 元素自然排序（默认的规则排序）
      2. 比较器排序

6.5.3、TreeSet的构造器

6.5.3.1、根据元素的自然顺序排序
  • public TreeSet()根据元素的自然顺序排序
6.5.3.2、根据比较器的规则给元素排序
  • public TreeSet(Comparator comparator)根据比较器的规则给元素排序

6.5.4、TreeSet存储自定义类型

  • 自定义类型放入TreeSet中，其是不知道怎么排序的，会出现异常


    • 自然排序Comparable(自定义类实现Comparable接口)


      •  // 类实现了Comparable接口就有自然排序的能力
        
public class Student implements Comparable<Student> {
        
    private String name;
        
    private int age;
        

        
    @Override
        
    public int compareTo(Student o) {
        
        // this: 当前对象
        
        // o: 另一个对象
        
        // return this.age - o.age; // 升序
        
        return o.age - this.age; // 降序
        
    }    // 类中省略其他}

    • 比较器排序Comparator(使用匿名内部类创建Comparator对象，并重写compara方法)


      •  // 创建TreeSet集合对象(使用比较器排序)
        
// 比较器的优先级高于,元素的自然顺序
        
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
        
     @Override
        
     public int compare(Student o1, Student o2) {
        
         // return o1.getAge() - o2.getAge(); // 升序
        
         return o2.getAge() - o1.getAge(); // 升序
        
     }
        
});

标签: Java

添加新评论