集合（二）

Map：

Map：一次添加一对元素，Collection一次添加一个元素。

Map也称为上列集合，Collection集合称为单列集合

Map集合中，元素以键值对的形式存放。

Map集合中必须保证建的唯一性。

常见方法：

1、添加

value put(key ,value) ：返回前一个和key相关联的值，如果没有返回null ；

2、删除

value clear() ： 清空Map集合

value remove(Object key) ：删除指定key对应的键值对。

3、判断

Boolean containsKey(key) ;

Boolean containsValue(Value) ;

Boolean isEmpty() ;

4、获取

value get(key) :通过键获得对应的值，如果没有则返回null。可以通过判读是不是null来判读是不是包含指定的键。

Int size() ：获得键值对的个数。

public class MapTest {

	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>() ; 
		//第一次put是，返回的null
		System.out.println(map.put("zhangsan","beijing")) ;
		//再次添加相同的key是，返回的是key对应的旧值。
		System.out.println(map.put("zhangsan", "tianjing"));
		map.put("lishi", "wuhan") ;
		map.put("wangwu", "shanghai") ;
		System.out.println(map);
		
		//移除一个键值队时，返回这个key对应的值
		System.out.println(map.remove("wangwu"));
		System.out.println(map);
		
		System.out.println("has zhangsan :"+map.containsKey("zhangsan"));
		System.out.println("has Beijing :"+map.containsValue("beijing"));
		System.out.println("is Empty :"+map.isEmpty());

		System.out.println("lishi :"+map.get("lishi"));
		//当对应的key没有对应的值时，返回null。
		System.out.println("wangwu :" +map.get("wangwu"));
	}
}

结果：

遍历Map安排集合的两种方式：

1、通过keySet()方法拿到key的set集合，遍历key的集合，每次拿到key就取出对应的值。

2、通过entrySet 拿到所有的对应关系，遍历对应关系集合，直接通过对应的关系拿到键和值。

Map中没有迭代器，不能用器遍历集合。

public class MapErgodic {

	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>() ; 
		map.put("zhangsan", "wuhan") ;
		map.put("zhaoliu", "shanghai") ;
		map.put("lishi", "wuhan") ;
		map.put("wangwu", "shanghai") ;
		System.out.println(map);
		ergodicByKey(map);
		System.out.println("--------------");
		ergodicByEntry(map);
	}
	//同过key遍历Map
	public static void ergodicByKey(Map<String ,String> map){
		//拿到map中所有的键的set集合
		Set<String> set = map.keySet();
		//遍历keyset，取出每个键
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()){
			String key = iterator.next();
			//通过键，取出对应的值
			System.out.println(key+"=="+map.get(key));
		}
	}
	
	//通过Map.entry，来遍历Map中的元素
	public static void ergodicByEntry(Map<String, String> map){
		//拿到list中所有的Map.entry
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		//遍历entrySet集合
		Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
		while(iterator.hasNext()){
			Map.Entry<String, String> entry = iterator.next();
			//从Map.entry中 跟别取得键和值。
			System.out.println(entry.getKey()+"=="+entry.getValue());
		}
	}	
}

结果：

HashMap：

HashMap以Hashcode值和对象的equals方法判断键的唯一性。

Student 类：

class Student implements Comparable{
	int age ;
	String name ;
	public Student(String name ,int age){
		this.age = age ;
		this.name = name ;
	}
	
	public String getname(){
		return name;
	}
	public int getage(){
		return age;
	}
	//Student本身的比较方法
	//先按姓名排序，姓名相同，按年龄排序
	@Override
	public int compareTo(Object o) {
		System.out.println(this.name+"..compareTo.."+((Student) o).getname());
		int temp = this.name.compareToIgnoreCase(((Student) o).getname());
		return temp== 0?this.age-((Student) o).getage():temp;
	}
	@Override
	public int hashCode() {
		System.out.println(this.name+" hash code..");
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		System.out.println(this.name+"..equals.."+((Student) obj).getname());
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "[name=" + name + ",age=" + age + "]";
	}	
}

