黑马程序员——18，泛型应用，Map

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

黑马程序员——18，泛型应用，Map

/*

泛型在接口上的应用：

*/

interface   Inter<Q> //其实就是限制了可以操作的类型而已
{
public   void    method(Q q );

}
class   Student<Q>  implements   Inter<Q>
{
public   void  method(Q   q)
{
System.out.println(q);
}
}

class  Fanxin
{
public  static   void   main(String[] args)
{
Student<String>   a=new Student<String>();
//这里限制操作类型String，那么Q对应的也就是String
a.method("这是学生a");
//a.method(16);//这句话编译不通过
System.out.println("HelloWorld!");
}
}

——————分割线——————

/*

泛型限定的介绍：

*/

import   java.util.*;
//Collection接口的体系放在Java.util包里面
class   Person
{
private   String   name  ;
private    int   age;
Person(String  name,int age)
{
this.name=name;
this.age=age;

}

public   String   getName()
{
return  name;
}
public   int   getAge()
{
return  age;
}
}
class  Student    extends   Person
{
Student(String  name,int age)
{
super(name,age);
}

//super.getName();
//super.getAge();
}

class   Fanxin2
{
public  static void  main(String[] args)
{
ArrayList< Student>  a=  new   ArrayList< Student>();

a.add(new   Student("学生haha01",12));
a.add(new  Student("学生haha02",19));
a.add(new   Student("学生haha03",26));
a.add(new   Student("学生haha04",15));
a.add(new  Student("学生haha05",1));
a.add(new   Student("学生haha06",16));

socx(a);
ArrayList< Person>   b=  new  ArrayList<Person>();
/*
ArrayList<?  extends Person>   b=  new  ArrayList<?  extends  Person>();
//在这里的这句话编译会出问题
*/

b.add(new   Person("人haha07",76));
b.add(new  Person("人haha08",17));
b.add(new   Person("人haha09",17));
b.add(new   Person("人haha06",16));
socx(b);
}

public    static void  socx(  ArrayList<?  extends Person>   a  )
{
/*
<? extends  Person >  表示接收的是Person类或者Person类的子类的对象（上限）
<? super Student > 表示接收的是Student类或者Student类的父类的对象（下限）
?  是通配符
*/

Iterator<?  extends Person >   it=  a.iterator();

while( it.hasNext() )
{

System.out.println(it.next().getName());
}
}

}
/*
以上代码编译运行结果是：
学生haha01
学生haha02
学生haha03
学生haha04
学生haha05
学生haha06
人haha07
人haha08
人haha09
人haha06

*/

————————分割线——————

/*

泛型限定在Comparable接口和Comparator接口的应用

*/

import java.util.*;
//Collection接口的体系放在Java.util包里面
class   Person
{
private  String  name  ;
private    int   age;
Person(String name,int  age)
{
this.name=name;
this.age=age;
}
public   String   getName()
{
return  name;
}
public   int   getAge()
{
return  age;
}

}
class  Student  extends  Person   implements   Comparable<Person>//<?  super E>
/*
Comparable当初定义的时候就是Comparable<?  super  E>  ，和TreeSet<E>相对应的
*/
{
Student(String  name,int  age)
{
super(name,age);
}

public    int   compareTo( Person   p)
{

return  -1;
}
public   String  getName()
{
return    super.getName();
}
public   int   getAge()
{
return  super.getAge();
}
}
class  Fanxin4
{
publicstatic void main(String[] args)
{
method(); //按照元素本身具备的比较性比较
method2(); //按照容器的比较器比较
}
public   static   void method()
{
System.out.println("以下是method-------");
TreeSet<Student>   a=  new  TreeSet<Student>();
//TreeSet<E>
gb(a);
}
public   static   void method2()
{
System.out.println("以下是method2-------");
TreeSet<Student>   a=  new  TreeSet<Student>(new  Bijiao());
//TreeSet<E>
gb(a);

}
public   static   void  gb(TreeSet<Student>  a)
{
a.add(new  Student("vdsfb1",12));
a.add(new  Student("惹我02",19));
a.add(new   Student("吧03",26));
a.add(new   Student("haha04",15));
Iterator<Student>    it= a.iterator();
while(it.hasNext())
{
Student  stu     =        it.next();
soc(stu.getName()+"---"+stu.getAge());
}
}
public  static  void  soc(Object  obj)
{
System.out.println(obj);
}
}
class   Bijiao   implements   Comparator<Person> //<?  super E>

