黑马程序员——Java基础知识（集合框架（下））

一、泛型

泛型：JDK 1.5之后出现的新特性，用于解决安全问题，是一个类型安全机制，允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。将类型参数化，以达到代码复用提高软件开发工作效率的一种数据类型。泛类型是引用类型，是堆对象。

 好处：
1.将运行时出现的问题ClassCastExcrption，转移到了编译时期，方便于程序员解决问题，让运行事情问题减少，更安全。
2.避免了强制转换的麻烦

泛型格式：通过<>来定义要操作的引用数据类型
示例：ArrayList<String> a = new ArrayList<String>();

其实<>就是用来接收类型的， 当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

什么时候要定义泛型类？

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。泛型类定义的泛型在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上，泛型放在返回值类型的前面，修饰符的后面。

泛型定义在类上：

class Demo<T>
{
public void show(T t)   
{
System.out.println("show:"+t);
}
public void print(T t)
{
System.out.println("print:"+t);
}
}

泛型定义在方法上：
class Demo
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
}


特殊之处：
静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上

泛型定义在接口上：
复写往里面传参数，一般都是定义好拿来用，泛型类和泛型方法可能会见到，如果是静态，泛型一定要定义在方法上

interface Inter<T>
{
void show(T t);
}

class InetrImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show:"+t);
}
}
class  GenericDemo
{
public static void main(String[] args) 
{
InterImpl<Integer> i = new IntegerImpl<Integer>();
i.show(4)
}
}

泛型的限定

如果不知道泛型是什么类型，或者需要传入类型多样可以用通配符 ？ 也可以理解为占位符 <?>，也可以用<T>代替；

对于一个范围内的一类型事物，可以通过泛型限定的方式定义，有两种方式：：
？ extends E: 可以接受E类型或者E的子类型。上限，即可以接受父类类型及它的所有子类类型
？ super E: 可以接受E类型或者E的父类型。下限，即可以接受子类类型及他的父类类型

代码：

import java.util.*;
class  GenericDemo
{
	public static void main(String[] args) 
	{
		
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Student("abc01"));
		ts.add(new Student("abc02"));
		ts.add(new Student("abc03"));
		ts.add(new Student("abc04"));

		for(Iterator<Student> it = ts.iterator(); it.hasNext(); )
		{
			System.out.println(it.next().getName());
		}

		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
		ts1.add(new Worker("work--01"));
		ts1.add(new Worker("work--03"));
		ts1.add(new Worker("work--02"));
		ts1.add(new Worker("work--04"));

		for(Iterator<Worker> it1 = ts1.iterator(); it1.hasNext(); )
		{
			System.out.println(it1.next().getName());
		}
	}
}

/*可以用父类的比较器 方法 泛型限定是用于泛型扩展用的不用每个对象集合都创建一个比较器来保证唯一性
class StuComp implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
class WorkerComp implements Comparator<Worker>
{
	public int compare(Worker s1,Worker s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
*/
//自定义一个父类比较器，
class Comp implements Comparator<Person>
{
	public int compare(Person s1,Person s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
//继承Person父类
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}
//继承Person父类
class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}

二、Map

Map集合：Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字。该集合存储键值对，一对一对往里存，而且要保证键（key）的唯一性。

Map的子类：
|--Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的
|--HashMap: 底层是哈希表数据结构，并允许使用null键null值，该集合是不同步的，高效
|--TreeMap:底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序
Map和Set集合很像，其实Set底层就是使用了Map集合。

Map集合的常用方法
1.添加
put(K key, V value) //返回的是原来的值
putAll(Map<? extends K,? extends V> m)//添加一个集合
2.删除
clear()//清空
remove(Object key)//删除指定键值对
3.判断
containsValue(Object value)//判断值是否存在
containKey(Object key)//判断键是否存在
isEmpty()//判断是否为空
4.获取

get(Object value)通过键获取对应的值，可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断
size() //获取集合的长度
value() //获取Map集合中所以得值，返回一个Collection集合
重点了解一下两个获取方法：
entrySet()
keySet()

添加元素 如果出现添加时，相同的键，那么后添加的值会覆盖原有的键对应的值，并put方法会返回被覆盖的那个值，如果原来没有值，会返回null。

Map的两种取出方式：

1、keySet:将map中所有的键存入到Set集合，因为set具备迭代器，所以可以用迭代方式取出所有的键，根据get方法，获取每个键对应的值。
Map集合的取出原理：将Map集合转成Set集合，再通过迭代器取出
Set<key的类型> a = b.keySet();再通过迭代器取出

2、Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中。而这个关系的数据类型就是Map.Entry

