黑马程序员_集合_map集合以及集合工具类Collections

------- android培训、java培训、期待与您交流！ ----------

Map集合
Map(双列)集合与collection(单列)集合是并列的，都是顶层的。
map接口使用两个泛型。
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 重复的键添加时，新的键值会覆盖原有键值，所以还是没有重复的键。
1.添加
V put(K key, V value) 
void putAll(Map<? extends K,? extends V> m) 
 
 
2.删除
clear() 删除所有元素
V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 


3.判断
boolean containsKey(Object key) 
boolean containsValue(Object value)
boolean isEmpty()   
4.获取
V get(Object key) 
int size()  返回此映射中的键-值映射关系数。
Collection<V> values()返回此映射中包含的值的 Collection 视图 
Set<Map.Entry<K,V>> entrySet() (重要)
Set<K> keySet()(重要)
 
map集合的三个实现子类
hashtable底层是hash表数据结构，不可以存入null键null值，是线程同步的
hashMap底层是哈希表处理结构，允许使用空键空值，该集合不同步。


TreeMap底层是二叉树结构，线程不同步，可以用于给map集合中的键进行排序。


set集合底层就是使用了map集合。


Map <String,String> map=new HashMap<String,String>();
map.put("01","zhangsan6");
map.put("02","zhangsan5");
map.put("03","zhangsan4");
map.put("04","zhangsan3");
map.put("05","zhangsan2");
map.put(null,"zhangsan1")
map.remove("01");//会返回01的值，并且删除这个键）
map.get("03");//返回03的值，如果没有返回空。
map.get(null);//null可以作为键值，此时返回zhangsan1.
null也可以作为值。hashtable则不可以。




Collection<String> coll =map.values();//此方法返回一个collection集合，collection集合虽然不能直接创建，可以用此方法得到。
当存到相同键的时候，put方法会返回一个原来的值而将新的值存入这个键其中，没有值当然不会返回。


Keyset 方法返回map集合中所有的键存入一个set集合中，set集合有迭代器，所以可以通过迭代方式取出所有的键，然后通过get方法获取每一个键值。


Set<String> Keyset=map.keySet();
Iterator<String> it=Keyset.iterator();
while(it.hasNext()){
   String key=it.next();
   String Value=map.get(key);
   
}


map中的entrySet方法:返回的是一个包含键与值的关系的视图。
 Set<Map.Entry<K,V>> entrySet() //前面一大坨是返回一个set集合
也就是说，这个方法的本质就是得到一个set集合，这个集合中的每一个元素都是是一个Map.Entry这个类型，这个类型记录了这个原map集合中键值关系，然后如果想要拿到键或者是值，则需要先拿到这Map.Entry.而set中拿到元素的方法就是迭代器的建立，这样通过建立一个迭代器拿到这个Map.Entry对象再通过其中的一些方法(具体方法参考API)得到我们想要的键和值，事实就是这么简单明了，难道不是吗？


set<Map.Entry<String,String>> entryset=map.entrySet();
Map.Entry本身是一个类型，它自己有两个泛型。
Iterator<Map.Entry<String,String>> it=Keyset.iterator();
while(it.hasNext()){
   
Map.Entry<String,String> me=it.next();
String key=me.getKey();
String value=me.getValue();


}


 
详解Entry，事实上Map接口中有一个静态的Entry接口，可以直接Map调用

interface Map{

  public static interface Entry{
     public abstract Object getKey();
     public abstract Object getValue();


}
}


class HashMap implements Map{
  class haha implements Map,Entry(){
     public Object getKey(){}
     public Object getValue(){}
}


}


用内部类实现内部接口，因为class实现了Map集合
能加static的接口必定是内部接口。
对象可能的存储方式有三种，数组，哈希表，或者二叉树，所以对象中如果需要存入到容器中，需要按需实现hashCode方法，equals方法，以及compareTo方法。
TreeMap也可以传入一个比较器

什么时候使用Map集合？
当数据之间存在映射关系时就要先想到Map集合。

public class JiheDemo16 {

	public static void main(String[] args) {
		Map<String,String> m=new Hashtable<String,String>();
		//添加元素。
		m.put("01", "zhangsan");//该方法返回该键所对应原来的值返回来。
		m.put("01","wangwu");//该方法返回zhangsan.
		m.put("02","zhangsan02");
		m.put("03","zhangsan3");
		//System.out.println(m.remove("02"));
		m.get("022");//不存在该键则返回空。
		//可以通过get方法的返回值来判断键是否存在，通过返回Null来判断。
		//获取map集合中所有的值。
		Collection<String> coll=m.values();
		System.out.println(coll);
	}

}

