java集合学习笔记

1. 基本概念

java容器类类库的用途是“保存对象”，可以分为Collection和Map两种体系
1.collection 一个独立元素的序列，这些元素都服从一条或多条规则。Collection（可以有序/无序，可重复/不可重复 等，具体依据具体的子接口Set，List，Queue等）

• List： 按照插入的顺序保存元素，可重复的集合
  - ArrayList
  - LinkedList
• Set元素无序，不可重复的集合
  
  • HashSet 使用相当复杂的方式存储元素，是最快获取元素的方式
  • TreeSet 按照比较结果的升序保存对象
  • LinkedHashSet 按照添加的顺序保存对象
  • queue按照排队规则来确定对象产生的顺序（通常与它们被插入的顺序相同）在一端插入元素，一端删除元素

2.Map 一组成对的键值对对象，允许使用关键字查找值。
- HashMap最快的查找技术
- TreeMap 按照比较结果的升序存储键
- LinkedHashMap 按照插入的顺序保存键，同时保留HashMap的查找速度

collection 方法摘要

boolean add(E e) //确保此collection包含指定的元素
boolean addAll(Collection<? extends E>c) //将指定collection中的所有元素都添加到此collection中
void clear() //移除此collection中的所有元素
boolean contains(Object o)//如果此collection中包含指定元素，则返回true;根据元素所在类的equals()方法进行判断,如果是自定义对象，重写equals()方法
boolean containsAll(Collection<?> c)//如果此collection包含指定collection中的所有元素，则返回true;
boolean equals(Object o)//比较此collection与指定对象是否相等
boolean isEmpty() //若为空，则返回true
boolean remove(Object o)
boolean removeAll(Collection<?> c) //从当前集合中删除包含在参数中的元素，及差集
boolean retainAll(Collection<?> c)//仅保留此collection中那些也包含在指定collection中的元素；返回结果给当前集合。
Object[] toArray() 将集合转化为数组，返回包含此collection中所有元素的数组
<T> T[] toArray(T[] a) //返回包含此collection中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

List中新增加的方法

void add(int index,Object element)//在指定的索引位置index添加元素element
Object get(int index)//获取指定索引index的元素
boolean addAll(int index,Collection eles)
Object remove(int index)
Object set(int index,Object element) //设置指定索引位置的元素为element
List subList(int fromIndex,int toIndex) 
int indexOf(Object obj)//返回Obj在集合中首次出现的位置。没有的话，返回-1
int lastIndexOf(Object obj)//返回obj在集合中最后一次出现的位置。如果没有的话，返回-1

2. 添加一组元素

public class AddingGroups {
    public static void main(String[] args){
        //Collection的构造器接受另一个Collection来将自己初始化
        //Arrays.aslist()方法接受一个数组或者逗号分隔元素列表，并将其转换为一个List
        Collection<Integer> collection=
          new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));
        Integer[] moreInt={6,7,8,9};
        //Collection.addAll()只接受另一个Collection对象作为参数
        collection.addAll(Arrays.asList(moreInt));
        //Collections.addAll()方法接收一个Collection对象，和数组或用对号分隔的列表，
        //将元素添加到Collection中
        Collections.addAll(collection, moreInt);
        Collections.addAll(collection, 10,11,12,13);
        List<Integer> lists=Arrays.asList(14,15,16);
        lists.set(0, 10);
        //运行时异常，Arrays.asList()的输出，将其当做list，
        //但是在这种情况下，其底层表示是数组，不能改变尺寸的大小
        //lists.add(17);
    }
}

