黑马程序员--Map集合、集合框架工具类

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

第一节--Map集合

Map集合和Collection集合不同的是，Map集合双列集合，存储的是一对元素，即键值对，键和值有映射关系，键具有唯一性。

       Map

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。取代了HashTable。jdk1.2.效率高。

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

 Map中常用的方法：

1.添加

V put(K,V);添加键值对，当K值已存在时，会将原来的V覆盖，并返回原来的V

void putAll(Map<? extends M,? extends N> m);添加一个集合

2、删除

        clear();//清空

        Vremove(Object key);//删除指定键值对

3、判断

        containsKey(Objectkey);//判断键是否存在

        containsValue(Objectvalue)//判断值是否存在

        isEmpty();//判断是否为空

4、获取

        Vget(Object key);//通过键获取对应的值

        size();//获取集合的长度

        Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合

还有两个取出方法，接下来会逐个讲解：

        Set<Map.Entry<K,V>>entrySet();

        Set<K>  keySet();

注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

/*练习：使用Map集合中取出元素的两种方式
思路：定义学生类，学生属性有姓名和年龄，同时学生有住址，学生和住址作为键值对存入Map集合
取出的第一种方式：将键存入Set集合，使用Set集合中的迭代器，根据键使用get()方法获取值
取出的第二种方式：将将键值对这种映射 关系存入Set集合，使用Set集合中的迭代器，同时可以获得
键和值
 */
public class MapDemo {

