黑马程序员_集合2

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

一   泛型
1 JDK1.5出现的新特性，是一种安全机制。在定义集合时就指定存储类型。
比如：ArrayList<String> al=new ArrayList<String>();表示集合只能存String类型的对象。
2 好处：
（1）将运行时异常转移到编译时异常
（2）避免了类型强转
3 泛型类：当类中要操作的数据类型不确定时，可以在类上定义泛型来进行扩展。但是泛型类上的引用类型一旦确定，方法上操作的类型也固定了。
格式：class<T>{}

4 泛型方法：泛型定义在方法上，方法中操作的类型不用跟着类上的类型。
格式：public <T> void show(T t){}

5 静态方法不可以访问类上定义的类型。如果静态方法操作的类型不确定，泛型可以定义在方法上。

6 泛型限定
（1）?占位符，通配符。当操作类型不明确时，可以用?表示，可以接收一切对象。
（2）泛型限定：
     ? extends E：可以接收E类型和E的子类类型
     ? super E: 可以接收E类型和E的父类类型

二    Map集合

1 Map集合：Map集合存的元素是以键值对存在的，并且保证键的唯一性。
（1）Map集合有两种特有的取出方式：
 keySet();返回键的Set集合，再通过Set集合的特有方法迭代器取出键，再通过键取出值
 entrySet();返回键值的映射关系Set集合，通过Set集合的特有方法迭代器取出映射关系，类型是Map.Entry。通过Map.Entry的特有方法取出键和值
例子如下：

import java.util.*;
class  MapDemo
{
	public static void main(String[] args) 
	{
		//定义一个Map子类集合，并添加元素，指定键值都是String类型
		HashMap<String,String> mp=new HashMap<String,String>();
		mp.put("alisi1","11");
		mp.put("ulisi1","11");
		mp.put("ylisi2","11");
		mp.put("lisi3","11");
		mp.put("alisi1","11");
		mp.put("tlisi4","11");

		get1(mp);//第一中取出方式
		System.out.println("------------------------");
		get2(mp);//第二种取出方式
		
	}
	//第一种方式：定义一个函数用于取出Map集合的元素
	public static void get1(HashMap<String,String> mp)
	{
		//使用keySet()方法，获取键的集合Set
		Set<String> keyset=mp.keySet();
		//用Set集合的特有方法迭代器获取键
		Iterator<String> it=keyset.iterator();
		while(it.hasNext())
		{
			String key=it.next();
			//利用键获取值
			String value=mp.get(key);
			//打印元素
			System.out.println(key+"::"+value);
		}
	}
	//第二种方式：定义一个函数用于取出Map集合的元素
	public static void get2(HashMap<String,String> mp)
	{
		//使用entrySet()获取键值对的映射关系集合set，类型是Map.Entry
		Set<Map.Entry<String,String>> entryset=mp.entrySet();
		用Set集合的特有方法迭代器获键值的映射关系
		Iterator<Map.Entry<String,String>> ite=entryset.iterator();
		while(ite.hasNext())
		{
			Map.Entry<String,String> me=ite.next();
			//使用Map.Entry的特有方法获取键和值
			String key=me.getKey();
			String value=me.getValue();
			//打印元素
			System.out.println(key+"::"+value);
		}	
	}
}

（2）Map集合下有三个常见的子类对象Hashtable、HashMap、TreeMap。
     Hashtable:底层是哈希表数据结构，不可以存null键null值，线程是同步的。
     HashMap:底层是哈希表数据结构，可以存null键null值，线程是不同步的。
     TreeMap：底层是二叉树数据结构，线程不同步，可以给键值排序。

HashMap举例：

import java.util.*;
//定义学生类实现Comparable让学生具备比较性
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//覆盖compareTo定义学生的比较方式
	public int compareTo(Student s)
	{
		int num=this.name.compareTo(s.name);
		if(num==0)
			return new Integer(this.age).compareTo(new Integer(s.age));
		return num;
	}
	//覆盖equals()方法，定义自己判断元素的唯一性
	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;
	}
	//覆盖hashCode()定义自己的哈希值
	public int hashCode()
	{
		return name.hashCode()+age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
//定义一个比较器加泛型比较学生
class Mycomp implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		//按学生年龄排序
		int num=s1.getAge()-s2.getAge();
		if(num==0)//如果年龄一样就按名字排序
			return s1.getName().compareTo(s2.getName());
		return num;
	}
}
class TreeMapDemo 
{
	public static void main(String[] args) 
	{
		//定义一个TreeMap集合，存储学生和地址。并将比较器传进来，按照比较器的排序方法排序
		TreeMap<Student,String> tm=new TreeMap<Student,String>(new Mycomp());
		//添加元素
		tm.put(new Student("lisi4",23),"beijing");
		tm.put(new Student("lisi2",33),"beijing");
		tm.put(new Student("lisi9",3),"beijing");
		tm.put(new Student("lisi7",7),"beijing");
		tm.put(new Student("lisi1",23),"beijing");
		//获取学生的地址的键值对映射关系
		Set<Map.Entry<Student,String>> entryset=tm.entrySet();
		//用集合的迭代器取出
		Iterator<Map.Entry<Student,String>> ite=entryset.iterator();
		while(ite.hasNext())
		{
			//用Map.Entry特有方法取出元素
			Map.Entry<Student,String> me=ite.next();
			Student stu=me.getKey();
			String value=me.getValue();
			System.out.println(stu.getName()+"::"+stu.getAge()+"::"+value);
		}
	}
}

三    工具类
1 Collections类：用于操作集合的工具类，方法都是静态的。
（1）方法摘要：
sort(List):对List集合的元素进行排序
max(Collection):获取集合的最大元素
binarySearch(List,Key):用二分查找获取某个元素在集合的位置。元素必须是有序。
replaceAll(List,oldkey,newkey):将集合中指定元素换成指定的新元素
fill(List,key):将集合的所有元素换成指定的元素
reverse(List):反转集合中元素顺序
shuffle(List),随机排序

2 Arrays类：方法都是静态的，用于操作数组的工具类
（1）方法摘要：
asList(数组):将数组变成集合，但不可以使用集合的增删方法，因为数组是固定长度的
toString(数组)：将数组变字符串

3 高级for循环:1.5版本的特性
（1）可以对集合元素进行获取，格式：for(元素类型 变量：集合)

例如：

import java.util.*;
class  ForDemo
{
	public static void main(String[] args) 
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("a");
		al.add("aa");
		al.add("aaa");
		al.add("aaaa");
		for(String str:al)
		{
			System.out.println(str);
		}
	}
}

（2）高级for循环在进行遍历集合的过程中，不能对集合进行操作
（3）高级for循环还可以对数组进行遍历
例如：

class  ForDemo
{
	public static void main(String[] args) 
	{
		int[] arr={1,3,5,7};
		for(int num:arr)
		{
			System.out.println(num);
		}
	}
}

（4）高级for循环必须要有操作的目标，不能跟传统for循环一样控制循环次数