集合的方法

 

为什么引用集合？

1、数组可以用来存储多个对象，但是对于对象的增删改操作确实是非常麻烦的
2、数组和集合的区别
 长度：数组的长度固定不变的
          集合长度是可以根据实际需要改变
 内容：数组存储的是同一种类型的元素
          集合可以存储不同类型的元素
          数据类型：数组可以存储基本数据类型，也可以存储引用数据类型
          集合只能存储引用类型
注意：虽然集合不能存储基本数据类型，但是可以存储基本数据类型的包装类类型

 

集合的设计：因为集合有很多增删查改的方法，而且集合是一套框架，既然是框架，那么每一种集合处理增加删除修改遍历的方式不一样。

 *  Collection的特点
 *   1.部分集合是有序的，部分集合是无序的，这里的有序指的是存储有序
 *   2.部分集合是可排序的，部分集合是不可排序
 *   3.部分集合是可重复的，部分集合是不可重复，唯一的

集合的特点:
 1.长度可变的
 2.能够存储任意的引用类型
 3.具备很多对对象进行增删查改的方法
 4.集合也能够存储基本类型的包装类类型，更加扩展了int的一些功能

集合的功能方法：
 * 1.添加功能
 *  boolean add(Object obj)
 *  boolean addAll(Collection c)
 * 2.删除功能
 *   void clear()
 *   boolean remove(Object o)
 *    boolean removeAll(Collection<?> c)
 remove方法依赖于next（）、previous（）方法才能使用，否者报错。
 * 3.修改功能
   set（index，new一个新的对象，替换指定位置的对象 ）
 * 4.遍历功能
 *   Object[] toArray()
 *  Iterator<E> iterator()
 *   <T> T[] toArray(T[] a)

 增强for --------格式for(元素数据类型   变量 : 数组或者集合) {。。。}    　　//简化遍历，但无法获取数组或者集合的索引，可能出现并发修改异常

 boolean hasNext(); 判断是否有下一个元素
 E next(); 获取下一个元素，并且指针指向下一个元素的位置
 迭代器的原理：在获取迭代器的时候，会创建一个集合的副本，同时创建一个指针指向迭代器迭代集合的起始位置。
 * 5.判断功能
 *  boolean contains(Object o)
 *   boolean containsAll(Collection<?> c)
 *   boolean isEmpty()
 * 6.其他功能
 *   boolean retainAll(Collection<?> c)
 * 7.获取集合长度的功能
 *   int size()

 

 

List接口
List list = new ArrayList();
特点：  1、集合是有序的（存储有序）
 2、有索引，方便查找和修改
 3、List集合可重复
 4、允许存储null值
所有方法：
 * 1.添加功能
 *  boolean add(Object obj)
 *  boolean addAll(Collection c) 
 *   void add(int index, E element)
 *   boolean addAll(int index, Collection<? extends E> c)
 * 2.删除功能
 *  void clear()
 *   boolean remove(Object o)
 *   boolean removeAll(Collection<?> c) 
 *   Object remove(int index)
 *   boolean remove(Object o) 

 * 3.修改功能
 *   Object set(int index, E element)
 * 4.遍历功能
 *   Object[] toArray()
 *  Iterator<E> iterator()
 *   <T> T[] toArray(T[] a) 
 *   ListIterator<E> listIterator()
 *   ListIterator<E> listIterator(int index)
 * 5.判断功能
 *  boolean contains(Object o)
 *   boolean containsAll(Collection<?> c)
 *   boolean isEmpty() 
 * 6.其他功能
 *   boolean retainAll(Collection<?> c)
 * 7.获取集合长度的功能
 *   int size()
 * 8.获取功能
 *  int indexOf(Object o)
 *   Object get(int index)
 *   int lastIndexOf(Object o)
 *   List subList(int fromIndex, int toIndex)

 

ListIterator接口是List特有的迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
ListIterator lit = list.listlterator();

