Java高级特性 集合框架、泛型和Collection(补充)(第二十三天)

Map接口

Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作
    1）最常用的实现类是HashMap

Map接口常用方法

方法名	说明
Object put(Object key, Object val)	以“键-值”对的方式进行存储
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove(Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在由指定的键映射的“键-值对”，返回true

遍历Map集合 

方法1：通过迭代器Iterator实现遍历 
方法2：增强型for循环
方法3：键值对

package GatherDemo03;

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

public class HashMapDemo01 {

	public static void main(String[] args) {
		//准备容器：创建HashMap对象
		HashMap<String, String> hm = new HashMap<String, String>();
		
		//准备元素并将元素存储到集合中
		hm.put("CN", "中华人民共和国");
		hm.put("JP", "小日本");
		hm.put("RU", "俄罗斯联邦");
		hm.put("USA", "美利坚合众国");
		hm.put("UK", "大不列颠及北爱尔兰联合王国");
		System.out.println(hm.size());

		//遍历键值对的3种方式
		//方式一：获取键的集合，然后在遍历键的集合过程中调用get()方法获取值
		Set<String> keys2 = hm.keySet();
		for (String key : keys2) {
			//根据键获取值
			String value=hm.get(key);
			System.out.println(key+"---"+value);
		}
		
		System.out.println("********************************");
		
		//方式二：获取键的集合，然后在遍历键的集合过程中调用get()方法获取值
		Set<String> keys3=hm.keySet();
		Iterator<String> it = keys3.iterator();
		while (it.hasNext()) {
			String key = it.next();
			//获得键
			String value=hm.get(key);
			System.out.println(key+"---"+value);
		}
		
		System.out.println("********************************");
		
		//方式三：键值对遍历，将hm集合中的键值对整体取出来后放入到Set集合中
		/*
		 *1)使用entrySet( )方法将hm集合中的键值对整体取出来放在Set集合中  
		 *
		 *2)然后使用增强for循环或者迭代器取出Set集合中的键值对元素，取出来的
		 *  是Object类型，实际，上键值对的真正类型是Map. Entry类型
		 *
		 *3)所以将取出来的元素强制转换为Map. Entry类型，Map. Entry类中有getKey( )
		 *  方法获取键值对的键，有getValue( )方法获取键值对的值
		 */
		Set<Map.Entry<String,String>> keyValues=hm.entrySet();
		for (Map.Entry<String,String> me : keyValues) {
			//获取键
			String key=me.getKey();
			//根据键获取值
			String value=me.getValue();
			System.out.println(key+"---"+value);
		}	
	}

}

package GatherDemo03;

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

public class HashMapDemo01 {

	public static void main(String[] args) {
		//准备容器：创建HashMap对象
		HashMap<String, String> hm = new HashMap<String, String>();
		
		//准备元素并将元素存储到集合中
		hm.put("CN", "中华人民共和国");
		hm.put("JP", "小日本");
		hm.put("RU", "俄罗斯联邦");
		hm.put("USA", "美利坚合众国");
		hm.put("UK", "大不列颠及北爱尔兰联合王国");
		System.out.println(hm.size());
		
		//根据键获取对应的值
		Object obj1=hm.get("CN");
		String str1=(String)obj1;
		System.out.println(str1);
		System.out.println(hm.get("CNN"));
		
		//删除集合中的元素
		String str2=hm.remove("JP");
		System.out.println(str2);
		
		System.out.println(hm.size());//删除元素JP，还有4个元素
		
		//获取HashMep集合中所有键值对的键
		Set<String> keys=hm.keySet();
		for (String key : keys) {
			System.out.println(key);
		}
		
		//获取HashMep集合中所有键值对的值
		Collection<String> values= hm.values();
		for (String value : values) {
			System.out.println(value);
		}
		
		//查询集合中是否存在指定键对应的键值对
		System.out.println(hm.containsKey("RU"));//true
		System.out.println(hm.containsKey("JP"));//false

		}	
	}

}

泛型

将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性
本质是参数化类型

泛型集合

泛型集合可以约束集合内的元素类型 

典型泛型集合ArrayList<E>、HashMap<K,V>
        1）<E>、<K,V>表示该泛型集合中的元素类型
        2）泛型集合中的数据不再转换为Object

语法：

HashMap<K,V>  集合名= new HashMap<K,V>();

Collections算法类

Java集合框架将针对不同数据结构算法的实现都保存在工具类中

Collections类定义了一系列用于操作集合的静态方法

Collections类常用方法

Collections和Collection不同，前者是集合的操作类，后者是集合接口

Collections提供的常用静态方法
     1）sort():排序
     2）binarySearch()：查找
     3）max()\min():查找最大\最小值

Collections排序

Collections类可以对集合进行排序、查找和替换操作

实现一个类的对象之间比较大小，该类要实现Comparable接口
      重写compareTo()方法

package GatherDemo04;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionsDemo01 {

	public static void main(String[] args) {
		
		ArrayList<String> al = new ArrayList<String>();
		
		al.add("qwe");
		al.add("abc");
		al.add("rds");
		al.add("asd");
		al.add("kjh");
		al.add("dgt");
		
		//遍历集合
		for (String string : al) {
			System.out.println(string);
		}
		
		System.out.println("排序后");
		//集合元素升序排序
		Collections.sort(al);
		for (String string : al) {
			System.out.println(string);
		}
		
		
		//查找元素，注意。查找元素之前集合要进行升序排序，否则，不能保证查找结果的正确性
		int index =Collections.binarySearch(al, "abc");
		System.out.println(index);//0
		int index2 =Collections.binarySearch(al, "dsajfhjsadfh");//查找不存在的元素返回负值
		System.out.println(index2);
		
		System.out.println(Collections.max(al));
		System.out.println(Collections.min(al));
	}

}

package GatherDemo04;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionsDemo02 {

	public static void main(String[] args) {
		// 准备容器：创建集合对象
		ArrayList<Student> al = new ArrayList<Student>();

		// 准备数据：创建Student对象
		Student stu1 = new Student("张三", 22);
		Student stu2 = new Student("李四", 21);
		Student stu3 = new Student("王五", 25);
		Student stu4 = new Student("赵六", 20);
		Student stu5 = new Student("孙七", 26);

		// 将对象存储到集合中
		al.add(stu1);
		al.add(stu2);
		al.add(stu3);
		al.add(stu4);
		al.add(stu5);

		// 遍历集合
		for (Student student : al) {
			System.out.println(student);
		}

		// 对集合进行排序
		Collections.sort(al);

		// 遍历集合
		System.out.println("排序后：");
		for (Student student : al) {
			System.out.println(student);
		}


// 输出byte类型的最大值和最小值
		System.out.println(Byte.MIN_VALUE);
		System.out.println(Byte.MAX_VALUE);
		
		System.out.println(Short.MIN_VALUE);
		System.out.println(Short.MAX_VALUE);

	}

}