关于java map 初始化，遍历，排序的几个解答

package demo;

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;
import java.util.SortedMap;
import java.util.TreeMap;

import org.junit.Test;

public class NineQuetsionOfMap {
	
	
	/**
	 * map真的不可以修改了吗？还是只是其地址（引用）不可以修改
	 */
	  private static final Map<String,String> map;
	  static {
	    Map<String,String> aMap = new HashMap<String,String>();
	    aMap.put("1", "one");
	    aMap.put("2", "two");
	    //调用这个方法之后使其映射也变得不可修改，但假如其中的值为一个user对象，其属性姓名也是也是可以修改的
	    //传值类型 ：八大基本类型（以及其包装类）和字符串   
	    //传址类型（引用）：数组和对象
	    map = Collections.unmodifiableMap(aMap);
	  }
	  
	  
	  //如下这样的初始化是没有任何意义的
	  private static final Map<Integer,String> map1;
	  static {
	    map1 = new HashMap<Integer,String>();
	    map1.put(1, "one");
	    map1.put(2, "two");
	  }

	/**
	 * @author songhao
	 * @Title: Convert_a_Map_to_a_List
	 * @Description: TODO(map转为集合的三中方式)
	 * @param 设定文件
	 * @return void 返回类型
	 * @throws @date
	 *             2017年12月13日 下午1:31:29
	 */
	@Test
	public void Convert_a_Map_to_a_List() {
		// 这里使用hashmap举例
		HashMap<String, String> hashMap = new HashMap<>();
		hashMap.put("0", "song");
		hashMap.put("1", "huang");
		hashMap.put("2", "liu");
		System.out.println(hashMap);
		// key list
		ArrayList<String> keyList = new ArrayList<String>(hashMap.keySet());
		System.out.println(keyList);
		// value list
		ArrayList<String> valueList = new ArrayList<String>(hashMap.values());
		System.out.println(valueList);
		// key-value list
		ArrayList<Entry<String, String>> entryList = new ArrayList<Entry<String, String>>(hashMap.entrySet());
		System.out.println(entryList);
		// {0=song, 1=huang, 2=liu}
		// [0, 1, 2]
		// [song, huang, liu]
		// [0=song, 1=huang, 2=liu]
		// 这三种转换方式其实也代表了遍历map的三种方式，转成集合之后我们可以使用循环或者list的迭代器进行遍历
	}

	/**
	 * @author songhao
	 * @Title: Sort_a_Map_on_the_keys
	 * @Description: TODO(将map根据key进行排序)
	 * @param 设定文件
	 * @return void 返回类型
	 * @throws @date
	 *             2017年12月13日 下午2:06:24
	 */
	@Test
	public void Sort_a_Map_on_the_keys() {
		// 这里使用hashmap举例
		HashMap<String, String> hashMap = new HashMap<>();
		hashMap.put("cz", "song");
		hashMap.put("ca", "huang");
		hashMap.put("a", "liu");
		hashMap.put("d", "wang");
		System.out.println(hashMap);//{a=liu, d=wang, cz=song, ca=huang}
		//既然要排序就必须要有某种规则，在java中我们可以使用Collections工具类中提供的规则或者使用Comparator接口提供的方法去制定规则
		/**
		 *  Java中Collection和Collections的区别
		 * 1、java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。
		 *  Collection   
		 * ├List   
		 * │├LinkedList   
		 * │├ArrayList   
		 * │└Vector   
		 * │　└Stack   
		 * └Set
		 * 2、Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。
		 */
		ArrayList<String> keyList = new ArrayList<String>(hashMap.keySet());
		//默认是不传比较器的，底层代码中和传比较器调用同一个方法只不过传的是null,
		//调用的是字符串底层的compareTo方法（取两个字符串的公共长度从头开始依次比较每一个字符，若不相等返回两个字符的asc码差值，若相等继续往后比，但是公共长度若完全相等再返回两串字符的长度之差） [a, ca, cz, d]
		Collections.sort(keyList);
		System.out.println(keyList);//[a, ca, cz, d]
		Collections.sort(keyList,new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return o1.compareTo(o2);
			}
		});
		System.out.println(keyList);//[a, ca, cz, d]

		// 另一种方法我们可以使用SortedMap去实现，可自动排序的map例如学过的treeMap集合他是基于红黑树算法集合
		SortedMap<String, String> sortedMap = new TreeMap<>(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		sortedMap.putAll(hashMap);
		System.out.println(sortedMap);//{a=liu, ca=huang, cz=song, d=wang}
		/**
		 * 我们也可以根据上面的第一种方法去实现根据value进行排序但是
		 * 对于这个问题，我们仍然可以使用排序的映射，但前提是这些值也是惟一的。
		 * 在这种情况下，您可以将键=值对转换为value=键。这个解决方案有很强的局限性，因此我并不推荐它。
		 * 
		 */
		map1.put(1, "6");
		map.put("1", "1");
	}
	/**
	 *                      | HashMap | HashTable | TreeMap
	 *  -------------------------------------------------------
	 *  迭代顺序            | no      | no        | yes
	 *  null key-value      | yes-yes | no-no     | no-yes
	 *  同步的（线程安全）  | no      | yes       | no
	 *  查找性能            | O(1)    | O(1)      | O(log n)
	 *  实现方式            | buckets | buckets   | red-black tree
	 *  
	 *  buckets我的理解就是hash桶
	 *  
	 *  除了这些还有一个LinkedHashMap.他继承了HashMap，所以其特性一样但是LinkedHashMap保留了插入顺序
	 *  ***************************************************************
	 *  扩展两个方法
	 *  将map变成同步的
	 *  Map copiedMap = Collections.synchronizedMap(map);
	 *  创建一个空的集合
	 *  map = Collections.emptyMap(); map = new HashMap();
	 */
	
	
	
}