void add(E e) 　　将指定的元素插入列表（可选操作）。

 
boolean hasNext()　　返回 true如果遍历正向列表，列表迭代器有多个元素。 

boolean hasPrevious()  　　返回 true如果遍历反向列表，列表迭代器有多个元素。 

E next() 返回列表中的下一个元素，并且前进光标位置。
   
int nextIndex()　　 返回随后调用 next()返回的元素的索引。
   
E previous() 　　 返回列表中的上一个元素，并向后移动光标位置。
   
int previousIndex() 　　返回由后续调用 previous()返回的元素的索引。 

void remove() 　 从列表中删除由 next()或 previous()返回的最后一个元素（可选操作）。

 
void set(E e) 用 指定的元素替换由 next()或 previous()返回的最后一个元素（可选操作）。
 

 * 数据结构: 数据的存储方式
 * 和集合相关的数据结构: 数组 栈 队列 链表 哈希表 二叉树

 

ArrayList方法
ArrayList list = new ArrayList();
底层数据结构是数组，插入和移除性能较差，线程安全，效率低

boolean add(E e) 将指定的元素追加到此列表的末尾。 
 
void add(int index, E element)  在此列表中的指定位置插入指定的元素。
  
boolean addAll(Collection<? extends E> c) 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。 
 
boolean addAll(int index, Collection<? extends E> c)  将指定集合中的所有元素插入到此列表中，从指定的位置开始。
  
void clear() 从列表中删除所有元素。
   
Object clone() 返回此 ArrayList实例的浅拷贝。
   
boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。
   
void ensureCapacity(int minCapacity) 如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。
   
void forEach(Consumer<? super E> action) 对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
   
E get(int index) 返回此列表中指定位置的元素。
   
int indexOf(Object o)  返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
  
boolean isEmpty() 如果此列表不包含元素，则返回 true 。 

Iterator<E> iterator()  以正确的顺序返回该列表中的元素的迭代器。
  
int lastIndexOf(Object o)  返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
  
ListIterator<E> listIterator()  返回列表中的列表迭代器（按适当的顺序）。
  
ListIterator<E> listIterator(int index) 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。 
 
E remove(int index)  删除该列表中指定位置的元素。
  
boolean remove(Object o)  从列表中删除指定元素的第一个出现（如果存在）。
  
boolean removeAll(Collection<?> c)  从此列表中删除指定集合中包含的所有元素。 

boolean removeIf(Predicate<? super E> filter)  删除满足给定谓词的此集合的所有元素。 
 
protected void removeRange(int fromIndex, int toIndex)  从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。
  
void replaceAll(UnaryOperator<E> operator) 将该列表的每个元素替换为将该运算符应用于该元素的结果。
   
boolean retainAll(Collection<?> c)  仅保留此列表中包含在指定集合中的元素。
  
E set(int index, E element)  用指定的元素替换此列表中指定位置的元素。
  
int size()  返回此列表中的元素数。
  
void sort(Comparator<? super E> c) 使用提供的 Comparator对此列表进行排序以比较元素。
   
Spliterator<E> spliterator() 在此列表中的元素上创建late-binding和故障快速 Spliterator 。
   
List<E> subList(int fromIndex, int toIndex) 返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
   
Object[] toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 
  
<T> T[] toArray(T[] a) 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
   
void trimToSize()  修改这个 ArrayList实例的容量是列表的当前大小。 

 

Vector特有的功能
Vector vector = new Vector();
类似于ArrayList，底层数据结构是数组，插入和移除性能较差，线程安全，效率低。

 

void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。
   
E elementAt(int index)  返回指定索引处的组件 。

Enumeration<E> elements() 返回此向量的组件的枚举。
   

 

 * LinkedList
　　

LinkedList list = new LinkedList();
 * 特点
 *  1.底层数据结构是链表
 *   2.链表的特点有序，查询和修改效率低，增加和删除效率高
 *  3.可以存储null值
 *   4.线程不安全
 *   5.允许重复
 *   6.不可排序

