java集合

List接口

• 继承了Collection接口，Iterable接口

List接口的方法：

• void add(int index,E element):在指定位置插入指定元素

• boolean add(E e):将指定的元素附加到该list的末尾

• boolean addAll(int index,Collection<? extends E >c):将指定集合的所有元素插入到此list的指定位置

• bollean addAll(Collection<? extends E>c):将指定集合的所有元素插入到此list集合的末尾

• void clear():将此list中的所有元素删除

• bollean **contains(Object o)😗*判断此list集合是否包含此元素，如果包含，返回true

• bollean containsAll(Collection<?>c):如果Lsit集合包含此集合中的所有元素，返回true

• static List copyOf(Collection<? extends E>coll):返回一个不可修改的列表 包含给定的Collection的元素，按其迭代顺序，注意：Collection中不能有null元素

• E equals(Object o):比较两个List集合是否等，相等返回true，重写了List接口的equals方法

• E get(int index):返回集合中对应下标的元素

• int hashCode():返回此list集合的哈希码值

• boolean isEmpty():判断集合为空返回true

• Iterator iterator():以正确的顺序返回此lsit中元素的迭代器（Iterator iterator = lsit.iterator() hasNext()判断下一个元素是否存在，next()返回此的第一个元素，并且使next指向下一个元素）

• int indexOf(Object o):返回list中指定元素第一次出现的下标，如不存在返回-1

• int LastIndexOf(Object o):返回此list中指定元素最后一次出现的索引，如不包含，返回-1

• ListIterator listIterator():返回此list中的元素迭代器（以正确的顺序）

• ListIterator listIterator(int index):返回此list中的元素迭代器（以适当的顺序），从列表指定位置开始。

• staticList of();返回一个不可修改的lsit列表

• E remove(int index):删除指定下标的元素

• boolean remove(Object o):删除指定元素（第一次出现的）如果有

• boolean removeAll(Collection<?>c):从此list中删除指定集合中包含的所有元素

• default void replaceAll(UnaryOperator operator):将此lsit的每个元素替换为对该元素引用运算符的结果

  List<Integer> numbers = new ArrayList<>	(Arrays.asList(1, 2, 3, 4, 5));
  // 将集合中的每个元素乘以2
  numbers.replaceAll(n -> n * 2);
  System.out.println(numbers); // 输出: [2, 4, 6, 8, 10]}
  

• boolean retainAll(Collection<?>c):仅保留此list中包含在指定集合中的元素

• E set(int set,E,element);修改指定位置的元素

• int size();返回此集合中的有效元素数量

• default void sort(Comparator<? super E>c):比较器，根据指定的顺序对集合进行排序

• List subList(int fromIndex,int toIndex):返回此list中fromindex(包含)和toIndex(不包含)之间的元素

• Object[] toArray() ：返回一个Object数组，其中包含此list中按正确顺序所有元素

• T[] toArray(T[] a):可返回指定类型数组，包含所有元素

• default Spliterator<[E]>**spliterator(可拆分迭代器)**在此list中的元素上创建一个 **Spliterator **

  • tryAdvance方法：可以遍历list集合

    • List<Integer> list = List.of(1,2,3,4,6,7,8);
             Spliterator<Integer> spliterator = list.spliterator();
             while (spliterator.tryAdvance(o-> System.out.print(o+" ")));
       	//输出1 2 3 4 6 7 8 
      

  • trySplit()？？？？

1.ArrayList类

• 线程不安全，初始默认容量为10，扩容比例为1.5

• 实现了Collection,Iterable,List接口

• 遍历方式：for循环，增强for循环,迭代器iterator(),forEach()方法，stream流

   ArrayList<Integer>arrayList = new ArrayList<>();
          arrayList.add(1);
          for (int i = 0; i < arrayList.size(); i++) {
              System.out.println(arrayList.get(i));
          }
          for (Integer i : arrayList) {
              System.out.println(i);
          }
          Iterator<Integer> iterator = arrayList.iterator();
          while (iterator.hasNext()){
              System.out.println(iterator.next());
          }
          arrayList.forEach(o-> System.out.println(o));
          arrayList.stream().forEach(o-> System.out.println(o));
  

ArrayList类的方法：