map集合中的两种存取方式:

public class JiheDemo17 {

	public static void main(String[] args) {
		Map<String,String> m=new HashMap<String,String>();
		m.put("01","abc");
		m.put("02","fh");
		m.put("03", "dfghh");
		Set<String> s=m.keySet();
		Iterator<String> it=s.iterator();
		while(it.hasNext()){
			String ss=it.next();
			System.out.println("key :"+ss+" Value :"+m.get(ss));
		}
		Set<Map.Entry<String,String>> entrySet=m.entrySet();//Set中存放该映射关系类型
		Iterator<Map.Entry<String,String>> it1=entrySet.iterator();
		while(it1.hasNext()){
			Map.Entry<String,String> me=it1.next();
			String key=me.getKey();
			String value=me.getValue();
			System.out.println("key :"+key+" value :"+value);
		}//注意泛型中的泛型也需要指定一下。。

	}

}

collections工具类
是一个专门用于对集合进行操作的工具类，类中都是静态方法，可以自动用类名调用。
sort中的参数是List集合，用于给List集合进行相关排序，不能对set集合进行操作。默认按升序排序，重复元素也能排序，List是数组结构可以存储重复元素（有索引）。如果不用默认的那就得传入比较器进行比较，也就是采用下面的Sort方法。 
static <T> void  sort(List<T> list, Comparator<? super T> c)
以上方法中Comparator做了泛型限定，在自定义比较器类实现该Comparator接口时，可以是Sort的List参数的T的类型或者是其父类型
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)


这个max函数的理解是:T必须是Object类的子类对象，并且Comparable中只能传入T或者T的父类，并且所要取最大值的集合中只能传入T或者是T的子类，而且返回一个T类型。
max的重载函数可以加入一个比较器:
public static <T> T max(Collection<? extends T> coll,
                        Comparator<? super T> comp)




public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)返回的是Key在集合中的位置（角标）。如果找不到则返回(-(插入点) - 1)
此方法的原理就是前面学习过的二叉查找法。然后返回的是那个-min-1
而min之所以称作插入点，是因为当所要找的元素不存在时，可以在min上插入。
static <T> Comparator<T> reverseOrder() 
此方法的使用必须要先让元素具备比较性。所以首先应该知道集合是否具备比较性。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)将比较器强行逆转。（都是静态方法）  


记住:comparable里面的方法叫做compareTo，此方法一般是容器中需要存放的元素自身去实现comparable接口并复写compareTo方法。
而comparator接口则一般用于需要传入此比较器的方法或者容器的构造函数。实现此接口必须得创建一个能够实现此接口并复写该接口中的compare方法的类，也叫做比较器。
static <T> List<T> synchronizedList(List<T> list) 
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 
 static <T> Set<T> synchronizedSet(Set<T> s) 
都是用于返回一个线程安全的另一个集合。可以看看源码。源码中覆盖list中的各种方法，比如说添加，删除等等加上同步锁就行。
 
static void swap(List<?> list, int i, int j)   用于任意两个元素换位置。
static void shuffle(List<?> list) 将集合中的元素重新按照随机的顺序进行排放。
static void shuffle(List<?> list, Random rnd)  指定随机源。

以下代码实现Collections中的二分法

public class JiheDemo21 {

	public static void main(String[] args) {
		ArrayList al=new ArrayList();
		al.add("sdgfs");
		al.add("sdfg");
		al.add("dfg");
		al.add("dgdfg");
		al.add("fghttf");
		//这里注意，如果该list集合没有指定泛型，那么如果存入不可比较的元素，调用
		//sort方法会抛出运行异常(类型转换异常)。
		Collections.sort(al);
		System.out.println(al);
		//int num=erFenSearch(al,"kiss");
		//System.out.println(al);
		//System.out.println(num);

	}
	public static <T>int erFenSearch(List<? extends Comparable<? super T>> list,T key){
		int min,max,mid;//自定义二分查找。
		min=0;
		max=list.size()-1;//注意是size-1而不是不存在的size.
		while(true){
			mid=(min+max)/2;
			int num=list.get(mid).compareTo(key);
			if(min<=max){//不要忘记等号，千万不要忘记，
				if(num>0){
					max=mid-1;
					continue;
					}
				if(num<0){
					min=mid+1;
					continue;//不懂为何要加上一个continue，这if语句执行完了难道不会再循环吗？
					}
				else
					return mid;
				}
			return -min-1;
		}
		
	}

}