Java 集合框架 : Collection、Map

1. Collection接口是Java集合框架的基本接口，所所有集合都继承该接口。

　　1.1 方法 ：

    public interface Collection<E> extends Iterable<E> {
        //向集合添加元素，成功返回true，失败返回false
        boolean add(E e);
        //用于返回一个实现了Iterator接口的对象。
        Iterator<E> iterator();
        ...
    }

　　1.2 Iterator 迭代器

    public interface Iterator<E> {
        //如果迭代器对象还有很多元素访问，返回true，
        boolean hasNext();
        //逐个访问集合中的每个元素，达到集合的末尾，
        //会抛出NoSuchElementException
        E next();

        default void remove() {
            throw new UnsupportedOperationException("remove");
        }

        default void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (hasNext())
                action.accept(next());
        }
    }

　　1.3 遍历集合

　　　　方法1：用迭代器

        Collection<String> c = ...;
        Iterator<String> iterator = c.iterator();
        while (iterator.hasNext()){
            //iterator.next() 越过一个元素，并返回刚刚越过的那个元素
            String element = iterator.next();
            //在调用过next方法之后，才可以调用remove()方法，
            // 来删除刚刚越过的那个元素
            iterator.remove();
            ...
        }

　　　　方法2：用for each

        Collection<String> c = ...;
        for (String element : c){
            do something with "element"...
        }

　　　　方法3：java8 lambda表达式 forEachRemaning()

        Collection<String> c = ...;
        Iterator<String> iterator = c.iterator();
        iterator.forEachRemaining( ele -> {
            do something with "element"...
        });

　　　　※ 在删除元素时还可以调用一个更简单的方法：

        Collection<String> c = ...;
        c.removeIf(ele -> {
            if (ele ...){
                return true;
            }else {
                return false;
            }
        });

2. List 有序集合

　　遍历元素的方法：

　　2.1 迭代器访问 ：适用链表结构集合

　　2.2 整数索引访问——又称随机访问 ：数组结构的集合

　　2.3 ArrayList 数组结构 从中删除一个元素，之后所有的元素都要向前移动，开销很大，增加元素同理。

　　2.3 LinkedList 链表结构 ，每个元素存储在独立的节点中，每个节点都有指向前一个元素和后一个元素的引用。

3.Set集 

　　3.1 HashSet 散列集，实现了基于散列表的集 ，位置随机，无序集合。

　　　　add() 

　　　　contains() 用来查看某个元素是已经存在集中。

　　3.2 TreeSet 树集 ，有序集合。树结构（红黑树 red-black tree）

import java.util.*;

/**
 * This program sorts a set of item by comparing their descriptions.
 * @version 1.12 2015-06-21
 * @author Cay Horstmann
 */
public class TreeSetTest
{
   public static void main(String[] args)
   {
      SortedSet<Item> parts = new TreeSet<>();
      parts.add(new Item("Toaster", 1234));
      parts.add(new Item("Widget", 4562));
      parts.add(new Item("Modem", 9912));
      System.out.println(parts);

      NavigableSet<Item> sortByDescription = new TreeSet<>(
            Comparator.comparing(Item::getDescription));

      sortByDescription.addAll(parts);
      System.out.println(sortByDescription);
   }
}

 

import java.util.*;

/**
 * An item with a description and a part number.
 */
public class Item implements Comparable<Item>
{
   private String description;
   private int partNumber;

   /**
    * Constructs an item.
    * 
    * @param aDescription
    *           the item's description
    * @param aPartNumber
    *           the item's part number
    */
   public Item(String aDescription, int aPartNumber)
   {
      description = aDescription;
      partNumber = aPartNumber;
   }

   /**
    * Gets the description of this item.
    * 
    * @return the description
    */
   public String getDescription()
   {
      return description;
   }

   public String toString()
   {
      return "[description=" + description + ", partNumber=" + partNumber + "]";
   }

   public boolean equals(Object otherObject)
   {
      if (this == otherObject) return true;
      if (otherObject == null) return false;
      if (getClass() != otherObject.getClass()) return false;
      Item other = (Item) otherObject;
      return Objects.equals(description, other.description) && partNumber == other.partNumber;
   }

   public int hashCode()
   {
      return Objects.hash(description, partNumber);
   }

   public int compareTo(Item other)
   {
      int diff = Integer.compare(partNumber, other.partNumber);
      return diff != 0 ? diff : description.compareTo(other.description);
   }
}

 4. Deque 双端队列，

　　4.1 ArrayDeque、LinkList

　　4.2 java.util.Queue<E> 

        boolean add(E element); //添加元素到队尾，返回true，如果队列已满，返回false
        boolean offer(E element);//添加元素到队尾，返回true，如果队列已满，抛出IllegalStateException
        E remove() // 删除并返回这个队列的头部元素，队列空，抛出NoSuchElementException
        E poll() //删除并返回这个队列的头部元素，队列空，返回null
        E element() // 返回队列的头部元素，队列空，则抛出NoSuchElementException
        E peek() //返回队列的头部元素，队列空，返回null

　　4.3 PriorityQueue 优先级队列

　　　　优先级队列中的元素可以按照任意的顺序插入，但总是按照排序的顺序进行检索，无论何时调用remove() 方法，总会获得当前队列中优先级最小的元素

　　　　......

5. HashMap 散列映射、TreeMap 树映射 ，

　　散列映射对键值进行散列，树映射用键的整体顺序对元素进行排序，并将其组织成搜索树，散列或比较函数只能作用于键。与键关联的值不能进行散列或比较。

　　无排序要求的话 选择散列映射，速度快。

　　5.1 遍历集合 

　　for each遍历

        Map<String,Object> hashMap = new HashMap<>();
        hashMap.put("name","Jack");
        hashMap.put("dept","开发部");
        hashMap.put("Sal",4000);
        //foreach遍历
        for (Map.Entry<String,Object> ele : hashMap.entrySet()){
            String key = ele.getKey();
            Object val =  ele.getValue();
            System.out.print(key +"=" + val +",");
        }

　　for each + lambda表达式遍历

        //Lambda表达式遍历
        hashMap.forEach((k,v) -> {
            System.out.print(k + "=" + v + ",");
        });