(10)Java泛型-Map集合-集合框架工具类-可变参数-静态导入
部分1.5新特性Java泛型-Map集合-集合框架工具类
泛型
概述：
JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
对于泛型可以这样理解：
没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。
好处：
1， 将运行时期出现的问题ClassCastException。转移到编译时期。方便程序员解决问题，让运行运行时异常减少，较安全。
2， 避免了强制转换的麻烦。
泛型格式：
通过<>来定义要操作的引用数据类型。
放到返回类型的前面，修饰符的后面不然会报错
示例：ArrayList
泛型类
什么是泛型类，简单的说就是带泛型的类。
在泛型出现之前，比如对于定义工具类，接收的类型不一样，比较通用的方法是采用多态的形式来实现。因为要让任意类的实例都可以使用所以设置所有类的父类Object。
示例：
class Student
{}
class Worker
{}
class Tool{
private Object obj;
public void setObject(Object obj){
this.obj = obj;
}
public Object getObject(){
return obj
}
}
class {
public static void main(String[] args) {
Tool t = new Tool();
t.setObject(new Student());
Student s = (Student)t.getObject()//需要对其向下转型object转student
//t.setObject(new worker());
//Student s = (Student)t.getObject()就会报类型转换错误异常
}
}因为早期使用Object来完成扩展，后面还需要对其转型使用，若不注意容易导致编译时期JVM看不出来问题但是用户运行时会报错。
所以在JDK1.5升级后我们就可以定义泛型类实现，原理一样。
示例：
class Student
{}
class Worker
{}
class Tool{
private W w;
public void setW(W w){
this.w = w;
}
public W getW(){
return w;
}
}
class {
public static void main(String[] args) {
Tool t = new Tool Student> ()<;
//加上泛型由我们指定哪个类型来使用工具类
t.setW(new Student());
Student s = t.getW();
//不用再强转。
}
} 那什么时候定义泛型类？
当类中要操作的引用数据类型不确定时候。
泛型除了定义在类上还可以定义在方法上
泛型方法：
因为泛型类定义的泛型，在整个类中有效，如果被对方使用，那么泛型类的对象明确要操作的具体类型后，所要操作的类型就已经固定了。
为了让不同方法可以操作不用类型，而且类型还不确定，那么可以将泛型定义在方法上。
示例：
lass Demo{
public void show(T t)//泛型定义在方法上{
System.out.println("Hello show!"+t);
}
public void run(T t)//泛型定义在方法上{
System.out.println("Hello run!"+t);
}
}
class FanXingDemo {
public static void main(String[] args)
{
Demo d = new Demo();
d.show("kj");
d.show(3);
d.run(3);
}
} 使用泛型方法，你传什么类型他就是什么类型了
注意：静态方法不可以访问类上定义的泛型。
为什么？因为Demo
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
泛型接口代码示例：
Interface Iner{
Void show(T t);
}
Class InerImp implements Iner{
Public void show(T t){
System.out.println(“show:”+t);
}
}
Class FanXingDemo2{
Public static void main(Sting[] args){
InerImp in = new InerImp ();
In.show(“rtyu”);
}
} 泛型高级应用
泛型限定：是用于泛型的扩展用的。
？通配符，也可以理解为占位符。
？ extends E：可以接收E类型或者E 的子类型，向上限定。
？ super E：可以接收E类型或者E的父类型，向下限定。
示例：
import java.util.*;
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
class FanXingDemo3{
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person("lisi"));
al.add(new Person("lisi"));
al.add(new Person("lisi"));
al.add(new Person("lisi"));
getIt(al);
ArrayList al1 = new ArrayList();
al1.add(new Student("lisi1"));
al1.add(new Student("lisi2"));
al1.add(new Student("lisi3"));
al1.add(new Student("lisi4"));
getIt(al1);
}
public static void getIt(Collection< ?extends Person> al){
for (Iterator it = al.iterator();it.hasNext() ; ){
System.out.println(it.next().getName());
}
}
} 泛型限定2
如：在TreeSet集合中，需要对其存储对象比较
若只是指定当前类型就只能比较当前对象，
但是指定他们的父类型，就都可以指定了，不用再多写比较器了
示例：
import java.util.*;
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
class Worker extends Person{
Worker(String name){
super(name);
}
}
class Cmp implements Comparator
{//定义比较器，若只是指定当前类型就只能比较当前对象，
//但是指定他们的父类型，就都可以指定了，不用再多写比较器了
public int compare(Person p1,Person p2){
return p1.getName().compareTo(p2.getName());
}
}
class Demo {
public static void main(String[] args) {
TreeSet al = new TreeSet(new Cmp());
al.add(new Person("lisi2"));
al.add(new Person("lisi3"));
al.add(new Person("lisi4"));
al.add(new Person("lisi2"));
getIt(al);
TreeSet al1 = new TreeSet(new Cmp());
al1.add(new Student("lisi1"));
al1.add(new Student("lisi23"));
al1.add(new Student("lisi43"));
al1.add(new Student("lisi64"));
getIt(al1);
}
public static void getIt(Collection< ?extends Person> al){
for (Iterator it = al.iterator();it.hasNext() ; ){
System.out.println(it.next().getName());
}
}
}打印结果： 
Map集合
概述：
Map
基本特点：
该集合是存储键值对，是一对一对忘集合里面存储，而且要保证键的唯一性。
常用方法：
添加：
1， put(K ket,Value) 添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原 有键对应值，并put方法会返回被覆盖的值。
2， putAll(Map m)添加一个集合
删除：
1， clear()清空
2， remove(Objet key) 删除集合里的指定元素
判断：
1， containsValue(Obect value)判断指定值是否存在
2， containsKey(Object key)判断指定键是否存在
3， isEmpty()判断是否为空
获取：
1， V get(Object obj)通过键获取值
2， size()获取集合长度
3， Collection
Set
Set
Map集合的子类
Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键，集合是线程同步的。JDK1.0效率第。
|--HashMap:底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。JDK1.2效率高
|--TreeMap;底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序
注意：
1， 在添加元素，如果出现添加时相同的键，那么后添加的值会覆盖原有键对应的值。并put方法会返回被覆盖的值。
2， 在通过get方法的返回值来判断一个键是否存在，通过返回null来判断。
Map集合的两种取出方式：
方式一：
Set
Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。
示例：
import java.util.*;
class MapDemo1{
public static void main(String[] args) {
HashMapmap = new HashMap();
map.put("lisi","22");
map.put("zhangsan","34");
map.put("wangwu","56");
map.put("xiaoba","11");
Setkeyset = map.keySet();//把map集合里的所有键取出。
Iteratorit = keyset.iterator();
while (it.hasNext()){
String key = it.next();//获取每一个键
String value = map.get(key);//根据键获取值。
System.out.println("key:"+key+"value:"+value);
}
}
} 方式二：
Set
简单说：关系是结婚证，可以根据结婚证来获取丈夫和妻子。
示例：
import java.util.*;
class MapDemo2{
public static void main(String[] args) {
HashMapmap = new HashMap();
map.put("lisi","22");
map.put("zhangsan","34");
map.put("wangwu","56");
map.put("xiaoba","11");
//通过entrySet()方法，获取器映射关系即Map.Entry,同时还要知道键值的泛型是String类型
Set> sme = map.entrySet();
//迭代取出关系，返回类型一样
Iterator> it = sme.iterator();
while (it.hasNext()){
Map.Entry me = it.next();
String key = me.getKey();取出键
String value = me.getValue();取出值
System.out.println("key:"+key+"value:"+value);
}
}
} 深入分析：
为什么映射关系的类型是Map.Entry?
其实Entry也是接口，他是Map接口中的一个内部接口。
interface Map{
public static interface Entry{
public abstract Object getKey();
public abstract Object getValue();
}
}为什么把Entry定义成Map的内部接口？
因为Entry代表一种关系，但是现有Map才有关系，是属于Map的内部事物，所以才定义成内部规则。比如，心脏是人体内的事物，必须要定义内部规则，一样道理。
Map练习：
*
需求：每一个学生都有一个对应的归属地，学生Student，地址String
学生属性：姓名，年龄
注意姓名和年龄相同的视为同一个学生，保证唯一性
*/
import java.util.*;
class Student implements Comparable{//实现Comparable接口并定义泛型
private String name;
private int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public int compareTo(Student s){//复写compareTo方法
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode(){
return name.hashCode()+age*77;
}
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;
}
public String toString(){
return name+""+age;
}
}
class HashMapDemo3{
public static void main(String[] args) {
HashMap hm = new HashMap();
hm.put(new Student("lisi1",33),"beijing");
hm.put(new Student("lisi2",23),"shanghai");
hm.put(new Student("lisi3",11),"wuhan");
hm.put(new Student("lisi4",44),"sichuan");
hm.put(new Student("lisi5",22),"beijing");
//第一种取出方式
Setss1 = hm.keySet();//将学生键存储进集合
Iterator it1 = ss1.iterator();
while (it1.hasNext()){
Student key = it1.next();
String value = hm.get(key);
System.out.println(key+"地址是："+value);
}
//第二种取出方式
Set> ss2 = hm.entrySet();
Iterator> it2 = ss2.iterator();
while (it2.hasNext()){
Map.Entry myentry = it2.next();
Student stu = myentry.getKey();
String str = myentry.getValue();
System.out.println(stu+"地址是 ："+str);
}
}
} 
如果需要对学生对象进行年龄进行升序排序。我们可以加入比较器，因为数据是以键值对形式存在的，所以要使用可以排序的Map集合，TreeMap
练习：
/*
需求：获取字符串中字母出现的次数，“qwertyuiasdfghjqwertyusdfghjsdf”
希望打印结果是a(1)c(2).....
通过结果发现每一个字母都对应相应的次数，说明字母和次数键存在映射关系
这时需要使用Map集合
思路：
1，因为要对每一个字母操作，所以需要字符串转成字符数组
2，对应map集合，因为打印结果的字母有顺序，所以使用trremap集合
3，遍历数组，将每一个字母作为键去map集合中查找
若返回null就将字母和1存入map集合
若返回！null说明该字母在集合中有对应的次数那么就将该次数自增一次，
再存入map集合覆盖原有次数
4，将map集合中的数据转变成指定字符串输出。
*/
import java.util.*;
class MapDemo4{
public static void main(String[] args) {
String s = Demo_1("qwertyuqwertyusdfsgdsdsfsdf");
System.out.println(s);
}
public static String Demo_1(String str){
//将传进来的字符串转成字符数组
char[] ch = str.toCharArray();
//建立TreeMap集合，因为不能接受基本数据类型，所以使用数据包装类。
TreeMap tm = new TreeMap();
int count = 0;//计数器记录次数
for (int x=0;x='a'&&ch[x]<='z')||((ch[x]>='A'&&ch[x]<='Z')))
continue;
//根据键获取值
Integer value = tm.get(ch[x]);
//若值不为null将自增后的次数赋值
if (value!=null)
count = value;
//如果值为null
count++;
tm.put(ch[x],count);
count=0;//清零
}//定义缓冲区存储键和值
StringBuilder sb = new StringBuilder();
//将键值映射关系存储进集合
Set> s = tm.entrySet();
Iterator> it = s.iterator();
//取出映射关系
while (it.hasNext())
{
Map.Entry ss = it.next();
Character key = ss.getKey();
Integer value = ss.getValue();
sb.append(key+"("+value+")");//添加进缓冲区
}
return sb.toString();
}
}打印结果如图： 
Map集合的扩展知识
因为map集合具备映射关系，而在实际中许多都是一对多的关系，比如一个学校对应多个班级，一个班级对应多个学生对象，一个学生对象对应其多个属性。这样的映射关系，就形成了一个映射体系。相当于大集合套小集合，把小集合作为映射的对象
示例：
班级对应学生
"yureban" student("01","wangwu")
"yureban" student("01","zhouqi")
"jiuyeban" student("12","lisi")
"jiuyeban" student("13","zhangsan")
学校对应班级
"czbk" "yureban"
"czbk" "jiuyeban"
打印全校学生的信息：
import java.util.*;
class Demo5{
public static void main(String[] args) {
//预热班学生集合
HashMapyureban = new HashMap();
//就业班学生集合
HashMapjiuyeban = new HashMap();
//学校班级集合
HashMap>czbk = new HashMap>();
//添加班级进学校班级集合
czbk.put("yureban",yureban);
czbk.put("jiuyeban",jiuyeban);
//添加预热班学生进集合
yureban.put("01","wangwu");
yureban.put("02","zhouqi");
//添加就业班学生进集合
jiuyeban.put("12","lisi");
jiuyeban.put("13","zhangsan");
getAllStudent(czbk);
}
//定义一个获取全部学生信息的集合,
public static void getAllStudent(HashMap> hm){
Iterator it1 = hm.keySet().iterator();
while (it1.hasNext()){
//返回班级名称
String s = it1.next();
System.out.println(s+"：");
//返回班级学生集合
HashMap hs = hm.get(s);
getStudent(hs);
}
}
public static void getStudent(HashMap hm){
Iterator it2 = hm.keySet().iterator();
while (it2.hasNext()){
//返回学生姓名
String name = it2.next();
//返回学生id
String id = hm.get(name);
System.out.println(name+":"+id);
}
}
}打印结果： 
集合框架工具类之Conllections
概述：
Conllections是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。
在Conllections工具类中，大部分方法是用于对List集合进行操作。
常见特有操作
查找：
1，T max(Conllectincoll);根据coll集合里面的自然顺序查找集合里的最大元素。
2，T max(Conllectioncoll,ComparatorSuper T>comp);根据指定的comp比较器查找coll集合里的最大元素。
替换：
1， void fill(Listlist,T obj);将list集合里的全部元素替换成指定对象obj。
2， boolean replaceAll(List
3， void swap(List list,int I,int b);指定列表集的指定两个位置进行置换。
排序：
1， void shuffle(List
2， void sort(List
3， void sort(List
反转：
1， reverse(List list);对指定list集合进行反转。
2， Comparator reverseOrder();返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
3， Comparator reverseOrder(Comparator
集合同步：
通常常用的集合都是不安全的，因为高效，如果多线程要操作这些集合，可以通过Collections提供的同步方法，将线程不安全的集合转换成安全的。
1， List
2， Map
示例练习：
/*
需求：对指定list集合中的指定部分元素进行替换，
要求使用Collections中的fill方法。
分析：
1，需要对集合指定的部分元素取出，存储进新的集合
2，使用fill方法对新集合的元素进行替换
3，新集合的元素添加进list集合。
*/
import java.util.*;
class FillDemo{
public static void main(String[] args) {
ArrayListlist = new ArrayList();
list.add("rytuy");
list.add("fdsd");
list.add("yrt");
list.add("cv");
//替换前集合
System.out.println(list);
//对集合指定部分替换
fillSome(list,0,2,"java");
//替换后集合
System.out.println(list);
}
public static void fillSome(Listlist,int start,int end,String str){
if(start>end)
throw new RuntimeException("插入位置非法");
//定义临时集合
List list1 = new ArrayList();
//获取list集合中指定的要置换的元素
//因为在start取一个，后面的一个就变成了start，而让y控制次数
for (int x=start,y=start;y<=end ;y++)
{//获取一个就往临时集合存储一个
list1.add(list.get(x));
//移除list集合需要替换的元素
list.remove(x);
}
//将临时集合的元素替换
Collections.fill(list1,str);
//从start位置开始把临时集合里的元素插入进原集合
list.addAll(start,list1);
}
}打印结果如图： 
集合框架工具类之Arrays
概述
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
Arrays是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。
常见方法：具体查看API文档java.util.Arrats类的方法
binarySearch():使用二分查找
copyOf():
copyOfRange():
deepToString():如果两个指定数组彼此是深层相等 的，则返回 true。
equals()判断某类型数组彼此是否相等
fill()将指定的某类型值分配给某类型数组
hashCode():对指定数组内容返回哈希码值
sort():对指定的数组进行排序
toString();将指定数组内容以字符串形式返回
数组变集合
static
注意：
1， 将谁转换成集合，不可以使用集合的增删方法，因为数组的长度是固定了。如果进行了增删操作，会发生不可以操作异常UnsupportedOperationException
2， 如果数组中的元素都是对象，那么变成集合时，数组中的元素转为集合中的元素。
3， 如果数组中的元素是基本数据类型，那么变成集合时，数组将作为集合元素存在。
示例：
import java.util.*;
class ArraysDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
asListDemo();
}
public static void asListDemo()
{//字符串数组转集合
String[] str = {"wer","sdg","java","array","nihao"};
List list = Arrays.asList(str);
sop(list);
/*基本数据类型不能转集合
int[] in = {1,2,3,4,5};
List list = Arrays.asList(in);
sop(list);*/
}
}集合变数组
Collection接口中的toArray方法
注意：
1， 指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
2， 为什么将集合变数组？
为了限定对元素的操作。不需要进行增删了。和数组变集合道理一样。
示例：
import java.util.*;
class CollectionToArray{
public static void main(String[] args){
ArrayList al = new ArrayList();{
al.add("abc1");
al.add("abc2");
al.add("abc3");
//将集合变为String数组
String[] arr = al.toArray(new String[al.size()]);
//利用Arrays操作数组的方法
System.out.println(Arrays.toString(arr));
}
} 1.5版本新特性
增强for循环
用于对集合的遍历，和iterator功能类似，他的底层结构还是iterator，是为了简化书写。
格式：
for (数据类型变量名：被遍历的集合(Collection)或者数组)
{执行语句}
注意：
高级for循环对集合进行遍历时，只能获取集合元素，但是不能对集合进行操作。
而迭代器除了遍历还可以进行remove集合中的元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有神马区别？
高级for有一个局限性，必须有被遍历的目标。
建议在遍历数组的时候，还是希望用传统for，因为传统for可以定义角标。
示例：
import java.util.*;
class AdvForDemo{
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
HashMap hs = new HashMap();
hs.put(1,"java1");
hs.put(2,"java2");
hs.put(3,"java3");
hs.put(4,"java4");
getFor_1(hs);
getFor_2(hs);
}
public static void getFor_1(HashMap is){
//用keySet方法取出键
Setkeyset = is.keySet();
for (Integer i: keyset)
{
String value = is.get(i);
sop(i+":"+value);
}
}
public static void getFor_2(HashMap is2){
//用entrySet方法取出键值
for(Map.Entry keyset2:is2.entrySet()){
Integer in = keyset2.getKey();
String str = keyset2.getValue();
sop(in+": "+str);
}
}
} 1.5版本新特性
可变参数
如果一个方法在参数列表中传入多个参数，当参数个数不确实时，每次都要重载其方法比较麻烦，这时可以用数组作为形式参数传入，但是每次还是要定义一个数组对象，所以在1.5版本后，java提供了一个新特性即可变参数。
其实可变参数就是数组参数的简写形式，不用每次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。他是隐式的将这些参数封装成了数组。
注意：
可变参数一定要定义在参数列表的最后面。
示例：
class ParamMethodDemo{
public static void main(String[] args){
show("haha",2,3,4,5,6);
}
public static void show(String str,int... arr)//...就表示可变参数{
System.out.println(arr.length);
}
} 1.5版本新特性
静态导入
静态导入类似于import导入java相关类，它导入的是静态成员，这样在编写程序时可以减少书写
格式：
import static java.util.Arrays.*;//导入了Arrays类中的所有静态成员。
Import static java.lang.System.*;//导入了System类中的所有静态成员。
注意：
1，当导入没有加上static时导入的是某一类
当加上static时导入的是某一类中的静态成员。
2，当类名重名时，需要指定具体的包名
当方法重名时，指定具备所属的对象或者类。
示例：
import java.util.*;
import static java.util.Arrays.*; //导入了Arrays类中的所有静态成员。
import static java.lang.System.*; //导入了System类中的所有静态成员。
class StaticImport
{
public static void main(String[] args){
out.println("haha");//省略书写System.
int[] arr = {3,1,5};
sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.
int index = binarySearch(arr,1);
out.println("Index="+index);
//当没有指定继承时，所以类默认继承了Object，
//因为toString方法object都具备，所以为了区分，必须写上具体调用者
System.out.println(Arrays.toString(arr));
}
}