2019-9-24【Javase】集合Collection、List

集合

1.集合

区别：

1. 数组长度是固定的；
   集合长度是不固定的，是变长；
   2）数组可以存储基本类型 和 引用类型的数据；
   集合 只能存储引用类型的数据。

2.Collection集合

Collection接口:单列存储。数据可以重复存储。
|
List接口 （线性表）: 数据可以重复存储，有顺序的，线性排列。
|

2.1 Collection

public static void main(String[] args) {
    // 集合的容器
    Collection<String> arr = new ArrayList<String>();
    // 是空的
    System.out.println(arr.isEmpty());// true
    // 向集合中添加数据
    arr.add("aa");
    arr.add("bb");
    arr.add("cc");
    System.out.println(arr);// [aa, bb, cc]
     1. 判断集合是否为 空 ，为空 true
    System.out.println(arr.isEmpty());// false
    2. 集合中存储的元素的个数
    System.out.println(arr.size());// 3
    // 3.
    Collection<String> c1 = new ArrayList<>();
    c1.add("ee");
    c1.add("ff");
    // 把 参数集合中的所有元素添加到当前集合中，只要当前集合发生了改变 true
    arr.addAll(c1);
    System.out.println(arr);// [aa, bb, cc, ee, ff]
    // 4. 把参数元素 从当前集合中 删除掉，只要当前集合发生了改变 true
    arr.remove("cc");
    System.out.println(arr);// [aa, bb, ee, ff]
    // 5. 把参数集合中的所有元素从当前集合中删除掉，只要当前集合发生了改变 true
    arr.removeAll(c1);
    System.out.println(arr);// [aa, bb]
    // 6. 参数元素 在当前集合中是否存在，存在 true 
    System.out.println(arr.contains("aa"));// true
    // 7. 参数集合中的所有元素在当前集合中是否存在，存在 true 
    System.out.println(arr.containsAll(c1));// false
    // 8. 把集合 元素 转换 成 一个 新的数组对象 
    Object [] obj = arr.toArray();
    System.out.println(Arrays.toString(obj));// [aa, bb]
    Object [] objs = new Object[0];
    //      obj = arr.toArray(objs);
    obj = arr.toArray(new Object[0]);
    System.out.println(Arrays.toString(obj));// [aa, bb]
    // 保留类型
    String [] strs = arr.toArray(new String[2]);
    System.out.println(Arrays.toString(strs));// [aa, bb]
    

    // 9. 清空集合
    arr.clear();
    System.out.println(arr.isEmpty());// true
    System.out.println(arr.size());// 0
    
    
}

2.2 List

List：线性表
是数据结构。
有多个具有相同特性的元素 组成的序列。

顺序。
按照元素添加的顺序分配索引。索引从0 开始的。

public static void main(String[] args) {
    // 
    List<String> list = new ArrayList<>();
    list.add("aa"); // 0
    list.add("bb"); // 1
    list.add("cc"); // 2
    // 1. 向指定的位置添加元素
    list.add(1, "hello");
    System.out.println(list);// [aa, hello, bb, cc]
    // 2. 获得索引位置的元素
    System.out.println(list.get(0));// aa
    // 3. 用第二个参数的元素 替换 索引位置的元素
    list.set(1, "tom");
    System.out.println(list);// [aa, tom, bb, cc]
    // 4. 取子集  【起始，终止) 
    System.out.println(list.subList(1, 3)); // tom,bb
    // 5. 排序
    list.sort(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            // 升序
            return o1.compareTo(o2);
        }
        
    });// [aa, bb, cc, tom]
    list.sort((s1,s2)->s2.compareTo(s1));// 降序 [tom, cc, bb, aa]
    // 没有指定自定义比较器Comparator那么会进行自然升序排序（Comparable接口）
    list.sort(null);
    System.out.println(list); // [aa, bb, cc, tom]
    
    
}

2.3 集合遍历

函数式接口：
Consumer原码:
@FunctionalInterface
public interface Consumer {
void accept(T t);
}
遍历:

    // 有序
    List<String> list = new ArrayList<>();
    list.add("aa");
    list.add("bb");
    // 1. 基本for :只针对List 
    for(int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    // 2. 增强for
    for(String s : list) {
        System.out.println(s);
    }
    // 3. 集合的forEach方法遍历
    list.forEach(new Consumer<String>() {
        @Override
        public void accept(String t) {
            System.out.println(t);
        }
        
    });
    // Lambda简化
    list.forEach(s->System.out.println(s));
    // 方法引用
    list.forEach(System.out::println);

迭代器：

2.3.1 Iterator

    List<String> list = new ArrayList<>();
    list.add("aa");
    list.add("bb");
    list.add("cc");
    System.out.println(list);// [aa, bb, cc]
    //--------------------------------------------
    // 1. Iterator 
    Iterator<String> i = list.iterator();
    // (1) forEachRemaining
    //i.forEachRemaining(System.out::println);
    // (2)
    while(i.hasNext()) {
        System.out.println(i.next());
    }

2.3.2 ListIterator

只能遍历 List类型的集合

    //----------ListIterator :只针对 List集合-------------------------------------
    System.out.println("---------ListIterator---------------");
    // 获得一个迭代器对象
    ListIterator<String> li = list.listIterator();
    // 向后遍历
    while(li.hasNext()) {
        System.out.println(li.next());
    }
    // 向前遍历
    while(li.hasPrevious()) {
        System.out.println(li.previous());
    }

List：线性表
是数据结构。
有多个具有相同特性的元素 组成的序列。
实现的技术：

1） 数组

public static void main(String[] args) {
    /*
     * 创建数组：创建了一个长度为0 的数组
     *      public ArrayList() {
                this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
            }
     */
    ArrayList<String> list = new ArrayList<>();
    /*
     * 数组的初始容量为 10
     *  private static final int DEFAULT_CAPACITY = 10;
     *  超过 10个 的扩容方式：
     *  int newCapacity = oldCapacity + (oldCapacity >> 1);
     *  扩容的最大值  ：Integer.MAX_VALUE
     *          return (minCapacity > MAX_ARRAY_SIZE) ?
                    Integer.MAX_VALUE :
                    MAX_ARRAY_SIZE;
     */
    list.add("aa");

​
}

2） 链表

由 非连续的 元素 组成 的 存储结构。
存数据 Node
分类：
（1） 单向链表
单向非循环链表

单向循环链表

2）双向链表
双向非循环

双向循环

Node代码：

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
​
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

List 实现类：
ArrayList : 线程非安全的。
Vector -> Stack ： 线程安全的。(不去使用)

LinkedList:链表

数组和链表的区别：