import java.util.*;
class  MapDemo2
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("04","zhangsan4");
		
		//将Map集合中的映射关系取出，存入到Set集合中

		Set<Map.Entry<String,String>> entrySet = map.entrySet();
		for(Iterator<Map.Entry<String,String>> it = entrySet.iterator();it.hasNext(); )
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();

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


		/*
		//先获取map集合的所有键的Set集合，keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合就可以获取其迭代器
		for(Iterator<String> it = keySet.iterator();it.hasNext();)
		{
			//获取键
			String key = it.next();
			//有了键可以通过map集合的get方法获取其对应的值
			String value = map.get(key);
			System.out.println("key:"+key+"  "+"value:"+value);
			
		}*/
	}
}

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

        原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

                     b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

interface Map
{
public static interface Entry//接口在成员位置上才能加静态修饰符
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class haha implements Map.Entry
{
public Object getKey(){};
public Object getValue(){};
}
}

练习：每一个学生都有对应的归属地，学生Student，地址类型String。学生属性：姓名，年龄
注意：姓名和年龄相同的视为同一个学生，保证学生的唯一性

/*
1.描述学生
2.定义map容器，将学生作为键，地址作为值，存入
3.获取map集合中的元素

*/


import java.util.*;

class  MapTest
{
	public static void main(String[] args) 
	{
		HashMap<Student,String> hm = new HashMap<Student,String>();
		hm.put(new Student("lisi01",21),"beijing");
		hm.put(new Student("zhangsan",20),"shanghai");
		hm.put(new Student("wangwu",23),"wuhan");
		hm.put(new Student("wangmazi",21),"guangzhou");
		//第一种取出方式：
		Set<Student> keySet = hm.keySet();
		for(Iterator<Student> it = keySet.iterator(); it.hasNext();)
		{
			Student stu = it.next();
			String addr = hm.get(stu);
			System.out.println(stu+"..."+addr);
		}
		//第二种取出方式entrySet
		Set<Map.Entry<Student,String>> mp = hm.entrySet();
		for(Iterator<Map.Entry<Student,String>> iter = mp.iterator(); iter.hasNext();)
		{
			Map.Entry<Student,String> me = iter.next();
			Student stu1 = me.getKey();
			String addr1 = me.getValue();
			System.out.println(stu1+"......."+addr1);
		}
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age; 
	}
	//学生对象很多也可能存入二叉树，确保唯一性并进行排序
	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;
	}

	//当事物对象很多，可能要存入HashSet，即哈希表里面的时候，要判定这元素不重复的条件，
	//需要判定hashCode和equals
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))//判断传入的是否是学生
			throw new ClassCastException("类型不匹配");//类型不匹配直接停止程序，抛异常
		Student s = (Student)obj;//是学生的话就进行强转：向下转型
		return this.name.equals(s.name) && this.age == s.age;//姓名和年龄都匹配
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆盖toString  建立学生对象自定义的表现形式 都转化为字符串
	public String toString()
	{
		return name+":"+age;
	}
}

注意：当发现有映射关系时，可以选择map集合，因为map集合中存放的就是映射关系

Map集合的应用及扩展

"asdfwaefasdgergasdferasdfa"获取该字符串中的字母出现的次数，希望打印结果是a(6)d(4).....

/*
思路：
1.将字符串转成字符数组，因为要对每一个字母进行操作

2.定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合

3.遍历字符数组，将每一个字母作为键去查map集合
		如果返回null,将该字母和1存入map集合中
		如果返回不是null,说明该字母在map集合中存在并有相应次数
		那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖掉原键的值
4.将map集合中的数据变成指定的字符串形式返回

*/

import java.util.*;
class  MapTest3
{
	public static void main(String[] args) 
	{
		String s = charCount("asdfwaefasdgergasdferasdfa");
		System.out.print(s);
	}
	public static String charCount(String str)
	{
			//Character 可以自动排序
		char[] chs = str.toCharArray();
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
			
		int count = 0;
		for (int x = 0; x<chs.length; x++)
		{
			/*可以简化为下面代码
			if(value == null)
			{
				tm.put(chs[x],1);
			}
			else
			{
				value = value + 1;
				tm.put(chs[x],value);
			}
			*/
			if(!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]<='Z'))
				continue; //如果不是字母继续循环
				
			Integer value = tm.get(chs[x]);
			
			if(value!=null)  //如果为空++后打印，如果不为空先把value的值赋给count再++打印
				count = value;
			count++;
			tm.put(chs[x],count);
			count = 0; //没计算一次清零

			
		}
		StringBuilder sb = new StringBuilder();
		Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
		for (Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator(); it.hasNext(); )
		{
			Map.Entry<Character,Integer> me = it.next();
			Character ch = me.getKey();
			Integer in = me.getValue();
			sb.append(ch+"("+in+")");
			//System.out.print(ch+"("+in+")");
		}

		return sb.toString();
	}
}