集合

image.png

Collection、List、Set均为接口，其余为实现类

集合概述

• 集合与数组都是容器
• 数组的特点
  • 数组定义完成并启动后，类型确定，长度固定
• 在进行增删数据操作的时候，数组是不太合适的，增删数据都需要放弃原有数组或者移位
• 数组适合的场景
  • 当业务数据的个数是固定的，且都是同一批数据类型的时候，可以采取定义数组存储
• 集合的特点
  • 集合的大小不固定，启动后可以动态变化，类型也可以选择不固定的，集合更像气球
  • 集合非常适合做元素的增删操作
• 注意，集合中只能存储引用类型数据，如果要存储基本类型的数据，可以选择使用包装类
• 集合适合的场景
  • 数组的个数不确定，需要进行增删元素的时候

Collection集合的体系特点

• 集合

  • Collection（单列）

    • Collection单列集合，每个元素（数据）只包含一个值

  • map（双列）

    • Map双列集合，每个元素包含两个值（键值对）

• Cowllection（单列集合的祖宗接口）

  • List
    • ArrayList
    • LinkedList
  • Set
    • HashSet
      • LinkedHashSet
    • TreeSet

• Collection集合的特点

  • List系列集合：添加的元素是有序的，可重复的，有索引
  • Set系列集合：添加的元素是无序，不重复，无索引
    • HashSet：无序，不重复，无索引
      • LinkedHasgSet：有序，不重复，无索引
    • TreeSet：按照大小默认升序排序，不重复，无索引

• 集合对于泛型的支持

  • 集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型

    Collection<String> lists = new ArrayList<String>();
    Collection<String> lists = new ArrayList<>();       //JDK1.7开始后面的泛型类型申明可以省略不写
    

    注意：集合和泛型都只支持引用数据类型，不支持基本数据类型，所以集合中存储的元素都认为是对象

    必须使用基本数据类型时，可以使用基本数据类型的包装类

• 综合代码

  package com.java.collection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  
  /**
   * Collection集合的特点
   */
  public class CollectionDemo01 {
      public static void main(String[] args) {
          // 以ArrayList为例： 有序  可重复  有索引
          Collection list = new ArrayList();  // 子类对象给到父类接口，这是一种多态的写法
          list.add("Java");
          list.add("Java");
          list.add("MyBatis");
          list.add(123);
          list.add(123);
          list.add(false);
          list.add(false);
          System.out.println(list);   // 集合本身重写了toString()方法
          //[Java, Java, MyBatis, 123, 123, false, false]
  
          System.out.println("-------------");
  
          // 以HashSet为例：无序  不重复  无索引
          Collection list1 = new HashSet();  // 子类对象给到父类接口，这是一种多态的写法
          list1.add("Java");
          list1.add("Java");
          list1.add("MyBatis");
          list1.add(123);
          list1.add(123);
          list1.add(false);
          list1.add(false);
          System.out.println(list1);   // 集合本身重写了toString()方法
          // [Java, false, MyBatis, 123]
  
          System.out.println("-------------");
          // Collection<String> list2 = new ArrayList<String>();
          Collection<String> list2 = new ArrayList<String>();
          list2.add("Java");
          // list2.add(23); 不满足String泛型约束
          list2.add("MyBatis");
  
          // Collection<int> list3 = new ArrayList(); // 需要使用对应的基本数据类型的包装类
          Collection<Integer> list3 = new ArrayList();
          list3.add(23);  // 此时添加的23不再是int型，实际上是Integer类型的包装类
          list3.add(32);
  
          Collection<Double> list4 = new ArrayList();
          list4.add(23.33);   // 此时添加的23.33不再是double型的基本类型数据，而是Double类型的引用类型数据
          list4.add(33.33);
      }
  }
  
  

Collection集合常用API

• Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的

• Collection常用API如下：

  方法名称	说明
  public boolean add(E e)	把给定的对象添加到当前集合中
  public void clear()	清空集合中所有的元素
  public boolean remove(E e)	把给定的对象在当前集合中删除
  public boolean contains(Object, ob)	判断当前集合中是否包含给定的对象
  public boolean inEmpty()	判断当前集合是否为空
  public int size()	返回集合中元素的个数
  public Object[] toArray()	把集合中的元素，存储到数组中
  public boolean addAll(int index, Collection c)	将给定集合中的所有元素添加到另一个集合中去，其中index是可选参数（前提是list家族），代表插入的位置，c表示传入一个集合

• 测试代码：

  package com.java.collection;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashSet;
  
  /**
   * Collection常用API
   */
  public class CollectionDemo02 {
      public static void main(String[] args) {
          // HashSet添加元素是 无序 不重复 无索引
          Collection<String> list = new HashSet<>();
  
          // 1. 添加元素，添加成功返回true
          list.add("Java");
          list.add("CSS");
          list.add("CSS");
          list.add("MySQL");
          list.add("MyBatis");
          list.add("Spring");
          System.out.println(list);
          // [Java, CSS, MySQL, MyBatis, Spring]
  
          // 2. 清空集合的元素
          list.clear();
          System.out.println(list);   // []
  
          // 3. 判断集合是否为空，是空返回true
          System.out.println(list.isEmpty()); // true
  
          // 4. 获取集合的大小
          list.add("Java");
          list.add("CSS");
          list.add("CSS");
          list.add("MySQL");
          list.add("MyBatis");
          list.add("Spring");
          System.out.println(list.size());   // 5
  
          // 5. 判断集合中是否包含某个元素
          System.out.println(list.contains("Java"));   // true
          System.out.println(list.contains("Node"));   // false
  
          // 6. 删除某个元素：如果有多个重复元素默认删除前面的第一个
          System.out.println(list.remove("CSS"));
          System.out.println(list);  // [Java, MySQL, MyBatis, Spring]
          // 只有list家族才可以使用元素索引删除，这里只是名字为list和list家族没有关系
  
          // 7. 把集合转换成数组
          // 转成Object类的数组是因为即使使用了泛型约束规定集合里面的数组都是String，但是，事实上也存在
          // 特殊的技术，使得即使有泛型约束也可以插入其他数据类型的元素
          // 因此为了防止这种情况，统一转换成Object类型，这样就向下兼容了所有类型的数据
          Object[] arr = list.toArray();
          System.out.println("数组" + Arrays.toString(arr));
  
          // 8. 合并两个集合的元素
          Collection<String> c1 = new ArrayList<String>();
          c1.add("Java1");
          c1.add("Java2");
          Collection<String> c2 = new ArrayList<String>();
          c2.add("Java3");
          c2.add("Java4");
  
          // addAll是将一个数组的元素拷贝到另一个数组中去，而不是剪切，即“倒入”
          c1.addAll(c2);
          System.out.println(c1);
          System.out.println(c2);
      }
  }