Java-集合

Collection：

在Java类库中，集合类的基本接口是Collection接口，这个接口有两个基本方法：

public interface Collection<E>{
      boolean add(E element);
      Iterator<E> iterator();
      ...  
}   

迭代器：

public Iterator<E>{
    E next();  //反复调用next方法逐个访问集合中的每个元素
    boolean hasNext(); //调用next之前调用hasNext判断
    void remove();
} 

注：Collection接口扩展了Iterable接口，因此对于标准类库中的任何集合都可以使用"for each"循环。

java.util.Collection<E>

• Iterator<E> iterator()
  返回一个用于访问集合中每个元素的迭代器。
• int size()
  返回当前存储在集合中的元素个数。
• boolean isEmpty()
  如果集合中没有元素，返回true。
• boolean contains(Object obj)
  如果集合中包含了一个与obj相等的对象，返回true。
• boolean add(Object element)
  将一个元素添加到集合中。如果由于这个调用改变了集合，返回true。
• boolean addAll(Collection<? extends E> other)
  将other集合中的所有元素添加到这个集合。如果由于这个调用改变了集合，返回true。
• boolean remove(Object obj)
  从这个集合中删除等于obj的对象。如果有匹配的对象被删除，返回true。
• boolean removeAll(Collection<?> other)
  从这个集合中删除other集合中存在的所有元素。如果由于这个调用改变了集合，返回true。
• void clear()
  从这个集合中删除所有的元素。
• boolean retainAll(Collection<?> other)
  从这个集合中删除所有与other集合中的元素不同的元素。如果由于这个调用改变了集合，返回true。
• Object[] toArray()
  返回这个集合的对象数组。
• <T> T[] toArray(T[] arrayToFill)
  返回这个集合的对象数组。如果arrayToFill足够大，就将集合中的元素填入这个数组中，剩余空间填补null；否则，分配一个新数组，其类型与arrayToFill的成员类型相同，其长度等于集合的大小，并添入集合元素。

java.util.Iterator<E>

• boolean hasNext()
  如果存在可访问元素，返回true。
• E next()
  返回将要访问的下一个对象，若到尾部则抛出一个NoSuchElement Exception。
• void remove()
  删除上次访问的对象，这个方法必须紧跟在访问一个元素之后执行。如果上次访问之后集合已经发生了变化，这个方法将抛出一个IllegalStateException。

Java库中常用的具体集合

集合类型	描述
ArrayList	一种可以动态增长和缩减的索引序列
LinkedList	一种可以在任何位置进行高效地插入和删除操作的有序序列
TreeSet	一种有序集
LinkedHashSet	一种可以记住元素插入次序的集
PriorityQueue	一种允许高效删除最小元素的集合
HashMap	一种存储键/值关联的数据结构
TreeMap	一种键值有序排列的映射表

java中常见的三大集合类

一、List集合

其主要实现类有LinkedList、ArrayList，前者实现了链表结构，后者可代表大小可变的数组。List的特点是能够以线性的方式存储对象，并允许存放重复对象。
List能够利用Collections类的静态方法sort排序。

java.util.List<E>

• ListIterator<E> listIterator()
  返回一个迭代器列表，以便用来访问列表中的元素。
• ListIterator<E> listIterator(int index)
  返回一个迭代器列表，以便用来访问列表中的元素,其中的参数index为迭代的起始位置。
• void add(int i, E element)
  在给定位置添加一个元素。
• void addAll(int i, Collection<? extends E> elements)
  将某个集合中的所有元素添加到给定位置。
• E remove(int i)
  删除给定位置的元素并返回这个元素。
• E get(int i)
  获取给定位置的元素。
• E.set(int i, E element)
  用新元素取代给定位置的元素，并返回原来那个元素。
• int indexOf(Object element)
  返回与指定元素相等的元素在列表中第一次出现的位置，若无则返回-1。
• int lastIndexOf(Object element)
  返回与指定元素相等的元素在列表中最后一次出现的位置，若无则返回-1。

java.util.ListIterator<E>

• void add(E newElement)
  在当前位置添加一个元素。
• void set(E newElement)
  用新元素取代next或previous上次访问的元素。如果在next或previous上次调用之后列表结构被修改了，将抛出一个IllegalStateException。
• boolean hasPrevious()
  当反向返回列表时，还有可供访问的元素，返回true。
• E previous()
  返回前一个对象，如果已经到达列表的头部，就抛出一个NoSuchElementException异常。
• int nextIndex()
  返回下一次调用next方法时将返回的元素索引。
• int previousIndex()
  返回下一次调用previous方法时将返回的元素索引。
• ArrayList用例：