Linkedlist特有的方法
void addFirst(E e) 在该列表开头插入指定的元素。
 
void addLast(E e)  将指定的元素追加到此列表的末尾

E getFirst()  返回此列表中的第一个元素。

E getLast()  返回此列表中的最后一个元素。

E removeFirst() 从此列表中删除并返回第一个元素。
  
E removeLast() 从此列表中删除并返回最后一个元素。 
 

 * Stack类
Stack stack = new Stack();
 * 方法:
 *   boolean empty() 测试堆栈是否为空。
                  
  E peek()     查看堆栈顶部的对象，但不从堆栈中移除它。
       
  E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
          
  E push(E item) 把项压入堆栈顶部。
           
  int search(Object o) 返回对象在堆栈中的位置，以 1 为基数。
          

 

泛型的概念: 在编译时期就确定的类型的一种技术
泛型是一种参数化类型，在JDK1.5之后引入的新特性，是一种将引用类型当做参数传递的参数化类型，在编译时期就已经确定了集合存储的元素类型

 *  格式:
 *   <数据类型> 这里的类型必须是引用类型
 *  泛型一般用于集合

 *  泛型的好处:
 *   1.提高了程序的安全性
 *   2.消除了黄色警告线
 *   3.在编译时期将类型确定，减少不必要的强转代码

泛型根据放置的位置不同分为------泛型类、泛型方法、泛型接口
 * 泛型通配符

 *       ?  : 表示任意类型
 *  ? extends E : 向下限定符  E或者E的子类
 *  ? super E : 向上限定符 E或者E的父类
 * 
 * 泛型限定符的应用
 * boolean addAll(Collection<? extends E> c)

 

 

Set接口：一个不包含重复元素的 collection。
Set集合特点：集合元素不重复、存储无序
Set<String> set = new HashSet<String>();

 

 

HashSet类概述
HashSet<Integer> hs = new HashSet<Integer>();
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
此类允许使用null元素。
HashSet保证元素唯一。
底层数据结构是哈希表，哈希表依赖于哈希值存储
添加元素时保证元素唯一，本质底层依赖两个方法：
 int hashCode()
 boolean equals(Object obj)

 

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

排序方式完全取决于使用的构造方法。（当调用的是无参构造时是自然排序，调用有参构造时是比较器排序）
使用元素的自然顺序对元素进行排序（自然排序）
TreeSet<Student> ts = new TreeSet<Student>() ；
根据创建 set 时提供的 Comparator 进行排序（比较器排序）
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>()；

LinkedHashSet类概述：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现、由链表保证元素有序、由哈希表保证元素唯一
LinkedHashSet<引用类型> s = new LinkedHashSet<>();

 

Map集合
Map<String, String> map = new HashMap<String, String>();
 Map集合提供了集合之间一种映射关系，让集合和集合之间产生关系

 * Map集合的特点
 *  1.能够存储唯一的列的数据(唯一，不可重复) Set
 *  2.能够存储可以重复的数据(可重复) List
 *  3.值的顺序取决于键的顺序
 *  4.键和值都是可以存储null元素的

 

一个映射不能包含重复的键。每个键最多只能映射到一个值。

 

 * 常用功能
 * 1.添加功能
 *  V put(K key, V value)
 *  void putAll(Map<? extends K,? extends V> m)
 * 2.删除功能
 *  V remove(Object key)
 *  void clear()
 * 3.遍历功能
 *  Set<K> keySet()
 *  Collection<V> values()
 *  Set<Map.Entry<K,V>> entrySet()
 * 4.获取功能
 *  V get(Object key)
 * 5.判断功能
 *  boolean containsKey(Object key)
 *  boolean containsValue(Object value)
 *   boolean isEmpty()
 * 6.修改功能
 *  V put(K key, V value)
 *  void putAll(Map<? extends K,? extends V> m)
 * 7.长度功能
 *  int size()