java--单列集合

一、集合概述

• 为什么出现集合
  面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

• 集合的特点
  集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

• 集合的分类
  java中集合分为单列集合和键值对集合。在两个顶级接口下又衍生出多中不同实现、不同数据结构的集合类。

---

二、Iterable

Iterable为单列集合封装了一系列迭代方法，为集合的遍历提供了底层依赖。下面列出方法列表

方法	作用
Iterator iterator();	返回迭代器对象
default void forEach(Consumer<? super T> action)	遍历collection类的集合（1.8新增）
default Spliterator spliterator()	返回并行迭代器对象（1.8新增）

---

三、Collection

单列集合的根接口。继承Iterable接口。方法列表

方法	作用
int size();	返回集合中元素的个数
boolean isEmpty();	判断集合是否为空
boolean contains(Object o);	判断集合是否包含某个元素
Iterator iterator();	返回迭代器对象
T[] toArray(T[] a);	将集合转为对象数组
boolean add(E e);	添加元素（成功返回true）
boolean remove(Object o);	移除元素（成功返回true）
boolean containsAll(Collection<?> c);	是否包含给定集合中的所有元素
boolean addAll(Collection<? extends E> c);	将给定集合中的元素添加到本集合
boolean removeAll(Collection<?> c);	将给定集合从本集合中移除
boolean retainAll(Collection<?> c);	本集合对给定集合做交集运算，结果保存在本集合（发生改变返回true）
void clear()	清空集合中的元素
default boolean removeIf(Predicate<? super E> filter)	移除集合中符合条件的元素（1.8新增）
default Stream stream()	返回stream串行流（1.8新增）
default Stream parallelStream()	返回stream并行流（1.8新增）

部分方法演示：

 @Test
    public void test1() {
        Collection<String> collection1 = new ArrayList<>();
        //添加元素
        collection1.add("Hello ");
        collection1.add("Collection!");
        //集合长度
        int size = collection1.size();
        System.out.println("collection.size:"+size);

        Collection<String> collection2 = new ArrayList<>();
        collection2.add("I ");
        collection2.add("Love ");
        collection2.add("You!");

        //contains方法
        System.out.println("是否包含'Love '元素："+collection2.contains("Love "));

        //addAll方法
        collection1.addAll(collection2);

        //remove方法
        collection1.remove("Love ");
        System.out.println("移除'Love '后："+collection1);

        //removeIf方法，移除以感叹号结束的元素
        collection1.removeIf(s -> s.endsWith("!"));

        System.out.println("----遍历----");
        //获取Stream流并遍历
        collection1.stream().forEach(System.out::println);
    }

运行结果：

collection.size:2
是否包含'Love '元素：true
移除'Love '后：[Hello , Collection!, I , You!]
----遍历----
Hello 
I 

---

四、List接口及其子类

List接口，继承Collection。有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

主要特点：元素有放入顺序，可重复。

特有方法列表：

方法	作用
boolean addAll(int index, Collection<? extends E> c)	将给定集合插入到指定索引处
E get(int index)	获取给定索引处的元素
E set(int index, E element)	将元素设置到指定索引处
void add(int index, E element);	将元素添加到指定索引处
E remove(int index);	移除指定索引处的元素
int indexOf(Object o);	返回给定元素在集合中的第一个索引值
int lastIndexOf(Object o);	返回给定元素在集合中的最后一个索引值
ListIterator listIterator()	返回ListIterator迭代器对象
ListIterator listIterator(int index);	返回以index为迭代起始位置的迭代器对象
List subList(int fromIndex, int toIndex);	截取从fromIndex（包含）到toIndex（不包含）的子集合
default void replaceAll(UnaryOperator operator)	将集合中的每个元素按照给定规则替换（1.8新增）
default void sort(Comparator<? super E> c)	按照给定规则将元素排序（1.8新增）

