Collection集合 框架图 及 Collections帮助类

    目录：

    一. Collection集合 框架图

    二. MAP框架图

    三. Collections帮助类

    四. 自定义对List/Map进行排序

    五. 对ArrayList进行初始化

一. Collection集合 框架图

    查看了一些资料将Collection接口及Map接口的框架总结如下，方便以后学习使用。

    java.util.Collection接口

   

 

二. MAP框架图

    参考：http://www.chawenti.com/articles/20110.html

   

    Hashtable（同步）没有自定义哈希算法，而直接采用的key的hashCode()。

    HashMap（非同步）添加元素时，是使用自定义的哈希算法。

    TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。
    TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。
    TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
    TreeMap 实现了Cloneable接口，意味着它能被克隆。
    TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。

    TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
    TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。
    另外，TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。

三. Collections帮助类

    Collections是个类，不是接口，是一个为集合提供处理功能的工具类/帮助类。

    1. 对List进行升序排序。public static void sort(List list)

    列表中的所有元素都必须实现 Comparable接口。此列表内的所有元素都必须是使用指定比较器可相互比较的。

double array[] = {112, 111, 23, 456, 231 };  
for (int i = 0; i < array.length; i++) {
    list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = 0; i < array.length; i++) {
  System.out.println(li.get(i));
}
//结果：112,111,23,456,231

    如果要降序排列，可以在sort函数中指定降序。可以选择：public static void sort(List list, Comparator c)，其中，参数可以用java.util.Collections的reverseOrder()方法返回。

    2. 返回指定collection中等于指定对象的元素数。public static int frequency(Collection c, Object o)

    3. 判断两个指定collection中有无相同的元素。public static boolean disjoint(Collection c1, Collection c2)

    4. 寻找集合中的最大/最小值。public static Object max/min(Collection coll)

double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
    list.add(new Double(array[i]));
}
Collections.max(list);
for (int i = 0; i <list.size(); i++) {
    System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：456

    5. 对于集合中的元素进行 替换。public static boolean replaceAll(List list, Object oldVal, Object newVal)

    6. 混排

    混排算法所做的正好与 sort 相反： 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List，这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的Card 对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。

double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
    list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = 0; i < array.length; i++) {
    System.out.println(li.get(i));
}
//结果：112,111,23,456,231

    7. 反转

    使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。

Collections.reverse(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
    list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = 0; i < array.length; i++) {
    System.out.println(li.get(i));
}
//结果：231,456,23,111,112

 

    8. 替换所有的元素

String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j<str.length;j++){
    li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = 0; i < li.size(); i++) {
    System.out.println("list[" + i + "]=" + li.get(i));

}
//结果：aaa,aaa,aaa,aaa,aaa

    9. 拷贝（copy）

    用两个参数，一个目标 List 和一个源 List， 将源的元素拷贝到目标，并覆盖它的内容。目标 List至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
    list.add(new Double(array[i]));
}
double arr[] = {1131,333};
for(int j=0;j<arr.length;j++){
    li.add(new Double(arr[j]));
}
Collections.copy(list,li);
for (int i = 0; i <list.size(); i++) {
    System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：1131,333,23,456,231

    10. lastIndexOfSubList

    返回指定源列表中最后一次出现指定目标列表的起始位置。

        List list = new ArrayList();
        List li = new ArrayList();
        int count = Collections.lastIndexOfSubList(list,li);
        double array[] = {112, 111, 23, 456, 231 };
        
        for (int i = 0; i < array.length; i++) {
        list.add(new Double(array[i]));
        }
        double arr[] = {111};
        String str[] = {"dd","aa","bb","cc","ee"};
        for(int j=0;j<arr.length;j++){
        li.add(new Double(arr[j]));
        }
        int locations = Collections. lastIndexOfSubList (list,li);
        System.out.println(" == "+ locations);
        //结果 1

    11. indexOfSubList

    返回指定源列表中第一次出现指定目标列表的起始位置。

    12. Rotate

    根据指定的距离循环移动指定列表中的元素。

    Collections.rotate(list,-1);

    如果是负数，则正向移动，正数则方向移动

double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
    list.add(new Double(array[i]));
}
Collections.rotate(list,-1);
for (int i = 0; i <list.size(); i++) {
    System.out.println("list[" + i + "]=" + list.get(i));
}
//结果：111,23,456,231,112

    这一部分参考链接：http://blog.csdn.net/lskyne/article/details/8961014

   

    13. unmodifiableMap

    用于实现一个不可修改的Map

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class CreateMap {
    private static Map<String, String> map;
    static {
        // 按照存入顺序的Map
        map = new LinkedHashMap();
        map.put("key1", "value1");
        map.put("key3", "value3");
        map.put("key2", "value2");
    }

    public static void main(String[] args) {
        CreateMap cm = new CreateMap();
        cm.map.put("test", "test");
        // java中提供了很多方法都可以实现对一个Map的复制，但是那些方法不见得会时时同步。
        // 简单说，就是一个Map发生的变化，而复制的那个依然保持原样。下面是一个比较高效的实现方法
        Map<String, String> copiedMap = Collections.synchronizedMap(map);
        cm.setUnmodifiable();
        copiedMap.put("test2", "test2");// 不会报错
        System.out.println("Travese copiedMap:");
        traveseMap(copiedMap);

        System.out.println("Travese cm.map");
        traveseMap(cm.map);
        cm.map.put("test2", "test2");// 报错
    }

    public void setUnmodifiable() {
        // 禁止修改，修改会抛出UnsupportedOperationException异常来禁止修改。
       this.map = Collections.unmodifiableMap(map);
    }

    public static void traveseMap (Mapmap) {
        Iterator<Map.Entry<String, String>> ite = map.entrySet().iterator();
        while(ite.hasNext()){
            Map.Entry<String, String> entry = ite.next();
            System.out.println("key = " + entry.getKey() + " and value = " + entry.getValue());
        }
    }
}