public class HashMapTest {

	public static void main(String[] args) {
		HashMap<Student,String> map = new HashMap<Student,String>() ; 
		Student t =new Student("wangwu",30) ;
		
		map.put(new Student("zhangsan",10), "wuhan");
		map.put(new Student("lisi",20), "beijing");
		map.put(t, "shanghai");
		map.put(new Student("zhangsan",10), "guangzhou");
		System.out.println("-------------------");
		//HashMap中，判读key是否重复，
		//先判断hashCode值是否相等
		//如果hashCode相等，则判断equals是否相等
		t.age=12;
		Set<Student>set = map.keySet();
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			Student key = (Student) iterator.next() ;
			//每次取出元素时，
			//先计算出参数key的Hashcode值，如果有相同的key，则认为有对应的值，就取出值。
			//如果后来对键的的属性进行的操作后，后面可能会找不到key，造成内存泄漏。
			//因为，hashcod和原来的值不同，而判读key是根据hashcode值判断的；
			System.out.println(key+"=="+map.get(key));
		}
	}
}

结果：

TreeMap：

以compareTo方法判断键的唯一性。

public class TreeMapTest {

	public static void main(String[] args) {
		TreeMap<Student,String> map = new TreeMap<Student,String>() ; 
		Student t =new Student("wangwu",30) ;
		
		map.put(new Student("zhangsan",10), "wuhan");
		map.put(new Student("lisi",20), "beijing");
		map.put(t, "shanghai");
		map.put(new Student("zhangsan",10), "guangzhou");
		System.out.println("-------------------");
		
		//TreeMap 中判断key是否唯一，直接判断key对象的compareTo方法。不等于0则唯一
		t.age=12;
		Set<Student>set = map.keySet();
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			Student key = (Student) iterator.next() ;
			//每次取出元素时，
			//拿参数key和集合中的key做conpareTo比较，等于0时，则该key有对应值，返回其对应值，否则返回null
			//如果后来对键的的属性进行的操作后，依然可以取出。
			System.out.println(key+"=="+map.get(key));
		}
	}
}

结果：

“asdfasdf”获取字符串中，每个字母出现的次数。

要求：打印结果是a(1)b(2)...;

public class MapAbc {

	public static void main(String[] args) {
		//将字符串转换为 字符数组
		char[] strs = StingToArry("asdlkfjassdfasdaasdf");
		//定义TreeMap集合，可以按字母的自然顺序排序
		TreeMap<Character,Integer> map = new TreeMap<Character,Integer>(); 
		//定义字母出现的次数
		int count = 0 ;
		
		for(int i=0;i<strs.length;i++){
			//先判断 字母对应的 次数
			//由于的当集合没有该字母时，返回的是null，在判断之前将其归零。
			if(map.get(strs[i])!=null)
				count = map.get(strs[i]);
			//次数加上一后，将字母对应的 次数存进去。
			count++;
			map.put(strs[i], count);
			count =0 ;
		}
		arrayToString(map);
	}

	//将字符数组，按照格式打印出来
	private static void arrayToString(TreeMap<Character, Integer> map) {
		Set<Character> set = map.keySet();
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			char key = (char) iterator.next();
			System.out.print(key+"("+map.get(key)+")");
		}
	}

	private static char[] StingToArry(String string) {
		return string.toCharArray();
	}
}

结果：

Collections工具类：

Collectons：是集合框架的工具类，里面的方法都是静态的。

public class CollectionsTest {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("adlkj");
		list.add("blkj");
		list.add("cj");
		list.add("e");
		list.add("bfdkdlkj");
		
		//collections，sort()方法 中自带的排序方式是按照对象的自然顺序
		Collections.sort(list);
		ergodic(list);
		System.out.println("--------");
		