{
public  int   compare(Person  a,Person b)
{

int  num=a.getName().compareTo(b.getName());
if(num==0)
{
return  1;
}
return  num;
}
}
/*
以上代码编译运行结果是：
以下是method-------
haha04---15
吧03---26
惹我02---19
vdsfb1---12
以下是method2-------
haha04---15
vdsfb1---12
吧03---26
惹我02---19
*/

——————分割线——————

/*

Collection集合是单列集合，而对应的Map就是双列集合

Map集合的介绍：

Map<k,v>

这种容器就是用来一对对的存储键和值，

一个键最多映射一个值，但是一个值可以被多个键映射到。

Map有几个常见的子类

HashTable----底层数据是哈希表数据结构，不可以存入null键null值，线程同步

HashMap------底层数据是哈希表数据结构可以存入null键null值，线程不同步，

功能与 HasTable一样。

TreeMap-----底层数据是二叉树数据结构，线程不同步，可以用来给Map集合中的键排序

*/

import  java.util.*;
class  Fanxin5

{
public   static  void   main(String[] args)
{

Map<String,String>   m= jb();
method(m);
Map<String,String>   m2= jb();
method2(m2);
Map<String,String>   m3= jb();
method3(m3);
Map<String,String>   m4= jb();
method4(m4);

}
public  static  Map<String,String>    jb()
{
Map<String,String>   m= new HashMap<String,String>();
m.put("001","aaa");
m.put("002","bbb");
m.put("003","ccc");
m.put("004","ddd");
m.put("005","eee");
m.put("006","fff");
soc("原本的m---"+m);
return  m;

}
public   static  void  method(Map<String,String> m)
{
//Map集合的基本功能演示
soc("下面是method-----------------");
soc("m.size()---"+m.size());
soc("m.get(\"004\")---"+m.get("004"));//通过键来获取值
soc("m.get(\"789\")---"+m.get("789"));//打印的是null
soc("m.containsKey(\"003\")---"+m.containsKey("003"));
soc("m.remove(\"003\")---"+m.remove("003"));//打印的是被删除的值
soc("m.remove(\"456\")---"+m.remove("456"));//打印的是null
soc("m---"+m);
soc("m.put(null,\"ggg\")---"+m.put(null,"ggg"));
soc("m.get(null)---"+m.get(null));
soc("m---"+m);
}
public   static void  method2(Map<String,String> m)
{
soc("下面是method2-----------------");
soc("做了Collection<String> c=m.values();操作");
Collection<String>  c=m.values();//获取容器m中的所有的值
soc("m---"+m);
soc("c---"+c);
}
public  static  void method3(Map<String,String> m)
{
soc("下面是method3-----------------");
soc("m.put(\"007\",\"dade\")---"+m.put("007","dade"));
soc("m.put(\"007\",\"xiaode\")---"+m.put("007","xiaode"));
/*
添加了两个有着相同键的值,后添加的值会覆盖前一个值，并且返回被覆盖的值
*/

soc("m---"+m);
}
public   static void  method4(Map<String,String> m)
{
soc("下面是method4-----------------");
soc("m.put(\"yubyua\",\"qdwc\")---"+m.put("yubyua","qdwc"));
soc("m.put(\"pogf\",\"yav\")---"+m.put("pogf","yav"));
soc("m.put(\"savsy\",\"qbhyt\")---"+m.put("savsy","qbhyt"));
soc("注意m的顺序---"+m);

}
public  static  void   soc(Object  obj)
{
System.out.println(obj);
}
}

/*
以上代码编译运行结果：
原本的m---{001=aaa,002=bbb, 003=ccc, 004=ddd, 005=eee, 006=fff}
下面是method-----------------
m.size()---6
m.get("004")---ddd
m.get("789")---null
m.containsKey("003")---true
m.remove("003")---ccc
m.remove("456")---null
m---{001=aaa, 002=bbb, 004=ddd, 005=eee,006=fff}
m.put(null,"ggg")---null
m.get(null)---ggg
m---{null=ggg, 001=aaa, 002=bbb, 004=ddd,005=eee, 006=fff}
原本的m---{001=aaa,002=bbb, 003=ccc, 004=ddd, 005=eee, 006=fff}
下面是method2-----------------
做了Collection<String>  c=m.values();操作
m---{001=aaa, 002=bbb, 003=ccc, 004=ddd,005=eee, 006=fff}
c---[aaa, bbb, ccc, ddd, eee, fff]
原本的m---{001=aaa,002=bbb, 003=ccc, 004=ddd, 005=eee, 006=fff}
下面是method3-----------------
m.put("007","dade")---null
m.put("007","xiaode")---dade
m---{001=aaa, 002=bbb, 003=ccc, 004=ddd,005=eee, 006=fff, 007=xiaode}
原本的m---{001=aaa,002=bbb, 003=ccc, 004=ddd, 005=eee, 006=fff}
下面是method4-----------------
m.put("yubyua","qdwc")---null
m.put("pogf","yav")---null
m.put("savsy","qbhyt")---null
注意m的顺序---{001=aaa, 002=bbb, 003=ccc, 004=ddd, 005=eee, 006=fff,yubyua=qdwc, pogf=yav, savsy=qbhyt}

*/

