关于Java中集合的基本使用

本人最近想把集合的基本知识再巩固一下，同时参考了相关书籍和一些博客，整合了一下。有什么错误望纠正！
集合框架图：

(1)Collection接口及实现类

Collection是最基本的集合接口，下面是Collection接口基本的方法。

Modifier and Type	Method and Description
protected Object clone()	创建并返回此对象的副本。
boolean equals(Object obj)	指示是否有其他对象“等于”这一个。
类 getClass()	返回该 Object运行时类。
protected void finalize()	当垃圾收集确定没有对对象的引用时，由对象上的垃圾收集器调用。
int hashCode()	返回一个对象的哈希代码值。
void notify()	唤醒一个在这个对象的监视器上等待的单个线程。
void notifyAll()	唤醒正在等待此对象监视器上的所有线程。
String toString()	返回对象的字符串表示形式。
void wait()	使当前线程等待另一个线程调用此对象的方法或 notify() notifyAll()方法。
void wait(long timeout)	使当前线程等待另一个线程调用此对象的方法或 notify() notifyAll()方法，或一个指定的时间流逝。
void wait(long timeout, int nanos)	使当前线程等待另一个线程调用此对象的方法或 notify() notifyAll()方法，或者其他某个线程中断当前线程，或一定量的实际时间已经过去了。

如果想要遍历里面的每个元素，可以使用iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素
Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}

1)set集合
set newset = new HashSet()或者set newset = new SortedSet()来声明。集合里面存储的元素如果是相同的字符串，那么最后不会把重复的字符串存储到set集合里。但如果集合中存储的不是字符串，而是其他元素，比如是一个类的对象，那么Set集合无法判断出怎么样的对象实例才算重复，比如：
Set set = new HashSet();
set.add(new Student(“a”,”1”));
set.add(new Student(“b”,”2”));
set.add(new Student(“a”,”1”));
System.out.println(set.toString());//此时重写了toString()方法

输出的结果是[(a,1),(b,2),(a,1)],并没有将重复的结果排除，此时你并没有告诉什么样的Student实例才算是重复，HashSet为例，会使用对象的hashCode()和equals()来判断对象是否相同。此时必须重写hashCode()方法和equals()方法。

另外HashSet和TreeSet都实现了Se接口，HashSet存储有重复的、规律性不强的数据，存储完之后可以利用TreeSet集合对HashSet的对象进行有序的排列。

import java.util.*;

public class SetExample {
  public static void main(String args[]) {
    Set set = new HashSet();
    set.add("Bernadine");
    set.add("Elizabeth");
    set.add("Gene");
    set.add("Elizabeth");
    set.add("Clara");
    System.out.println(set);
    Set sortedSet = new TreeSet(set);
    System.out.println(sortedSet);
  }
}

运行程序产生了以下输出。请注意重复的条目只出现了一次，列表的第二次输出已按字母顺序排序。
[Gene, Clara, Bernadine, Elizabeth]
[Bernadine, Clara, Elizabeth, Gene]

2)List接口
List 接口继承了 Collection 接口以定义一个允许重复项的有序集合。ArrayList是基于数组实现的，在调整索引顺序时表现较差，但是随机访问数据的速度比较快。LinkedList是采用链式结构的，数据之间是通过指针相连接，适合在链表中频繁的插入和删除操作。

3)Queue接口
如果希望手机对象时可以以队列的方式，收集的对象加入至尾端，取得对象时可以从前端，则可以使用Queue接口的操作对象。Queue也是继承自Collection，所以也具有Collection的add()、remove()、element()等方法，而Queue定义了自己的offer()、poll()、peek()等方法，最主要的差别在于Collection的上述方法操作失败时会抛出异常，而Queue的上述方法操作失败时会返回特定的值。LinkedList也实现了Queue接口，所以也可以通过Queue reques = new LinkedList()的方式来创建Queue对象。具体方法中，offer()用来在队列后端加入对象，成功则返回true，失败则返回false。poll()用于取出队列的前端对象，若队列为空，则返回null，并且返回取出来的对象。peek()用来浏览队列前端对象（不取出），若队列为空返回null。
Queue的子接口Deque进一步添加了一些操作，可以在前端加入与取出对象，在尾端加入与取出对象。具体的方法有addFirst(),removeFirst(),getFirtst(),addLast(),removedLast(),getLast()。Deque可以使用Deque de = new ArrayDeque()的方式创建对象。

(2)Map接口及其实现类

Map集合:
Map提供了一种映射关系，其中的元素是以键值对（key-value）的形式存储的，一个key值只能对应一个value，一个value可以对应多个key。
首先是通过put的方法将键值对存进Map集合中，可以使用entrySet()方法来同时取得Map的键与值。