		//sort()可以自定义比较方式，只要传递进去一个比较器就行
		Collections.sort(list, new MyComparator2());
		ergodic(list);
		System.out.println("--------");
		
		//打乱集合中元素的排列顺序
		Collections.shuffle(list);
		ergodic(list);
		System.out.println("--------");
		
		mySort(list,new MyComparator2());
		ergodic(list);
		
		

	}
	
	//自定义的排序方法
	//通过比较排序，实现按字字符串长度排序。
	public static <T> void mySort(List<T> list,Comparator<? super T> com){
		for(int i=0;i<list.size()-1;i++){
			for(int j=i+1;j<list.size();j++){
				if(com.compare(list.get(i),list.get(j))>0){
					//交换集合中的两个元素
					Collections.swap(list, i, j);
				}
			}
		}
	}
	
	//遍历集合的方法
	public static void ergodic(List<?> list){
		Iterator<?> iterator = list.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
}

/*
 * 自定义的比较器，重写conpare（）方法
 * 实现对字符串的长度比较
 */
class  MyComparator2 implements Comparator<String>{
	@Override
	public int compare(String o1, String o2) {
		int temp = o1.length()-o2.length();
		return temp==0? o1.compareTo(o2):temp;
	}
}

结果：

Arrays：

Arrays是集合框架中的工具类，里面的方法都是静态的。

重点方法是 List asList() ：将数组转换成List，转换过来的List集合的长度是固定的，自能进行改查的操作，增删会报错。

如果数组里面是对象，转换后来直接将对象拿过来，如果是基本类，则转换成相对应的包装类进行存储。

好处 ：可以使用集合中的方法对数组进行操作。

public class ArraysTest {

	public static void main(String[] args) {
		
		String[] strs = new String[]{"abc","abd","abf","abf","abs"};
		//数组本身的toString方法，是打印本身的hashcode值
		System.out.println(strs);
		//Arrays的toString方法可以将将数组按照一定的格式转换成字符串
		System.out.println(Arrays.toString(strs));
		//将数组转换成list
		List<String> list = Arrays.asList(strs);
		System.out.println(list.contains("abc"));
		
		int[] arryint = new int[]{12,34,45};
		//基本数据类型，只能将数组本身看成一个对象，m
		//list中只有一个元素，就是数组本身
		List<int []> list2 = Arrays.asList(arryint);
		System.out.println(list2);
		
		//使用基本类型的包装类，自动将基本数据类型包装成其包装类。
		Integer[] arryint2 = new Integer[]{23,34,45};
		List<Integer> list3 = Arrays.asList(arryint2);
		System.out.println(list3);
	}
}

结果：

集合转数组

使用Collection接口中的toArray方法。

将集合转换成数组后，可以对集合中的元素操作方法进行限制，不允许进行增删。

toArray方法需要传递进去一个指定类型的数组。

如果长度小于集合的size，该方法将会创建一个同类型并和集合size一样的数组。

如果长度大于集合的size，该方法将会使用传递进来的数组，其他位置为null。

最好，将传递进来的数组的长度设置成集合的size。

public class ListToArray {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("asd1") ;
		list.add("asd2") ;
		list.add("asd3") ;
		list.add("asd4") ;
		
		//当传递进来的数组长度小于list的size是
		//会新建一个size和list大小一样的数组
		String[] strs1 = (String[]) list.toArray(new String[1]);
		System.out.println(Arrays.toString(strs1));
		
		//当传递进来的数组长度过长时
		//直接使用，传递进来的数组，没装满的位置是null
		String[] strs = list.toArray(new String[10]);
		System.out.println(Arrays.toString(strs));
		
		//当传递进来的数组长度与list的size一样时
		//不用新建数组，直接用传递进来的数组，不存在装不下，和空位置。
		String[] strs2 = list.toArray(new String[list.size()]);
		System.out.println(Arrays.toString(strs2));
	}

}

结果：