//ArrayList
public static void main(String[] args){
    List list = new ArrayList();
    list.add("ab");
    list.add("123");
    list.add(0, "first");
    System.out.println("存放"+list.size()+"个元素");
    list.remove(0);//删除第一个元素
    //查看集合中是否包含ab
    if(list.contains("ab")){
        System.out.println("包含元素ab");
    }
    //取出集合中第二个元素
    System.out.println("第二个元素是:"+list.get(1));
    //取出集合中所有元素
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

• LinkedList用例：

//LinkedList
public static void main(String[] args){
    LinkedList list=new LinkedList();
    //添加元素
    list.add("abc");
    list.add(123123);
    //将某个元素添加到链表的头部或尾部
    list.addFirst("1111111");
    list.addLast("22222");
    list.add("33333");
    System.out.println("元素个数:"+list.size());
    //取出第三个元素
    System.out.println("第三个元素是:"+list.get(2));
    //取链表头部或尾部的元素。
    System.out.println("第一个元素:"+list.getFirst());
    System.out.println("最后一个元素:"+list.getLast());
    //删除第一个元素
    list.removeFirst();
    for (Object object : list) {
        System.out.println(object);
    }
}

LinkedList

• LinkedList()
  构造一个空链表。
• LinkedList(Collection<? extends E> elements)
  构造一个链表，并将集合中所有的元素添加到这个链表中。
• E.removeFirst()
• E.removeLast()
  删除并返回列表的头部或尾部。

二、Map集合

其主要实现类有HashMap、TreeMap。Map对值没有唯一性要求，对健要求唯一，如果加入已有的健，原有的值对象将被覆盖。HashMap类按照哈希算法来存取键对象，可以重载equals()、hashCode()方法来比较键，但是两者必须一致。TreeMap，可自然排序，也可通过传递Comparator的实现类构造TreeMap。

java.util.Map<K, V>

• V get(Object key)
  获取与键对应的值；返回与键对应的对象，如果在映射表中没有这个对象则返回null。
• V put(K key, V value)
  将键与对应的值关系插入到映射表中。重复则会发生覆盖。这个方法将返回键对应的旧值，若这个键未曾出现过则返回null。
• void putAll(Map<? extends K, ? extends V> entries)
  将给定映射表中的所有条目添加到这个映射表中。
• boolean containsKey(Object key)
  如果在映射表中存在这个键，返回true。
• Set<Map.Entry<K, V>> entrySet()
  返回Map.Entry对象的集视图，即映射表中的键值对。可以从这个集中删除元素，同时也从映射表中删除了它们。但不能添加任何元素。
• Set(K) keySet()
  返回映射表中所以键的集视图。可以从这个集中删除元素，同时也从映射表中删除了它们。但不能添加任何元素。
• Collection<V> values()
  返回映射表中所有值的集合视图。可以从这个集中删除元素，同时也从映射表中删除了它们。但不能添加任何元素。

java.util.Map.Entry<K, V>

• K getKey()
• V getValue()
  返回这个条目的键或值。
• V setValue(V newValue)
  设置映射表中与新值对应的值，并返回旧值。
• HashMap用例：

public static void main(String[] args) {
        Map<String, Employee> staff = new HashMap<>();
        staff.put("1", new Employee("L"));
        staff.put("2", new Employee("J"));
        staff.put("3", new Employee("F"));
        //print all entries
        System.out.println(staff);
        //remove an entry
        staff.remove("1");
        //replace an entry
        staff.put("2", new Employee("R"));
        //look up a value
        System.out.println(staff.get("2"));
        //iterate through all entries
        for (Map.Entry<String, Employee> entry : staff.entrySet())
        {
            String key = entry.getKey();
            Employee value = entry.getValue();
            System.out.println("key = " + key + ", value = " + value);
        }
    }

三、Set集合

其主要实现类有HashSet、TreeSet。存放对象的引用，不允许有重复对象。

• HashSet用例：

public static void main(String[] args) {
    Set set=new HashSet();
    //添加数据
    set.add("abc");
    set.add("cba");
    set.add("abc");//故意重复
    set.add(123);
    set.add(true);
    System.out.println("集合元素个数:"+set.size());
    //遍历出集合中每一个元素
    Iterator it=set.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

1.HashSet（），调用对象的hashCode（）方法，获得哈希码，然后再集合中计算存放对象的位置。通过比较哈希码与equals（）方法来判别是否重复。所以，重载了equals（）方法同时也要重载hashCode（）方法。
2.TreeSet（），继承ShortedSet接口，能够对集合中对象排序。默认排序方式是自然排序，但该方式只能对实现了Comparable接口的对象排序，java中对Integer、Byte、Double、Character、String等数值型和字符型对象都实现了该接口。
如果有特殊排序，须重载该接口下的compareTo（）方法或通过Comparator接口的实现类构造集合。