java Collection集合 基本用法和原理

java Collection集合 基本用法和原理 二、 Collection 接口 一、接口描述

• public interface Collectionextends Iterable
  

• Collection 层次结构 中的根接口。Collection 表示一组对象的集合，这些对象也称为 collection 的 元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序 的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接 口（如 Set 和 List）实现。

二、List接口 (一)、接口描述

public interface List extends Collection 

• 是有序的 collection 。
• 可以存放重复的元素
• 此接口的用户可以对列表中每个元素的插入位置进行精 确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中 的元素， 不提供具体的实现方法。
• 具体的常用实现类为 : Vector， ArrayList, linkedList

(二)、ArrayList 类用法

// 该类的继承的类 与 实现的接口
public class ArrayList extends AbstractListimplements List, RandomAccess, Cloneable, Serializable

• ArrayList创建与使用

public static void arrayList() {
    // 创建一个List 集合
    // 这里的 表示泛型， 表示这个集合要存储的数据类型
    List list = new ArrayList<>();
    // 向集合中 添加数据
    list.add("张三");
    list.add("李四");
    list.add("王五");
    // 获取集合的内容大小
    int size = list.size();


    // 查看是否包含指定内容
    System.out.println(list.contains("张三"));

    // 删除指定数据
    list.remove("张三");
    size = list.size();
    for (int i = 0; i < size; i++) {
        // 获取集合内容
        System.out.println(list.get(i));
    }
    // 替换指定位置的数据
    list.set(1, "张三");
    size = list.size();
    for (int i = 0; i < size; i++) {
        // 获取集合内容
        System.out.println(list.get(i));
    }
    // 转换成数组
    String[] arr = list.toArray(new String[]{});
}

• 实现原理
  • 采用的动态对象数组实现的， 默认构造方法创建了一个空数组
  • 在第一次添加数据的时候， 数组会扩充容量为10， 之后扩充的算法： 原来的数组的大小 + 原来数组的一半
• 注意点
  • 因为是数组实现的，不适合删除以及插入
  • 为了防止数组的动态扩充过多， 建议初始化ArraysList时， 指定初始容量
  • 是线程不安全的， 建议在单线程下使用

(三)、Vector类的使用

// 该类的继承的类 与 实现的接口
public class Vector extends AbstractListimplements List, RandomAccess, Cloneable, Serializable

• Vector创建与使用’

public static void vector() {
    // 创建Vector 集合
    List v = new Vector<>();
    // 添加数据
    v.add("张三");
    v.add("李四");
    v.add("王五");

    int size = v.size();
    for (int i = 0; i < size; i++) {
        System.out.println(v.get(i));
    }
 // 具体用法与 ArrayList 差不多   
}

• 实现原理
  • 也是采用的动态对象数组实现的， 默认构造方法创建一个容量为10的对象数组
  • 扩充的算法： 当扩充增量为0的时候， 扩充原来的2倍， 当增量大于0的时候， 新数组大小 = 就数组大小 + 增量
• 注意点
  • 也不适合插入和删除
  • 为了防止扩充过多， 建议指定容量
  • 是线程安全的， 适合多线程下使用， 在单线程使用效率较低

(四)、linkedList 类的使用

// 该类的继承的类 与 实现的接口
public class linkedList extends AbstractSequentialListimplements List, Deque, Cloneable, Serializable

• linkedList创建与使用(用法都类似)

public static void linkedList() {
    // 创建
    List linkedlist = new linkedList<>();
    // 添加数据
    linkedlist.add("张三");
    linkedlist.add("李四");
    linkedlist.add("王五");

    int size = linkedlist.size();
    for (int i = 0; i < size; i++) {
        System.out.println(linkedlist.get(i));
    }
}

• 原理
  • 使用链表实现的
• 注意点
  • 对插入与删除 性能高,但不适合遍历

(五)、总结

• 如果考虑到安全问题， 建议使用Vector 集合
• 如果频繁的插入， 删除 *** 作, 建议使用linkedList 集合
• 如果频繁的遍历, 可以使用 ArraysList

三、Set接口 (一)、接口描述

// 继承与实现
public interface Set extends Collection

• 是一个无序的collection
• 不允许出现重复的元素，
• 具体的常用实现类有：HashSet、TreeSet、linkedHashSet

