1. 集合UML图

集合主要分两类：Collection 和 Map.
image.png
image.png
Vector、HashTable、Properties是线程安全的；
ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。
List，Set，Map在遍历过程中是不允许更新操作的（增，删，改）

2. Collection接口

2.1 Collection接口API
  1. // jdk1.8
  2. public interface Collection<E> extends Iterable<E> {
  3.     int size();  //集合中元素的数量
  4.     boolean isEmpty(); //集合中是否有元素
  5.     boolean contains(Object o); // 判断某个元素是否存在
  6.     Iterator<E> iterator(); // 由于继承了接口Iterable，继承于Iterable
  7.     Object[] toArray(); // 转成Object数组
  8.     <T> T[] toArray(T[] a); // 转成指定类型的数组
  9.     boolean add(E e); //添加元素
  10.     boolean remove(Object o); //删除指定元素
  11.     boolean containsAll(Collection<?> c); // 判断多个元素是否包含
  12.     boolean addAll(Collection<? extends E> c); // 添加多个元素
  13.     boolean removeAll(Collection<?> c); // 移除多个元素
  14.     boolean retainAll(Collection<?> c); // 保留交集的元素
  15.     void clear(); //清空集合
  16.     boolean equals(Object o);
  17.     int hashCode();
  19.     default boolean removeIf(Predicate<? super E> filter) {
  20.         Objects.requireNonNull(filter);
  21.         boolean removed = false;
  22.         final Iterator<E> each = iterator();
  23.         while (each.hasNext()) {
  24.             if (filter.test(each.next())) {
  25.                 each.remove();
  26.                 removed = true;
  27.             }
  28.         }
  29.         return removed;
  30.     }
  32.     //实现口 Iterable
  33.     default Spliterator<E> spliterator() {
  34.         return Spliterators.spliterator(this, 0);
  35.     }
  37.     default Stream<E> stream() {
  38.         return StreamSupport.stream(spliterator(), false);
  39.     }
  41.     default Stream<E> parallelStream() {
  42.         return StreamSupport.stream(spliterator(), true);
  43.     }
  44. }

2.2 Collection接口实现类的特点
  1. Collection实现子类可以存放多个元素，每个元素可以是Object
  2. 有些Collection的实现类，可以存放重复的元素，有些不可以
  3. 有些Collection的实现类，有些是有序的（LIst），有些不是有序的(Set)
  4. Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的
    2.3 Iterator遍历集合
  • Collection 继承了接口 Iterable
  • Iterator iterator(); 调用iterator()返回Iterator， Iterator 是迭代器，主要用于遍历集合中的元素。

  • Iterator仅用于集合遍历，Iterator本身并不存放对象。

    1. public interface Iterator<E> {
    2.   boolean hasNext();
    3.   E next();
    5.   default void remove() {
    6.       throw new UnsupportedOperationException("remove");
    7.   }
    9.   default void forEachRemaining(Consumer<? super E> action) {
    10.       Objects.requireNonNull(action);
    11.       while (hasNext())
    12.           action.accept(next());
    13.   }
    14. }
    1.   public static void main(String[] args) {
    2.       List<String> list =new ArrayList<>(Arrays.asList("a","b","c"));
    3.       //调用iterator()得到迭代器
    4.       Iterator<String> iterator = list.iterator();
    5.       //hasNext判断是否还有下一个元素
    6.       while (iterator.hasNext()){
    7.           //next 指针下移，并将下移以后集合位置上的元素返回
    8.           System.out.println(iterator.next());
    9.       }
    10.   }

    注意：

  1. 在调用next之前一定要调用hasNext()方法，若不调用，且下一条记录无效，直接调用next会抛出异常（NoSuchElementException）。
  2. 当退出while循环后，这时Iterator迭代器，指向最后的元素， 如果希望再次遍历，需要重置我们的迭代器（即：再次调用iterator()方法）
    2.4 增强for循环遍历集合
    增强for循环，可以代替iterator迭代器，特点：增强for循环是简化版的iterator,本质是一样。只能用于遍历集合或数组。 ```java public static void main(String[] args) {
    1.  // itit  ctrl + j
    2.  List<String> list = new ArrayList<>();
    3.  //增强for循环其实就是 Iterator
    4.  //当然我们可以给ArrayList中的iterator()中打断点验证
    5.  for (String s : list) {
    6.  }
    }

main方法字节码 0 new #2 3 dup 4 invokespecial #3 > 7 astore_1 8 aload_1 9 invokeinterface #4 count 1 14 astore_2 15 aload_2 16 invokeinterface #5 count 1 21 ifeq 37 (+16) 24 aload_2 25 invokeinterface #6 count 1 30 checkcast #7 33 astore_3 34 goto 15 (-19) 37 return

  1. <a name="p8CPp"></a>
  2. #### 3. List接口
  4. - List集合类中元素有序（即添加元素顺序和取出元素顺序一致），且可重复
  5. - List集合中的每个元素都有其对应的顺序索引，即支持索引（索引从0开始）
  6. ```java
  7. public interface List<E> extends Collection<E> {
  8.     // 父接口中的方法
  10.     //List接口独有
  11.      default void replaceAll(UnaryOperator<E> operator) {
  12.         Objects.requireNonNull(operator);
  13.         final ListIterator<E> li = this.listIterator();
  14.         while (li.hasNext()) {
  15.             li.set(operator.apply(li.next()));
  16.         }
  17.     }
  19.     default void sort(Comparator<? super E> c) {
  20.         Object[] a = this.toArray();
  21.         Arrays.sort(a, (Comparator) c);
  22.         ListIterator<E> i = this.listIterator();
  23.         for (Object e : a) {
  24.             i.next();
  25.             i.set((E) e);
  26.         }
  27.     }
  29.     E get(int index); //获取指定index的元素，因此支持fori循环
  30.     E set(int index, E element); //设置指定index的元素为element,相当于替换
  31.     void add(int index, E element);// 在index位置插入element元素
  32.     E remove(int index); // 移除指定index的元素，并返回该元素
  33.     int indexOf(Object o); // 返回o在集合中首次出现的位置
  34.     int lastIndexOf(Object o);// 返回o在集合中最后出现的位置
  35.     ListIterator<E> listIterator();
  36.     ListIterator<E> listIterator(int index);
  37.     List<E> subList(int fromIndex, int toIndex);
  38.     //返回fromIndex（包含）到toIndex（不包含）的子集合
  39. }