标签：黑马程序员
------<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!
*/版权声明：本文为博主原创文章，未经博主允许不得转载。
标签：黑马程序员
原文地址：http://blog.csdn.net/dangaodeaiyi/article/details/47314233