四. 自定义对List/Map进行排序

    最后补充，对Map实现自定义排序，借助Comparator http://www.cnblogs.com/xiohao/p/4314326.html

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class TestCompare {
public static void main(String[] args) throws IOException {
new TestCompare().testCompare();
}

private void testCompare() {
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("张三", 7);
map.put("李四", 1);
map.put("王五", 9);
map.put("赵六", 8);

ArrayList<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(
map.entrySet());
Collections.sort(list, new Comparator<Entry<String, Integer>>() {

@Override
public int compare(Entry<String, Integer> o1,
Entry<String, Integer> o2) {
return o1.getValue() - o2.getValue();
}
});

// map按照指定格式排序后的结果
for (Entry<String, Integer> entry : list) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
}
}

    运行结果：

   

    重要的一点：实现对List或Map的排序有两种方法，参考  http://www.cnblogs.com/wentiertong/archive/2011/03/07/1973698.html

    第一种方法，就是list中对象实现Comparable接口，实现compareTo方法，代码如下：

public class Person implements Comparable<Person> {
    private String name;
    private Integer order;

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the order
     */
    public Integer getOrder() {
        return order;
    }

    /**
     * @param order
     *   the order to set
     */
    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public int compareTo(Person arg0) {
        return this.getOrder().compareTo(arg0.getOrder());
    }

}

    测试代码：

public static void main(String[] args) {
    List<Person> listA = new ArrayList<Person>();
    Person p1 = new Person();
    Person p2 = new Person();
    Person p3 = new Person();

    p1.setName("name1");
    p1.setOrder(1);
    p2.setName("name2");
    p2.setOrder(2);
    p3.setName("name3");
    p3.setOrder(3);

    listA.add(p2);
    listA.add(p1);
    listA.add(p3);
    Collections.sort(listA);
    for (Person p : listA) {
        System.out.println(p.getName());
    }
}

    第二种方法，就是在 重载Collections.sort方法，代码如下：

public class Person {
    private String name;
    private Integer order;

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the order
     */
    public Integer getOrder() {
        return order;
    }

    /**
     * @param order
     *            the order to set
     */
    public void setOrder(Integer order) {
        this.order = order;
    }

}

    使用Collections.sort方法：

public static void main(String[] args) {
        List<Person> listA = new ArrayList<Person>();
        Person p1 = new Person();
        Person p2 = new Person();
        Person p3 = new Person();

        p1.setName("name1");
        p1.setOrder(1);
        p2.setName("name2");
        p2.setOrder(2);
        p3.setName("name3");
        p3.setOrder(3);

        listA.add(p2);
        listA.add(p1);
        listA.add(p3);

        Collections.sort(listA, new Comparator<Person>() {
            public int compare(Person arg0, Person arg1) {
                return arg0.getOrder().compareTo(arg1.getOrder());
            }
        });

        for (Person p : listA) {
            System.out.println(p.getName());
        }
    }

    两次执行的结果都是：

    name1

    name2
 
    name3

五. 对ArrayList进行初始化

    1.

ArrayList<String> list = new ArrayList(Arrays.asList("Ryan", "Julie", "Bob"));

    2. 常用的初始化方法

    //初始化List 
    List<string> list = new ArrayList<string>(){{
    add("string1");
    add("string2");
    //some other add() code......
    add("stringN");
    }};

    //初始化Map
    Map<string , String> map = new HashMap<string , String>(){{
    put("key1", "value1");
    put("key2", "jb51.net");
    //.... some other put() code
    put("keyN", "valueN");
    }};