• clone() 重写自Object的方法:返回ArrayList的浅表副本，是一个Object类型的集合

• ensureCapacity(int miniCapacity):手动增加ArrayList容量

• equals():比较两个集合是否相等

• removeIf(Predicate<? super E> filter)：移除此集合满足给定谓词的所有元素

  	    ArrayList<Integer> arrayList = new ArrayList<>(List.of(1,2,3,4,5,6,7,8));
          arrayList.removeIf(o -> o % 2 == 0);
          for (Integer i : arrayList) {
              System.out.print(i+" ");
          }
  

• provtected removeRange(int fromIndex,int toIndex): 移除从下标fromIndex到toIndex(不包含)元素,使用时需要继承ArrayList类不方便

  public class Demo02 extends ArrayList {
      public static void main(String[] args) {
          Demo02 demo02 = new Demo02();
          demo02.add(1);
          demo02.add(2);
          demo02.add(3);
          demo02.add(4);
          demo02.add(5);
          demo02.removeRange(0,2);
          for (Object o : demo02) {
              System.out.println(o);// 3 4 5
          }
      }
  }
  

• subList(int fromIndex,int toIndex):返回标fromIndex到toIndex(不包含)的视图,与clear（）可组合使用

          ArrayList<Integer> arrayList = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8));
          List<Integer> integers = arrayList.subList(0, 3);
          integers.forEach(o-> System.out.print(o+" "));//1 2 3 
  

• trimToSize(): 将此 ArrayList 实例的容量修剪为列表的当前大小(==arrayList.size())。

• 使用remove()方法删除元素时只使用for循环与迭代器iterable()删除

2.LinkedList类

• LinkedList由链表实现。因此它插入和删除的效率比较快，但查找效率较慢，不如数组

• LinkedList继承了List接口与Deque接口，继承了AbstractSequentialList抽象类，继承关系如图：

  

• LinkedList 实现了Deque接口，LinkedList可以当作双端队列使用，由双链表实现。LIkedList实现主要由其静态内部类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;
          }
    

• LinkedList允许所有元素（包括null）

• LinkedList继承了List接口，故List中有的方法都可以使用，下面总结一下LinkedList中特有的方法

LinkedList的方法：

• void addFirst(E e): 将指定元素插入到list头部；

• void addLast(E e):将指定元素插入到list的末尾

• Iterator descendingIterator():以相反的顺序返回次双端队列的迭代器（就是反转）

• E element():检索但不删除此list头部（第一个元素）

• E getFirst():返回此list中的第一个元素

• E getLat():返回此list中的最后一个元素

• bollean offfer(E e):添加一个元素作为此list的尾部

• bollean offerFirst(E e):在此lsit前面插入一个元素

• bollean offerLast(E e):在此list的后面插入指定元素

• E peek():检索但不删除此list的头部

• E peekFirst():检索但不删除此list的头部,如果此lsit为空返回null

• E peekLast():检索但不删除此list的尾部,如果此list为空返回null

• E poll():检索并删除此list的头部

• E pollFirst():检索并删除此list的头部，如果list为空，返回null

• E pollLast():检索并删除此list的尾部，如果list为空，返回null

• E pop():从此list表的堆栈中弹出一个元素

• void push(E e):将一个元素推入此list表示的堆栈中

• E remove():检索并删除此list的头部（重写了Deque的方法remove）方法实现如下：

  • public E remove() {
         return removeFirst();
     }//调用了removeFirst()方法
    

• E removeFirst():从此list中移除并返回第一个元素

• E removeFirstOccurrence(Object o):删除次list中第一此出现的指定元素（从头到尾遍历列表时）

• removeLast():从此list中移除并返回最后一个元素

• E removeLastOccurrence(Object o):删除次list中最后一此出现的指定元素（从头到尾遍历列表时）

  • public static void main(String[] args) {
           LinkedList<Integer>list = new LinkedList<>(List.of(1,1,1,3,4,5,6,7,8,9));
           System.out.println(list);
           list.removeFirstOccurrence(1);
           System.out.println(list);
           //[1, 1, 1, 3, 4, 5, 6, 7, 8, 9]
           //[1, 1, 3, 4, 5, 6, 7, 8, 9]
       }
    