——————分割线——————

/*

Map集合取出方式：

*/

import  java.util.*;

class  Mapjs
{
public   static  void   main(String[] args)
{
Map<String,String>   m= new HashMap<String,String>();
m.put("006","aaa");
m.put("002","bbb");
m.put("004","ccc");
m.put("003","ddd");
m.put("005","eee");
m.put("001","fff");
//HashMap底层数据结构是哈希表，还是自动按照哈希表顺序排列
soc("原本的m---"+m);
Set<String>  s=m.keySet();
//把所有键放在Set集合的容器的里面
Iterator<String>   it= s.iterator();
//有了Set之后就可以建立迭代器
while(it.hasNext())
{
String str=it.next();
String  zhi=m.get(str);
soc("键---"+str+"；   值---"+zhi);
}
System.out.println("HelloWorld!");
}
public  static  void   soc(Object  obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
原本的m---{001=fff,002=bbb, 003=ddd, 004=ccc, 005=eee, 006=aaa}
键---001；   值---fff
键---002；   值---bbb
键---003；   值---ddd
键---004；   值---ccc
键---005；   值---eee
键---006；   值---aaa
Hello World!

*/

——————分割线————

/*

Map集合第二种取出方式

使用entrySet方法

*/

import java.util.*;
class  Mapjs2
{
public   static  void  main(String[]   args)
{

Map<String,String>  m=new HashMap<String,String>();
m.put("jk06","aubv");
m.put("jk76","ewwb");
m.put("jk17","wef");
m.put("jk4","uykuy");
Set<Map.Entry<String,String>>   s=  m.entrySet();
//把映射关系取出来
/*
Map.Entry<String,String>可以看做是一种类型（注意仅仅是看做），
是Map集合中映射关系类型，这是一种关系类型。
实际上，Map.Entry是Map接口内部的一个public修饰的静态子接口
*/
Iterator<Map.Entry<String,String>>   it=s.iterator();
while(it.hasNext() )
{
Map.Entry<String,String>     ys =it.next();
String    yskey =ys.getKey();
String    ysvalue  =ys.getValue();
soc("key---"+yskey+";    values---"+ysvalue);

}
}
public  static  void   soc(Object  obj)
{
System.out.println(obj);
}
}

/*
以上代码编译运行结果：
key---jk76;    values---ewwb
key---jk4;    values---uykuy
key---jk06;    values---aubv
key---jk17;    values---wef

Map.Entry是Map接口内部的一个public修饰的静态子接口
这是大致结构：
interface Map
{
public   sataic  interface   Entry
{
public abstract   Object   getKey();
public  abstract  Object   getValue();

}

}
class HashMap  implements  Map
{
class   Has   implements Map.Entry
{
public Object  getKey(){}
public Object  getValue(){}

}

}
*/

——————分割线————

/*

Map相关的练习

描述学生（名字，年龄）

学生名字和年龄一样就是同一个人

定义Map集合，把学生作为键，学生地址作为值。

最后获取Map集合

*/

import  java.util.*;
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;
}
public   int  hashCode()
{
return  this.name.hashCode()+this.age;

}
public   boolean   equals(Object  obj)
{
if(!(obj   instanceof   Student))
{
throw   new    RuntimeException("不是学生类");
}
Student  stu=(Student)obj;
boolean  bo= this.name.equals(stu.name)&& newInteger(this.age).equals(new Integer(stu.age));
//进行名字比较和年龄比较，注意这里用了Integer类型
return  bo;
}
public   int   compareTo(Student  a)
{
int   db=  new   Integer(this.age).compareTo(new  Integer(a.age));
if(db==0)
{

return  this.name.compareTo(a.name);
}
return db;
}
}

