目录:
一. 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进行初始化
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"); }};