import java.util.HashMap;
import java.util.Map;
public class map {
      public static void main(String[] args)
      {
          Map<String,String> map = new HashMap<>();
          map.put("one", "一");
          map.put("two","二");
          map.put("three", "三");

          Set entries = map.entrySet();
          for(Object o:entries)
          {
              Map.Entry entry = (Entry) o;
              String key = (String) entry.getKey();
              String value = (String) entry.getValue();
              System.out.println("键："+key);
              System.out.println("值："+value);
          }
      }
}

其次如果是想取得Map中所有的键，可以使用Map的keySet()方法返回Set对象，如果想取得Map中所有的值，可以使用values()方法返回Collection对象。

import java.util.HashMap;
import java.util.Map;
public class map {
      public static void main(String[] args)
      {
          Map<String,String> map = new HashMap<>();
          map.put("one", "一");
          map.put("two","二");
          map.put("three", "三");

          System.out.println("键是：");
          foreach(map.keySet());
          System.out.println("值是：");
          foreach(map.values());
      }
      public static void foreach(Iterable<String> iterable)
      {
          for(String element : iterable)
          {
              System.out.println(element);
          }
      }
}

下面给出基本的map取键和值的方法：

package jiheTest;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class map {

public static void main(String[] args) {
    Map<String,String> map = new HashMap<String,String>();
    map.put("lin", "男");
    map.put("xiong", "男");
    map.put("cheng", "男");
    map.put("jiao", "男");
    map.put("shuai", "男");
    map.put("zhao", "男");
    map.put("yuan", "男");

    //第一种遍历map的方法，通过加强for循环map.keySet(),然后通过通过对应的key获取到value的值
    for(String s:map.keySet())
    {
        System.out.println("key :"+s+" value:"+map.get(s));
    }
    System.out.println("----------------------");


    //第二种遍历键和值
    for(String s1:map.keySet())
    {
        System.out.println("key :"+s1);
    }
    for(String s2:map.values())
    {
    System.out.println("value :"+s2);   
    }
    System.out.println("-------------------------");


    //第三种方式Map.Entry<Sring,String>的加强for循环遍历输出键key和值value
    for(Map.Entry<String, String> entry : map.entrySet())
    {
        System.out.println("键key:"+entry.getKey()+"值value :"+entry.getValue());
    }
    System.out.println("----------------------");

    //第四种方式Iterator遍历获取，然后获取到Map.Entry<String,String>,再得到getKey()和getValue()
    Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();
    while(it.hasNext())
    {
        Map.Entry<String, String> entry = it.next();
        System.out.println("key :"+entry.getKey()+" value"+entry.getValue());
    }
    System.out.println("----------------------");
}

}

总之就是map的keySet()方法可以得到键的集合，values()方法可以得到值的集合，entrySet()可以得到键值对的集合

另外常用的Map操作类为java.util.HashMap与java.util.TreeMap。在HashMap中建立键值对应之后，键是无序的。如果想要使键有序，那么可以使用TreeMap建立键值对应，则键的部分将会排序，条件是作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定操作Comparator接口的对象，重写里面的Comparator方法，可以根据自己想要的键值进行排序。

import java.util.TreeMap;
import java.util.Comparator;
//正常情况下如果键值是字符串时会自动根据字典顺序排列。
        TreeMap<String,String> tm1 = new TreeMap<String, String>();
        tm1.put("d", "1");
        tm1.put("c", "2");
        tm1.put("a", "3");
        tm1.put("e", "4");
        System.out.println("tm1"+tm1);

        //指定排序器
        TreeMap<String,String> tm2 = new TreeMap<String, String>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        }); 

        tm2.put("d", "1");
        tm2.put("c", "2");
        tm2.put("a", "3");
        tm2.put("e", "4");
        System.out.println("tm"+tm);

输出结果：
tm1{a=3, c=2, d=1, e=4}
tm2{e=4, d=1, c=2, a=3}

（3）Iterator接口及实现类
辅助工具类
Collections、Arrays类
Collections、Arrays是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中 元素进行排序、查找等各种操作。
Comparable、Comparator接口
一般是用于对象的比较来实现排序，两者略有区别
Comparable用作默认的比较方式，实现了该接口的类之间可以相互进行比较，这个对象组成的集合就可以直接通过sort()进行排序了。
Comparator是设计模式中策略模式的一种应用。将算法的实现和数据进行了分离。
一般用在如下情况下：
1、类设计者没有考虑到比较问题而没有实现Comparable接口。这是我们就可以通过使用Comparator，这种情况下，我们是不需要改变对象的。
2、一个集合中，我们可能需要有多重的排序标准，这时候如果使用Comparable就难实现了可以实现Comparator提供多种标准的比较器进行排序。
参考博客：
1) Java集合学习-集合框架浅析
2)java集合类详解
3)Map集合遍历的四种方式理解和简单使用