class  Mapjs3
{
public   static  void  main(String[] args)
{
method();
method2();
}
public  static void   method()
{
soc("这是method---");
Map<Student,String>  m=  new HashMap<Student,String>();
m.put(new Student("aaa",26),"asd05");
m.put(new Student("vfev",13),"asd14");
m.put(new Student("nytn",20),"asd43");
m.put(new Student("uitu",18),"asd77");
m.put(new Student("wr",17),"asd08");
m.put(new Student("vbb",17),"asd78");
m.put(new Student("vbb",17),"asd19");
//以下都是相同的针对Map集合的取出操作
Set<Map.Entry<Student,String>>  s=m.entrySet();
Iterator<Map.Entry<Student,String>>   it=s.iterator();
while(it.hasNext())
{
Map.Entry<Student,String>  me   =it.next();
Student     yskey  =  me.getKey();
String    ysvalue  =   me.getValue();
soc(yskey.getName()+"---"+yskey.getAge()+"---"+ysvalue);
}
}
public   static    void   method2()//写一个方法打印学生信息
{
soc("这是method2---");
Map<Student,String>  m=  new TreeMap<Student,String>();
m.put(new Student("aaa",26),"asd05");
m.put(new  Student("vfev",13),"asd14");
m.put(new Student("nytn",20),"asd43");
m.put(new Student("uitu",18),"asd77");
m.put(new Student("wr",17),"asd08");
m.put(new Student("vbb",17),"asd78");
m.put(new Student("vbb",17),"asd19");
Set<Map.Entry<Student,String>>  s=m.entrySet();
Iterator<Map.Entry<Student,String>>   it=s.iterator();
while(it.hasNext())
{
Map.Entry<Student,String>  me   =it.next();
Student     yskey  =  me.getKey();
String    ysvalue   =   me.getValue();
soc(yskey.getName()+"---"+yskey.getAge()+"---"+ysvalue);
}
}
public  static void   soc(Object  obj)
{
System.out.println( obj);
}
}
/*
以上代码编译运行结果：
这是method---
uitu---18---asd77
vbb---17---asd19
vfev---13---asd14
aaa---26---asd05
nytn---20---asd43
wr---17---asd08
这是method2---
vfev---13---asd14
vbb---17---asd19
wr---17---asd08
uitu---18---asd77
nytn---20---asd43
aaa---26---asd05
这两者的打印顺序不一样
*/

————————分割线——————

</pre><pre name="code" class="java">/*
TreeMap的应用例子：
有一串字符串获取该字符串中每一个字母出现的次数，
打印结果是这种形式的：a(6)b(8)...

每一个字母都对应着一个数字，这样就形成映射关系了。
*/
import  java.util.*;
class   Mapjs6
{
public  static void  main(String[] args)
{
String   a="sss#$dfgggyi++vf--b";
TreeMap<Character,Integer>    m=method(a);
method2(m);
}
public  static TreeMap<Character,Integer> method(String  str)
{
char[]   ch=str.toCharArray();//把字符串拆成字符数组
TreeMap<Character,Integer>    m=new   TreeMap<Character,Integer>();
for(int x=0;x<ch.length;x++)
{
if(!(ch[x]>='a' && ch[x]<='z'|| ch[x]>='A' && ch[x]<='Z'))
continue; //如果不是字母字符就结束本次循环，进入下一次循环

Integer  i= m.get(ch[x]);
if(i==null)
{
m.put(ch[x],1);
}
else
{
i=i+1;
//如果没有下面m.put(ch[x],i);这句话那么改变的仅仅是i而ch[x]对应的值没有改变！
m.put(ch[x],i);
/*
注意：这句话很重要！不能省略！一定要重新放！
新的元素会把就的元素剔除。
*/
}

}
soc(m);
System.out.println();
return   m;

}
public   static void  method2(TreeMap<Character,Integer> m   )
{
Set<Map.Entry<Character,Integer>>   s=m.entrySet();
Iterator<Map.Entry<Character,Integer>>  it=s.iterator();
//把映射关系取出来进行操作
while ( it.hasNext())
{
Map.Entry<Character,Integer>  a=it.next();
Character   akey  =    a.getKey();
Integer   avalue = a.getValue();
soc(akey+"("+ avalue+")");

}
}

public  static void  soc(Object obj)
{
System.out.print(obj);
}
}
/*
以上编译运行结果：
{b=1, d=1, f=2, g=3, i=1, s=3, v=1, y=1}
b(1)d(1)f(2)g(3)i(1)s(3)v(1)y(1)
*/