Arrays.asList(）和Collections.addAll()方法使用可变参数列表；

3. Iterator

迭代器是一个对象，遍历并选择序列中的对象；常被称为“轻量级对象”，创建它的代价小；将遍历序列的操作与序列底层的结构分离，统一了对容器的访问方式；java中的Iterator 只能单向移动；迭代器指向的位置是元素之前的位置。
- 使用iterator()要求容器返回一个Iterator;
- next() 获得序列中的下一个元素；输出并下移
- hasNext()检查是否还有元素；
- remove()将迭代器新近返回的元素删除；
如果只是向前遍历List,但是并不打算修改List对象本身，foreach语法会更加简洁；

ListIterator

ListIterator没有当前元素，它的光标位置始终位于调用previous()所返回的元素和调用next()所返回的元素之间

 void add(E e);//将指定的元素插入列表；
 boolean hasNext(),正向遍历列表，若列表迭代器有多个元素，则返回true;
 boolean hasPrevious()// 逆向遍历列表，若列表迭代器存在多个元素，则返回true;
 int nextIndex() //返回对 next 的后续调用所返回元素的索引;
 E previous() //返回列表的前一个元素
 int previousIndex() //返回对previous的后续调用所返回的元素索引；
 void remove() //从列表移除由next 或previous返回的最后一个元素；
 void set(E e) //用指定元素替换next或previous返回的最后一个元素；

remove()和set(Object) 方法不是根据光标位置定义的，而是根据对调用next()或pervious()所返回的最后一个元素的操作定义的。

两者区别

1. ListIterator实现了Iterator接口，幷包含其他的功能，如：增加元素、替换元素、获取前一个和后一个元素及索引等
2. Iterator可以用来遍历Set和List集合，ListIterator只能用来遍历List.
3. 都可以实现删除对象，但是ListIterator借助set()方法实现对象的修改，Iterator不能修改；

4. LinkedList

LinkedList执行某些操作（List中间的插入和删除操作）比ArrayList高效；

 boolean add(E e) //将指定的元素添加到此列表的结尾
 E element()  //获取但不移除此列表的头
 E get(int index) //返回此列表中指定位置处的元素
 boolean offer(E e) //将指定元素添加到列表的末尾
 E peek()  //获取但不移除列表的头
 E Poll()  //获取并移除此列表的头
 E remove() //获取并移除此列表的头（第一个元素）

getFirst()和element() 相同，若List为空，则抛出NoSuchElementException。 peek()在列表为空时返回null;

removeFirst和remove() 方法相同，在List为空时抛出NoSuchElementException。 pool()在列表为空时返回null;

import java.util.*;
/*
 * 创建一个空的LinkedList<Integer>，通过使用ListIterator，
 * 将若干个Integer插入到这个list中，总是在中间位置插入
 */
public class E14_MiddleInsertion {
    public static void main(String[] args){
        LinkedList<Integer> list=new LinkedList<>();
        ListIterator<Integer> iterator=list.listIterator();
        for(int i=1;i<=10;i++){
            iterator.add(i);
            if(i%2==0)
                iterator.previous();
        }
        System.out.print(list); 
    }
}

5. Stack

java.util中没有任何公共的Stack接口
ArrayList实现自List接口（队列结构），JDK没有直接提供Stack结构的接口，JDK的java.util.Stack类是从Vector继承而来，Vector已过时，主要用于容量增加算法和同步以及方法冗余，同Stack、HashTable正在被淘汰，更明智的做法是用LinkedList取代Stack。

import java.util.LinkedList;

public class Stack<T> {
    private LinkedList<T> storage=new LinkedList<T>();
    public void push(T t){storage.addFirst(t);}
    public T peek(){return storage.getFirst();}
    public T pop(){return storage.removeFirst();}
    public boolean empty(){return storage.isEmpty();}
    public String toString(){return storage.toString();}
}

6. Set

不保存重复的元素，常用来查询某个元素是否在set中

SortedSet 是一个接口，元素按照自然顺序进行排序，或者根据在创建有序set时提供的Comparator进行排序。插入有序set的所有元素必须实现Comparable接口（或者被指定的比较器接受），并且，所有的这些元素都是可以相互比较的。
所有通用有序set实现类都应该提供4个“标准”构造方法：
1. void构造方法，创建一个空的有序set, 按照元素的自然顺序进行排序；
2. 带有一个Comparator类型参数的构造方法，它创建一个空的有序set，根据指定的比较器进行排序；
3. 带有一个Collection类型参数的构造方法，创建一个新的有序set, 其元素与参数相同，按照元素的自然顺序进行排序；
4. 带有一个SortedSet类型参数的构造函数，创建一个新的有序set，其元素和排序方法与输入的有序set相同，无法保证强制实施此建议，因为接口不能包含构造方法；

HashSet : 通过使用散列法来存储信息，元素并没有以某种特定的顺序存放；
LinkedHashSet： 使用链表来维护元素的插入顺序，因为查询速度原因也使用了散列；
TreeSet: 元素存储在红黑树存储结构中，对象以升序存储，访问和遍历的时间很快；