Java学习之Map、Collections

Map 接口

Map集合的特点：
1.使用Key(键),Value（值)对的形式存储；
2.内部会维护Key的唯一性。不管值是什么情况。

Map的基本功能：
put：V put (K key,V value)：将指定的值与此映射中的指定键关联（可选操作）。
clear：清空集合：
remove：V remove(Object key):如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
containsKey：boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回 true。
isEmpty：boolean isEmpty()：判断Map是否为空；
Map的获取功能：
V get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
Set keySet()：返回此映射中包含的键的 Set 视图。
Collection values()：返回此映射中包含的值的 Collection 视图。

获取map中的所有元素：
原理：map中是没有迭代器Iterator的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。
之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

把map集合转成set的方法：
Set keySet( ); 将map中所有的键存到Set集合。
Set<k,value> entrySet( );//取的是键和值的映射关系。

Entry就是Map接口中的内部接口；
为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

取出map集合中所有元素的方式一：keySet()方法。
可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

Set keySet = map.keySet(); 
Iterator it = keySet.iterator(); 
while(it.hasNext()) 
{ 
     Object key = it.next(); 
     Object value = map.get(key);
     System.out.println(key+":"+value);
}

取出map集合中所有元素的方式二：entrySet()方法。

Set<map.entry<String,String>> entrySet = map.entrySet(); 
Iterator<map.entry<String,String>> it = entrySet.iterator();
while(it.hasNext()) { 
Map.Entry me = (Map.Entry)it.next(); 
System.out.println(me.getKey()+"... ..."+me.getValue()); 
}

||- -Map接口
||- -HashMap类

底层是哈希表数据结构；允许使用null键和null值；
线程不同步，效率高；

保证元素唯一性的:
原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true
(往HashSet里面存的自定义元素要复写hashCode和equals方法，以保证元素的唯一
性！)

		class Student {
			private String name;
			private int age;
			public Student(String name, int age) {
				super();
				this.name = name;
				this.age = age;
			}
			public int getAge() {
				return age;
			}
			public void setAge(int age) {
				this.age = age;
			}
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
			
			@Override
			public int hashCode(){
				return name.hashCode()+age*34;
			}
			@Override
			public boolean equals(Object obj){
				
				if(!(obj instanceof Student))
					return false;
				Student stu = (Student)obj;
				return this.name.equals(stu.name)&&this.age==stu.age;
			}
		
				
		public class HashMapDemo1 {
			public static void main(String[] args) {
				Map<Student , String> hmap = new HashMap<Student , String>();
				hmap.put(new Student("001",20), "China");
				hmap.put(new Student("002",25), "England");
				hmap.put(new Student("003",50), "America");
				hmap.put(new Student("004",20), "Italy");

				
				System.out.println(hmap.size());
				Set<Student> keySet = hmap.keySet();
				Iterator<Student> it = keySet.iterator();
				while(it.hasNext()){
					Student stu = it.next();
					String addr = hmap.get(stu);
					System.out.println(stu.getName()+"--"+stu.getAge()+"- -"+addr);
				}	
			}	
		}		

||- -Map接口
||- -TreeMap类
底层是二叉树结构；允许使用null键和null值；线程不同步；可以给Map集合中的Key键进行排序.

TreeMap排序的第一种方式：让元素自身具备比较性，比如八种基本数据类型或则字符串，
实现Compareble接口,覆盖compareTo方法，此方式是元素的自然顺序
TreeMap排序的第二种方式：当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时(比如想字符串的长度排序),此时就需要让集合自身具备自定义的比较性。
那如何让集合自身具备比较性呢？

		class Student implements Comparable<Student>{
			private String name;
			private int age;
			public Student(String name, int age) {
				super();
				this.name = name;
				this.age = age;
			}
			public int getAge() {
				return age;
			}
			public void setAge(int age) {
				this.age = age;
			}
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
			@Override
			public int compareTo(Student stu) {
				int num = new Integer(this.age).compareTo(new Integer(stu.age));
				if(num==0)
					return this.name.compareTo(stu.name);
				return num;
			}			
		}

		public class HashMapDemo1 {
			public static void main(String[] args) {
							
				Map<Student , String> tmap = new TreeMap<Student , String>();
				tmap.put(new Student("001",20), "China");
				tmap.put(new Student("002",25), "England");
				tmap.put(new Student("003",50), "America");
				tmap.put(new Student("004",20), "Italy");
				
				System.out.println(tmap.size());
				Set<Student> keySet1 = tmap.keySet();
				Iterator<Student> it1 = keySet1.iterator();
				while(it1.hasNext()){
					Student stu = it1.next();
					String addr = tmap.get(stu);
					System.out.println(stu.getName()+"--"+stu.getAge()+"- -"+addr);		
				}
			}
		}

Collections：（注意区别与Collection）

import java.util.ArrayList;
import java.util.Collections;
Collections类概述：

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

public static <T> void sort(List<T> list)：排序(根据元素的自然顺序 对指定列表按升序进行排序)
public static <T> int binarySearch(List<?> list,T key):在list中查找key对象
public static <T> T max(Collection<?> coll)：根据元素的自然顺序，返回给定 collection 的最大元素。
public static void reverse(List<?> list)：反转指定列表中元素的顺序。
public static void shuffle(List<?> list)：使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。



	//1.排序
	Collections.sort(list);
	System.out.println("排序后的集合：" + list);
	//2.public static <T> int binarySearch(List<?> list,T key):在list中查找key对象
	System.out.println("查找34：" + Collections.binarySearch(list, 34));
	System.out.println("查找340：" + Collections.binarySearch(list, 340));
	
	//3.public static <T> T max(Collection<?> coll)：根据元素的自然顺序，返回给定 collection 的最大元素。
	System.out.println("查找最大的：" + Collections.max(list));
	//4.public static void reverse(List<?> list)：反转指定列表中元素的顺序。
	Collections.reverse(list);
	System.out.println("反转后：" + list);
	//5.public static void shuffle(List<?> list)：使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
	Collections.shuffle(list);
	System.out.println("shuffle之后的：" + list);
}

}

Collection 和 Collections的区别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

总结:
针对不同数据结构实现的类，我们应该掌握其特点，例如List下的三个子类ArrayList、LinkedList和Vector的因为底层实现数据结构的不同，LinkedList增删方便高效，而ArrayList快速随机访问速度快，Vector访问会检测同步问题。在多线程的环境中需要考虑使用同步的集合类，在单线程的环境下可以使用非同步的集合类，从而满足高效的需求等。
涉及到使用Tree实现的集合类时，内部数据都会进行一定顺序的排序，如TreeSet和TreeMap都对输入其中的数据进行排序操作，需注意实现排序的两种方法：自然排序和比较器排序。自然排序是实现Comparab接口，重写compareTo()方法；比较器排序是自定义一个类实现Comparator接口，覆写compare()方法内容。两者差别在于在new对象时是否需要实例化，这点需要注意。
集合的内容多而杂，相互之间又有着共通之处，但大大增加对于软件编写中存储问题的知识积累，为后期项目开发提供基础支撑。