——————分割线————

/*

Map的扩展应用：

简单的概括就是大容器里面装着小容器

*/

import java.util.*;
class  Mapjs7
{
public   static  void  main(String[] args)
{
HashMap<String,String>   jichu= new HashMap<String,String>();
//定义一个基础班容器
jichu.put("2","sdf");//前面是学生学号后面是姓名
jichu.put("21","ert");
jichu.put("13","io");
jichu.put("19","aheds");
HashMap<String,String>  tigao=new HashMap<String,String>();
//定义一个提高班容器
tigao.put("76","edf");
tigao.put("43","ycs");
tigao.put("74","cbhg");
tigao.put("20","aggs");
HashMap<String,HashMap<String,String>>   xuexiao=new  HashMap<String,HashMap<String,String>>();
//定义一个学校容器，装的是基础班和提高班
xuexiao.put("基础班",jichu);
xuexiao.put("提高班",tigao);

//打印所有学生的学号和名字

Set<Map.Entry<String,HashMap<String,String>>>  s= xuexiao.entrySet();
//把映射关系放在Set集合中
Iterator<Map.Entry<String,HashMap<String,String>>>  it=s.iterator();
//建立迭代器对映射关系进行操作
while( it.hasNext()   )
{
Map.Entry<String,HashMap<String,String>>   m =it.next();
String   bjkey  =m.getKey();
HashMap<String,String>   bjvalue  =m.getValue();
soc("这是"+bjkey+"的学生");
method(bjvalue);

}

}
public   static void  method(HashMap<String,String>  jiaoshi )
{
Set<Map.Entry<String,String>>     s  =jiaoshi.entrySet();
Iterator<Map.Entry<String,String>>    it=  s.iterator();
while(it.hasNext())
{
Map.Entry<String,String>    m=it.next();
String   s1  =     m.getKey();
String   s2  =   m.getValue();
soc(s1+"---"+s2);
}

}
public  static  void  soc(Object  obj)
{
System.out.println(obj);
}
}
/*
以上代码运行结果是：
这是提高班的学生
74---cbhg
20---aggs
76---edf
43---ycs
这是基础班的学生
2---sdf
13---io
19---aheds
21---ert

*/

——————分割线————————

/*

刚才的例子中还可以继续变形：

学生作为对象存在，里面含有名字和年龄

(和视频老师不同，本文喜欢从小的容器往大的容器写去，纯属思维差异)

*/

import  java.util.*;
class  Student
{
private   String  name;
private  String  age;
Student(String  name,String   age)
//注意：这里的age类型是String
{
this.name=name;
this.age=age;
}
public  String getName()
{
return name;
}
public   String getAge()
{
return age;
}

}
class  Mapjs8
{
public  static void  main(String[] args)
{
List<Student>   jichu=new  ArrayList<Student>();
//建立一个基础班的列表容器
jichu.add(new Student("sdf01","25"));
jichu.add(new Student("sdf08","16"));
jichu.add(new Student("sdf03","15"));
jichu.add(new Student("sdf07","22"));

List<Student>  tigao=new  ArrayList<Student>();
//建立一个提高班的列表容器
tigao.add(new Student("rfv23","15"));
tigao.add(new Student("rfv45","10"));
tigao.add(new Student("rfv02","23"));
tigao.add(new Student("rfv01","24"));
HashMap<String,List<Student>>  xuexiao=new HashMap<String,List<Student>>();
//建立一个学校的HashMap集合
xuexiao.put("基础班",jichu);
xuexiao.put("提高班",tigao);
//再把所有学校的学生信息打印出来

Set<Map.Entry<String,List<Student>>>   s=xuexiao.entrySet();
Iterator<Map.Entry<String,List<Student>>>   it=   s.iterator();
while( it.hasNext()  )
{
Map.Entry<String,List<Student>>    m=it.next();
String  xkey =m.getKey();
soc("这是"+xkey+"----");
List<Student>     xvalue =m.getValue();
method(xvalue);

}

System.out.println("HelloWorld!");
}
public  static  void  method(List<Student>   s)
{
Iterator<Student>   it   =s.iterator();
while(it.hasNext())
{
Student  stu =it.next();
soc(stu.getName()+"---"+stu.getAge());
}
}
public  static void  soc(Object  obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
这是提高班----
rfv23---15
rfv45---10
rfv02---23
rfv01---24
这是基础班----
sdf01---25
sdf08---16
sdf03---15
sdf07---22
Hello World!

*/