	public static void main(String[] args) {
		//创建HashMap集合，并存入Student对象
		HashMap<Student, String> hm = new HashMap<Student,String>();
		//TreeMap<Student, String> hm = new TreeMap<Student,String>();
		hm.put(new Student("lisi01",22), "heze");
		hm.put(new Student("lisi05",25), "tianjin");
		hm.put(new Student("lisi02",12), "shangqiu");
		hm.put(new Student("lisi31",26), "heze");
		hm.put(new Student("lisi05",25), "tianjin");
		//getOutAnother(hm);
		getOut(hm);
		//System.out.println(hm);

	}
	//定义取出HashMap集合中元素的方法,并打印元素
	public static void getOut(HashMap<Student, String> hm){
		//通过keySet()方法获取hm的键的Set集合，使用迭代器
		Iterator<Student> iter = hm.keySet().iterator();
		while(iter.hasNext()){
			Student s = iter.next();
			System.out.println(s.toString()+'\t'+hm.get(s));
		}
	}
	public static void getOutAnother(HashMap<Student, String> hm){
		//通过entrySet()方法获取hm的键值映射的Set集合，使用迭代器
		Iterator<Map.Entry<Student,String>> iter = hm.entrySet().iterator();
		while(iter.hasNext()){
			Map.Entry<Student, String> me = iter.next();
			Student stu = me.getKey();
			String str = me.getValue();
			System.out.println(stu.toString()+"\t"+str.toString());
		}
	}
}
//定义学生类
class Student implements Comparable<Student>{
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	//复写hashCode方法和equals方法，使对象可以存入HashSet集合，保证对象唯一性
	//并实现自然排序,年龄为主
	public int hashCode(){
		return this.name.hashCode()+this.age;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Student))
			throw new RuntimeException("类型错误");
		Student s = (Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
	//复写comparaTo()方法，定义对象的比较规则，使对象可以存入TreeSet集合，保证对象的唯一性
	//让TreeSet集合可以对对象进行自然排序
	@Override
	public int compareTo(Student s) {
		int num = (new Integer(this.age)).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public String toString(){
		return name+":"+age;
	}
}

集合使用技巧

1、各种集合的特点

看到Array就是数组结构，元素有脚标，查询速度快

看到Linked就是链表结构，增删速度快，有特有方法：addFirst()、addLast();removeFirst()、removeLast();getFirst()、getLast();

看到Tree就是二叉树结构，必须进行排序，排序需要比较

比较有两种方式：

第一种：让元素自身具备比较性。元素实现Comparable接口，复写comparaTo方法

第二种：让集合具备比较性。自定义比较器实现Comparator接口，复写Compara方法。将自定义比较器对象作为集合构造函数参数进行传递。

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

LinkedHashSet、LinkedHashMap，这两个集合可以保证元素存入顺序和取出顺序一致，保证哈希表有序。

2、如何选择集合

元素是单个对象，使用 Collection 集合

元素是有映射关系的一对对象，使用 Map 集合

需要保证元素唯一性，使用 Set 集合

不需要保证元素唯一性，使用 List 集合

/*
 * 练习:获取字符串,并以a(3)b(2)...的格式打印结果
 * 思路：
 * 1.定义一个功能，给出任意一个字符串都能实现上述结果
 * 2.将字母作为键，次数作为值，用Map集合存储
 * 3.将字符串转换成字符数组，便于操作
 * 4.判断字符作为键在集合中是否存在，使用get()方法判断，如果不存在，则返回null，将该字母
 * 	和1作为键值对，存入集合中，否则就将该字母和键值自增，存入集合
 * 5.取出集合中键值对，用StringBuidler存储。
 * 6.转换成字符串返回给调用者
 */
class Test{
	public static void main(String [] args){
		String str = "cabillaacbicjjkahgaufas;uiofheriao;gjfji";
		charCount(str);
	}
	public static String charCount (String str){
		TreeMap<Character,Integer>  tm = new TreeMap<>();
		char[]arr = str.toCharArray();
		for(int x = 0;x < arr.length;x++){
			Integer value = tm.get(arr[x]);
			if(value==null){
				tm.put(arr[x], 1);
			}
			else{
				value = value + 1;
				tm.put(arr[x], value);
			}
		}
		Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Character,Integer>> iter = entrySet.iterator();
		StringBuilder sb = new StringBuilder();
		while(iter.hasNext()){
			Map.Entry<Character, Integer> me = iter.next();
			Character chr = me.getKey();
			Integer in = me.getValue();
			sb.append(chr+"("+in+")");
		}
		System.out.print(sb.toString());
			
		return sb.toString();
	}
}

 

第二节--集合框架工具类

Collections:

是对集合对象进行操作的工具类，提供的方法都是静态方法，不需要创建对象。很多方法都是对List集合进行操作的。

常见操作

1、查找

        T max(Collection<? extends T> coll);根据集合的自然顺序，获取coll集合中的最大元素

        T max(Collection<? extends T> coll,Comparator<? super T> comp);根据指定比较器comp的顺序，获取coll集合中的最大元素

        int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);二分法搜索list集合中的指定对象

2、替换

        voidfill(List<? super T> list, T obj);将list集合中的全部元素替换成指定对象obj

        booleanreplaceAll(List<T> lsit,T oldVal,T newVal);用newVal替换集合中的oldVal值

        void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素

3排序：

        void shuffle(List<?> list);使用默认随机源对list集合中的元素进行随机排序

        void sort(Lsit<T> list);根据自然顺序对list集合中的元素进行排序

        voidsort(List<T> lsit,Comparator<? super T> c);根据指定比较器c的排序方式对list集合进行排序

4、反转

        reverse(List<?> list);反转list集合中元素的顺序

        Comparator reverseOrder();返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

        ComparatorreverseOrder(Comparator<T> cmp);返回一个比较器，强行逆转了指定比较器的顺序

5、同步的集合

        List<T>synchronizedList(List<T> list);返回支持的同步（线程安全的）List集合

       Map<K,V>synchronizedList(Map<K,V> m);返回支持的同步（线程安全的）Map集合

Arrays：

对数组对象进行操作的工具类，内部定义的都是静态方法。

常见操作：

1、Lsit<T> asList(T... a);//将数组转换为集合

        a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。

        b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。

        c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

2、binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等

  特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。

    如：sort(T[]a,Comparator<? super T> c)

               fill(int[]a,int from,int to)等

3、String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。