黑马程序员java之集合框架Map



------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

|--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

|--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

|--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map方法：

1，添加。

 put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

 void putAll(Map);

2，删除。

 void clear()：清空

 value remove(key)：删除指定键。

3，判断。

 boolean isEmpty()：

 boolean containsKey(key)：是否包含key

 boolean containsValue(value)：是否包含value

4，取出。

 int size()：返回长度

 value get(key)：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collection<T>coll = map.values();获取map集合中的所有的值。

取出Map集合中所有元素有两种方法

1，keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

class MapDemo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");
//先获取map集合的所有键的Set集合,keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合。就可以获取其迭代器。
		Iterator<String> it = keySet.iterator();

		while(it.hasNext())
		{
			String key = it.next();
			//有了键可以通过map集合的get方法获取其对应的值。
			String value  = map.get(key);
			System.out.println("key:"+key+",value:"+value);
}
}
}

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

class MapDemo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");

		//将Map集合中的映射关系取出。存入到Set集合中。
		Set<Map.Entry<String,String>> entrySet = map.entrySet();

		Iterator<Map.Entry<String,String>> it = entrySet.iterator();

		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();

			System.out.println(key+":"+value);

		}
}
}

package com.text;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

/**
 * *Test1--取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq"，
 * 	输出格式为：a(2)b(1)k(2)...
 * 
 * 思路：   1，因为有键值对应次数，首先想到Map集合
 * 		2，因为是字符串，所以该先变成字符数组
 * 		3，因为是字符存储，所以需要自然排序所以用TreeMap
 * */
public class Text01 {
	public static void main(String[] args) {
		String s = "abcdekka27qoq";
		printDemo(s);
		
	}
	public static void printDemo(String s){
		TreeMap<Character,Integer> hm = new TreeMap<Character,Integer>();
		char[] ch = s.toCharArray();//把字符串变成字符数组
		
		int count = 0;
		for(int i =0;i<ch.length;i++){
			//便利数组，当数组中全是字符时候，进行存储。
			if(!(ch[i]>='a'&&ch[i]<='z'||ch[i]>='A'&&ch[i]<='Z'))
				continue;
			Integer value =  hm.get(ch[i]);//存储字符
			
			if(value!=null)//当返回值不为空的时候，证明这个字符已经存储过了。所以可以获取存储的次数。
				count = value;
			count++;//次数加1
			hm.put(ch[i], count);//存储字符和存储次数
		}
		Set<Character> keySet = hm.keySet();//遍历集合，第一种取出方式
		Iterator<Character> it = keySet.iterator();
		while(it.hasNext()){
			char c = it.next();
			System.out.print(c+"("+hm.get(c)+")");//打印集合元素
		}
	}

}

//输出结果是：

a(2)b(2)c(3)d(4)e(5)k(7)o(4)q(4)

使用集合的技巧：

看到Array就是数组结构，有角标，查询速度很快。

看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast；removeFirst()； removeLast()；getFirst()；getLast()；

看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。

看到tree就是二叉树，就要想到排序，就想要用到比较。

比较的两种方式：

一个是Comparable：覆盖compareTo方法；

一个是Comparator：覆盖compare方法。

集合什么时候用？

当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。保证唯一，就用Set。不保证唯一，就用List。

集合框架的工具类。

Collections:集合框架的工具类。里面定义的都是静态方法

Collections.sort(list);//list集合进行元素的自然顺序排序。

Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。

Collections.max(list); //返回list中字典顺序最大的元素。

int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。

Collections.reverseOrder();//逆向反转排序。

Collections.shuffle(list);//随机对list中的元素进行位置的置换。

List synchronizedList(list);

Map synchronizedMap(map);

//原理：定义一个类，将集合所有的方法加同一把锁后返回。

package pract;

import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;

public class CollectionDemo {
	public static void main(String[] args) {
		
		orderDemo();	
	}
	public static void orderDemo()
	{	//Collections.reverseOrder();//逆向反转排序，返回值是一个Comparator
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());

		ts.add("abcde");
		ts.add("aaa");
		ts.add("k");
		ts.add("cc");

		Iterator<String> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

Collection和 Collections的区别：

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。

Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

Arrays：用于操作数组对象的工具类，里面都是静态方法。

asList方法：将数组转换成list集合。

String[] arr ={"abc","kk","qq"};

List<String>list = Arrays.asList(arr);//将arr数组转成list集合。

将数组转换成集合，可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set； 但是数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。会报不支持操作异常UnsupportedOperationException；

如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。

如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

package pract;

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {

	public static void main(String[] args) {
		// 可以通过list集合中的方法来操作数组中的元素
		String[] arr = {"abc","cc","kkkk"};
		List<String> list = Arrays.asList(arr);	
		System.out.println(list.contains("cc"));//判断数组中是否有cc元素
		
		int[] nums = {2,4,5};		
		List<int[]> li = Arrays.asList(nums);
		//如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。
		System.out.println(li);
		
		//运行结果：
		//true
		//[[I@659e0bfd]
	}

}

集合变数组：用的是Collection接口中的方法：toArray();

将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。

在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

package pract;

import java.util.ArrayList;
import java.util.Arrays;

public class CollectionToArray {

	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");		
		/*
		1,指定类型的数组到底要定义多长呢？
		当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
		当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
		所以创建一个刚刚好的数组最优。
		*/

		String[] arr = al.toArray(new String[al.size()]);

		System.out.println(Arrays.toString(arr));//[abc1, abc2, abc3]

	}

}

Jdk5.0新特性：

Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

--------------------------------------------------

增强for循环：foreach语句，foreach简化了迭代器。

格式：//增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器

for(元素类型 变量名 :Collection集合 &数组 ) {

 …

}

作用：对存储对象的容器进行迭代： 数组 collection  map

高级for循环不可以直接遍历map集合，但是可以将map转成set后再使用foreach语句。

package pract;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ForEachDemo {

	public static void main(String[] args) {
		// 高级for循环遍历map集合
		HashMap<Integer,String> hm = new HashMap<Integer,String>();

		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");

		Set<Integer> keySet = hm.keySet();
		for(Integer i : keySet)
		{
			System.out.println(i+"::"+hm.get(i));
		}

//		Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
//		for(Map.Entry<Integer,String> me : entrySet)

		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			System.out.println(me.getKey()+"------"+me.getValue());
		}
	}

}

//输出结果：

1::a

2::b

3::c

1------a

2------b

3------c

StaticImport 静态导入。

当类名重名时，需要指定具体的包名。

当方法重名是，指定具备所属的对象或者类。

import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。


class  StaticImport //extends Object
{
	public static void main(String[] args) 
	{
		int[] arr = {3,1,5};

		//Arrays.sort(arr);
		sort(arr);
		int index = binarySearch(arr,1);
		//当方法重名是，指定具备所属的对象或者类。
		System.out.println(Arrays.toString(arr));
		//toString重名父类的方法
		System.out.println("Index="+index);
	}
}

package pract;

import java.util.*;

class SystemDemo {
	public static void main(String[] args) {

		Properties prop = System.getProperties();

		// 因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
		// 那么可以通过map的方法取出该集合中的元素。
		// 该集合中存储都是字符串。没有泛型定义。

		// 如何在系统中自定义一些特有信息呢？
		System.setProperty("mykey", "myvalue");

		// 获取指定属性信息。
		String value = System.getProperty("mykey");

		System.out.println("value=" + value);

		
		  //获取所有属性信息。高级for循环
		 for(Object obj : prop.keySet()) {
			 String values =(String)prop.get(obj);
		 
		  System.out.println(obj+"::"+values); 
		  }
		 
	}
}