(二)、HashSet类用法

public class HashSet extends AbstractSet implements Set, Cloneable,Serializable

• 创建与使用

 // 创建一个HashSet集合
Set hs = new HashSet<>();
hs.add("张三");
hs.add("李四");
hs.add("王五");
hs.add("赵六");
String[] items = hs.toArray(new String[]{});
for (String item : items) {
    System.out.println(item);
}

// 示例2
 Set hs = new HashSet<>();
Cat c1 = new Cat("小红", 3, 5);
Cat c2 = new Cat("小黑", 2, 1);
hs.add(c2);
hs.add(c1);
hs.add(new Cat("小白", 3, 2));
hs.add(new Cat("小黄", 2, 3));
hs.add(new Cat("小绿", 4, 4));

// 添加一个属性相同的数据，但内存地址不同
hs.add(new Cat("小红", 3, 5)); // 是可以插进去， 此时有两个小红
// 内存地址相同
hs.add(c2) // 只会存在一个 ‘小黑’
Cat[] items = hs.toArray(new Cat[]{});
for (Cat item : items) {
    System.out.println(item);
}

• 实现原理

  • 于哈希表(hashMap) 实现的
    • 哈希表存储结构就是： 数组 + 链表， 数组中的每个元素都以链表的形式存储
    • 如果把对象存储到哈希表中呢？
      • 先要计算对象的hashCode 值， 根据数组的长度 取余， 来决定对象要存储数组的哪个位置
  • 添加元素时， 把元素作为HashMap的Key 存储， HashMap的value 使用一个固定的Object对象
  • 排除元素是通过HashCode来检查对象是否相同

• 注意

  • 添加的元素不允许重复，可以使用null元素(但只能出现一个)
  • 不保证顺序持久不变
  • 判断两个对象对象是否相同， 先判断两个对象的hashCode 是否相等**(如果相等， 但是不一定是同一对象， 如果不等， 那一定不是同一对象)**，还要在通过equals判断(如果相同，则是同一对象， 反之)。
  • 自定义的对象，如果要实现属性值相同则认为同一对象， 这种需求只需要，重写hashCode 和 equals 方法即可。

(三、)TreeSet 类

public class TreeSet extends AbstractSet implements NavigableSet,Cloneable, Serializable

• TreeSet类 创建与使用

public static void treeSet() {
    // 创建一个TreeSet 集合, 
    // 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
    // param1: 比较器(Comparator)
    Set st = new TreeSet<>(new CatComparator());
    Cat c1 = new Cat("小红", 3, 1);
    Cat c2 = new Cat("小黑", 2, 2);
    Cat c3 = new Cat("小黄", 2, 3);
    Cat c4 = new Cat("小蓝", 2, 4);
    st.add(c1);
    st.add(c2);
    st.add(c3);
    st.add(c4);
    Cat[] cats = st.toArray(new Cat[]{});
    for (int i = 0; i < cats.length; i++) {
        System.out.println(cats[i]);
    }
}

• 实现原理
  • 有序的, 基于TreeMap(二叉树数据结构)实现的
  • 对象需要比较大小， 通过对象比较器(Comparator/Comparable)来实现
  • 对象比较器还可以去除重复元素， 当通过比较的两个数是相同的，会认为这两个对象也是相同的， 会进行去重

(四)、linkedHashSet 类

public class linkedHashSet extends HashSet implements Set, Cloneable,Serializable

• linkedHashSet 使用

 // 创建 linkedHashSet 集合
Set set = new linkedHashSet<>();
Cat c1 = new Cat("小红", 3, 1);
Cat c2 = new Cat("小黑", 2, 2);
Cat c3 = new Cat("小黄", 2, 3);
Cat c4 = new Cat("小蓝", 2, 4);
set.add(c1);
set.add(c2);
set.add(c3);
set.add(c4);

Cat[] cats = set.toArray(new Cat[] {});
for (int i = 0; i < cats.length; i++) {
    System.out.println(cats[i]);
}

• 实现原理
  • 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外 在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序， 即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。

(五) 、总结

• 有排序， 可以选择 TreeSet
• 无排序， 也不用保证顺序 可以选择 HashSet
• 无排序，也不用保证顺序， 可以选择 linkedHashset