部分方法演示：

     @Test
    public void test2() {
        //用Arrays工具类创建集合
        List<Integer> list = new ArrayList<>();
        list.add(0);
        list.add(11);
        list.add(222);
        list.add(3333);
        list.add(44444);
        list.add(44444);

        //在指定索引处添加元素;
        list.add(3, 0);

        //获取指定索引处的元素
        System.out.println("3 索引处的元素：" + list.get(3));
        System.out.println(list);

        //移除指定索引处的元素
        System.out.println("移除 4 索引处的元素：" + list.remove(5));
        System.out.println(list);

        //返回给定元素在集合中的最后一个索引值
        System.out.println("0 在集合中的最后一个索引值"+list.lastIndexOf(0));

        //replaceAll方法
        list.replaceAll(i -> ++i);
        System.out.println(list);
    }

运行结果

3 索引处的元素：0
[0, 11, 222, 0, 3333, 44444, 44444]
移除 4 索引处的元素：44444
[0, 11, 222, 0, 3333, 44444]
0 在集合中的最后一个索引值3
[1, 12, 223, 1, 3334, 44445]

1.ArrayList类

主要特点：底层数据结构是数组；   查询快，增删慢 ；   线程不安全，效率高

特有方法列表：

方法	作用
public void trimToSize()	将ArrayList容量修改为当前大小（节约内存）
public void ensureCapacity(int minCapacity)	预定ArrayList容量大小（当添加大量元素时效率高）

2.Vector类

主要特点：底层数据结构是数组；   查询快，增删慢 ；   线程安全，效率低

特有方法列表：

方法	作用
public synchronized void copyInto(Object[] anArray)	将元素复制到给定数组中
public synchronized void trimToSize()	将Vector容量修改为当前大小（节约内存）
public synchronized void ensureCapacity(int minCapacity)	预定Vector容量大小（当添加大量元素时效率高）
public synchronized void setSize(int newSize)	设置Vector的长度（元素个数）
public synchronized int capacity()	返回Vector的当前容量大小
public synchronized int indexOf(Object o, int index)	返回从index开始元素o（可为空）的第一个索引值
public synchronized int lastIndexOf(Object o, int index)	返回从index开始元素o（可为空）的最后一个索引值
public synchronized E elementAt(int index)	返回index索引处的元素
public synchronized E firstElement()	返回 0 索引处的（第一个）元素
public synchronized E lastElement()	返回最后一个元素
public synchronized void setElementAt(E obj, int index)	在指定索引处设置给定元素 （集合长度不变）
public synchronized void removeElementAt(int index)	将指定索引处的元素移除
public synchronized void insertElementAt(E obj, int index)	在指定索引处添加元素（集合长度+1）
public synchronized void addElement(E obj)	添加元素
public synchronized boolean removeElement(Object obj)	移除元素
public synchronized void removeAllElements()	移除所有元素（集合长度变为0）
public Enumeration elements()	返回Enumeration对象（常用于遍历）

部分方法演示：

@Test
    public void test3() {
        Vector<String> vector = new Vector<>();
        vector.add("王");
        vector.add("富");
        vector.add("贵");
        vector.add("王富贵");
        vector.add("王富贵");
        //设置指定索引处的元素（ 参数index<vector.size()，否则越界 ）
        vector.set(3,"富贵");
        System.out.println(vector);

        //在指定索引处添加元素（ 参数index<=vector.size()，否则越界 ）
        vector.add(0,"哈哈");
        System.out.println(vector);

        System.out.println("第一个元素为："+vector.firstElement());
        System.out.println("最后一个元素为："+vector.lastElement());
    }

运行结果：

[王, 富, 贵, 富贵, 王富贵]
[哈哈, 王, 富, 贵, 富贵, 王富贵]
第一个元素为：哈哈
最后一个元素为：王富贵

3.LinkedList类

主要特点：底层数据结构是链表 ;   查询慢，增删快;    线程不安全，效率高;

特有方法列表：

方法	作用
public E getFirst()	获取第一个元素
public E getLast()	获取最后一个元素
public E removeFirst()	移除第一个元素
public E removeLast()	移除最后一个元素