3.Vector类

• 线程安全,底层实现是一个数组，可以动态调整大小，初始容量为10，扩容比例为2倍
• 继承了AbstractList抽象类，及List, RandomAccess, Cloneable, java.io.Serializable接口，继承关系如下
• 

Vector的方法

• void addElement(E obj):将指定的组件添加到此向量的末尾，将其大小加1（将元素添加到末尾，并使其容量增加为原来有效长度的1倍）

• int capacity();返回当前容量

• void copyInto(Object[]anArray): 将当前集合中的元素复制到指定数组中

• E elementAt(int index):返回指定索引处的组件(元素)

• Enumeration elements() 返回此向量的组件的枚举（可以用来遍历数组）

  • public static void main(String[] args) {
          Vector<Integer>list = new Vector<>(List.of(1,3,4,5,6,7,8,9));
          Enumeration<Integer> elements = list.elements();
          while (elements.hasMoreElements()){
              System.out.print(elements.nextElement()+" ");
          }
          //1 3 4 5 6 7 8 9 
      }
    

• void ensureCapacity(int minCapacity): 手动控制Vector集合的容量

• boolean equals(Object o):判断两个数组是否相等

• E firstElement():返回第一个组件（索引为0处的）

• int indext(Object o,int index):返回此向量中指定元素第一次出现的索引，从index向前搜索，如果未找到该元素，返回-1

• E LastElement():返回向量的最后一个组件

• E LastIndexOf(Object o,int index):返回此向量中指定元素最后一次出现的索引，从index位向后搜索，如果未找到该元素，返回-1

• ListIterator ListIsterator(int index):返回此list的列表元素迭代器（以适当的顺序），从列表的指定位置开始。

• void removeAllElements() ：从此向量中删除所有组件并将其大小设置为零

• boolean removeElement(Object obj):从此向量中移除参数的第一个（最低索引）出现

• void removeElement(int index):删除指定索引处的组件

• boolean removeIf(Predicate<? super E>filter):移除此集合中满足给定谓词的所有元素

• void setElement(E obj,int index):将此向量指定index处的组件设置为指定对象

• void setSize(int newSize):设置此向量的大小

• void trimToSize():将此向量的容量修剪为向量的当前大小

Set接口

父接口：Collection接口与Iterable接口

set集合不包含重复元素，只能有一个null元素,插入是随机的，不能随机访问，没有get方法

set集合方法

• boolean add(E e):如果指定元素不存在，则将其添加到此集合
• boolean addAll(Collection<? extends E> c):将指定集合中所有元素添加到此集合(如果他们不存在)
• void clear() 从此集合中删除所有元素
• boolean contains(Object o):如果此集合包含指定元素，则返回true
• boolean containsAll(Collection<?>c):如果此集合包含指定集合的所有元素，则返回true
• static Set copyOf(Collection<? extends E>coll):返回包含给定Collection元素的不可修改的集合。
• boolean equals(Object o):比较指定对象与此集合是否相等
• int hashCode() 返回此集合的哈希码值
• boolean isEmpty() 如果此集合不包含任何元素，则返回true
• Iterator iterator() 返回此集合元素的迭代器
• static Set of():返回包含0个元素的不可修改的集合
• static Set of(E e1):返回包含一个元素的不可修改的集合
• static Set of(E... elements):返回任意数量元素的不可修改集合
• boolean remove(Object o):如果指定元素存在，则从该集合中移除指定元素
• boolean removeAll(Collection <?>c):从此集合中删除指定集合中包含的所有元素
• boolean retainAll(Collection <?>c):仅保留此集合中包含在指定集合中的元素
• int size():返回此集合中的元素数
• default Spliterator spliterator()在此集合中的元素上创建一个Spliterator
• Object[] toArray():返回包含此集合中所有元素的数组
• T[] toArray(T[]a):返回包含此集合中所有元素的数组，返回数组的运行时类型是指定数组的类型

1.HashSet类：

继承了AbstractSet抽象类，实现了 Set, Cloneable, java.io.Serializable接口

基于HashMap实现，不允许有重复值，允许有null值，无序，非线程安全

HashSet方法：

• Object clone():返回此 HashSet 实例的浅表副本：元素本身未被克隆。