部分方法演示：

    @Test
    public void test4() {
        LinkedList<Character> list = new LinkedList<>();
        list.add('A');
        list.add('A');
        list.add('B');
        list.add('C');
        System.out.println(list);

        System.out.println("第一个元素：" + list.getFirst());

        System.out.println("最后一个元素：" + list.getLast());

        System.out.println("移除第一个元素：" + list.removeFirst());
        System.out.println(list);

        System.out.println("移除最后一个元素：" + list.removeLast());
        System.out.println(list);
    }

运行结果：

[A, A, B, C]
第一个元素：A
最后一个元素：C
移除第一个元素：A
[A, B, C]
移除最后一个元素：C
[A, B]

---

五、Set接口及其子类

Set接口，继承自Collection接口。该类集合特点元素不可重复，无放入顺序（注意：元素虽然无放入顺序，但是元素在 set 中的位置是有该元素的 HashCode 决定的，其位置其实是固定的）

主要特点：元素不可重复，无放入顺序

1.HashSet类

主要特点：底层数据结构是哈希表；   不保证 set 的迭代顺序；   线程不安全

代码演示：

 	@Test
    public void test5() {
        HashSet<String> set = new HashSet<>();
        set.add("窝窝头");
        set.add("一块钱");
        set.add("四个");
        set.add("嘿嘿");
        //元素顺序与添加顺序不同，但其顺序由HashCode决定，又相对固定
        for (int i = 0; i < 5; i++) {
            System.out.println("打印："+set);
        }
        
        //添加元素
        set.add("哈哈");
        //元素顺序发生改变，故其不保证迭代顺序
        System.out.println("添加元素后："+set);

        System.out.println("添加重复元素："+set.add("窝窝头"));
        System.out.println(set);
    }

运行结果

打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
打印：[一块钱, 四个, 嘿嘿, 窝窝头]
添加元素后：[一块钱, 四个, 嘿嘿, 哈哈, 窝窝头]
添加重复元素：false
[一块钱, 四个, 嘿嘿, 哈哈, 窝窝头]

1.1LinkedHashSet类

LinkedHashSet实现Set接口，继承自HashSet。由链表保证了元素有序，由哈希表保证了元素唯一。

主要特点：元素有序、唯一 ；线程不安全；

代码演示：

@Test
    public void test6() {
        LinkedHashSet<Character> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add('B');
        linkedHashSet.add('A');
        linkedHashSet.add('N');
        linkedHashSet.add('G');
        linkedHashSet.add('S');
        linkedHashSet.add('E');
        linkedHashSet.add('R');
        linkedHashSet.add('R');//重复元素
        System.out.println(linkedHashSet);
    }

运行结果

[B, A, N, G, S, E, R]

2.TreeSet类

TreeSet 使用元素的自然顺序对元素进行排序 或者根据创建 set 时提供的 Comparator 进行排序， 具体取决于使用的构造方法。

主要特点： 底层数据结构是红黑树，元素有序且唯一；线程不安全；

代码演示:

    @Test
    public void test7() {
        //无参构造，自然排序规则
        TreeSet<Integer> integers = new TreeSet<>();
        integers.add(1);
        integers.add(8);
        integers.add(6);
        integers.add(3);
        integers.add(15);
        System.out.println(integers);

        //带参(比较器)构造
        /*
        TreeSet<String> strings = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return Integer.compare(s1.length(),s2.length());
            }
        });*/

        //1.8后使用Lambda表达式
        TreeSet<String> strings = new TreeSet<>(Comparator.comparingInt(String::length));
        strings.add("天王盖地虎宝塔镇河妖");
        strings.add("谁tm买小米啊");
        strings.add("菠菜贱卖");
        System.out.println(strings);
    }

运行结果

[1, 3, 6, 8, 15]
[菠菜贱卖, 谁tm买小米啊, 天王盖地虎宝塔镇河妖]

六、Java中单列集合的粗略关系图