------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
黑马程序员——17，集合，TreeSet，二叉树，泛型
/*
TreeSet:可以自动对容器内部元素排序
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class Jihe13
{
publicstatic void main(String[] args)
{
method();
}
public static void method()
{
soc("下面是method------");
TreeSet a= new TreeSet();
a.add("haha01");
a.add("iujha02");
a.add("Ufwqha03");
a.add("fha01");
a.add("haha02");
a.add("Fsfsda05");
a.add("hvdv05");
a.add("vadba03");
a.add("Nhna02");
a.add("tyra07");
a.add("25D");
Iterator it= a.iterator();
while(it.hasNext() )
{
soc(it.next());
}
/*
TreeSet的容器里面元素被打印出来都是逐位比对之后的结果，
在逐位比对时，常见的优先顺序：数字>大写字母>小写字母，
*/
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
下面是method------
25D
Fsfsda05
Nhna02
Ufwqha03
fha01
haha01
haha02
hvdv05
iujha02
tyra07
vadba03
*/——————分割线——————
/*
TreeSet存储自定义对象的例子：
TreeSet的元素一定要有比较性，而且TreeSet可以自动把具有比较性的元素排序
这也是底层调用的一种表现形式TreeSet里面不可以存放重复元素，重复元素将会会被删除
*/
import java.util.*;
//Collection接口的体系放在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(Object obj)
{
if( ! ( obj instanceof Student ) )
{
throw new RuntimeException("不是学生");
}
Student a=(Student)obj;
System.out.println("这是"+this.name+"和"+a.name+"比较");
if( this.age>a.age )
{
return 1;
}
if(this.age==a.age)
{
//主要条件相同要判断次要条件
return this.name.compareTo(a.name);
//String类也实现了Comparable接口，也有compareTo方法
//如果这里直接写return 0;的话就表示了对象是相同的
}
return -1;
/*
TreeSet排序的原理是二叉树排序：（底层数据结构二叉树结构）
所谓的二叉树，
例如：就是第一个元素进去，第二个元素进去判断若是比第一个元素大则放在右下边，(返回正数)
若是比第一个元素小则是放在左下边(返回负数)若是相同元素（返回0）则是被剔除掉。如此类推下去就会形成一个叉型树。
不过，如果元素个数过多的话，进来的元素会挑二叉树中的某一个元素做比较：
1，若是比那某个元素大则放在那某个元素的右下边，若是相等则是被剔除，
2，若是比那某个元素小泽放在左下边，
3，但是如果比那某个元素右下边的元素都大就跳到那某个元素的上一层继续比较，
就这样子，一步步确定自己在二叉树中的位置。
也可以利用这个原理，让compareTo方法返回值固定为正数或者负数，使得添加的元素按照添加顺序排序了（正序或者倒序）。
最后逐个输出的时候也是从最左边的开始按照二叉树顺序输出。
*/
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class Jihe14
{
publicstatic void main(String[] args)
{
TreeSet a= new TreeSet();
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));
a.add(new Student("haha07",76));
a.add(new Student("haha08",17));
a.add(new Student("haha09",17));
a.add(new Student("haha06",16));
//TreeSet与一个Comparable接口相关，该接口强制对实现它的每一个类的对象排序
/*Comparable接口之所以有这种强制排序能力，因为该接口有一个用来比较的compareTo方法。
所以这对于TreeSet存储自定义对象时候就可以利用实现Comparable接口，并且复
写compareTo方法
*/
Iterator it= a.iterator();
while(it.hasNext() )
{
Student stu=(Student)it.next() ;
soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
这是haha01和haha01比较
这是haha02和haha01比较
这是haha03和haha01比较
这是haha03和haha02比较
这是haha04和haha02比较
这是haha04和haha01比较
这是haha05和haha02比较
这是haha05和haha01比较
这是haha06和haha02比较
这是haha06和haha01比较
这是haha06和haha04比较
这是haha07和haha02比较
这是haha07和haha03比较
这是haha08和haha02比较
这是haha08和haha01比较
这是haha08和haha04比较
这是haha08和haha06比较
这是haha09和haha02比较
这是haha09和haha01比较
这是haha09和haha06比较
这是haha09和haha08比较
这是haha06和haha06比较
名字---haha05---年龄---1
名字---haha01---年龄---12
名字---haha04---年龄---15
名字---haha06---年龄---16
名字---haha08---年龄---17
名字---haha09---年龄---17
名字---haha02---年龄---19
名字---haha03---年龄---26
名字---haha07---年龄---76
*/——————分割线——————
/*
但是如果元素自己没有或者自己本身具备的比较性不适合：
例如：
学生个体已经具备年龄的比较性，但是排序的时候需要按照名字排序，
这个时候就需要定义一个类实现Comparator接口，覆盖compare方法，该类一个比较器类，
该类的实例就是一个比较器。
把比较器放入TreeSet构造函数中，就会优先用比较器进行元素排列（不管元素本身是否具备比较性）
*/
import java.util.*;
//Collection接口的体系放在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(Object obj)
{
if( ! ( obj instanceof Student ) )
{
throw new RuntimeException("不是学生");
}
Student a=(Student)obj;
System.out.println("这是"+this.name+"和"+a.name+"比较");
if( this.age>a.age )
{
return 1;
}
if(this.age==a.age)
{
//主要条件相同要判断次要条件
return this.name.compareTo(a.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class Jihe15
{
publicstatic void main(String[] args)
{
TreeSet a= new TreeSet(new Bijiao() );//把比较器放进TreeSet构造函数中
a.add(new Student("vdsfb1",12));
a.add(new Student("惹我02",19));
a.add(new Student("吧03",26));
a.add(new Student("haha04",15));
a.add(new Student("qwqwe5",1));
a.add(new Student("ahs6",16));
a.add(new Student("ibbf07",76));
a.add(new Student("cuhn8",17));
a.add(new Student("kvjakn09",17));
a.add(new Student("kvjakn09",16));
Iterator it= a.iterator();
while(it.hasNext() )
{
Student stu=(Student)it.next() ;
soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
class Bijiao implements Comparator
{
public int compare(Object a,Object b)
{
Student na=(Student)a;
Student nb=(Student)b;
int num=na.getName().compareTo(nb.getName());
//这里的compareTo方法是字符串本身就具备的方法，按照字典排列字符串
if(num==0)
{
return na.compareTo(nb); //按照元素本身具备的比较性进行比较
}
return num;
}
}
/*
以上代码编译运行结果：
这是vdsfb1和vdsfb1比较
这是kvjakn09和kvjakn09比较
名字---ahs6---年龄---16
名字---cuhn8---年龄---17
名字---haha04---年龄---15
名字---ibbf07---年龄---76
名字---kvjakn09---年龄---16
名字---kvjakn09---年龄---17
名字---qwqwe5---年龄---1
名字---vdsfb1---年龄---12
名字---吧03---年龄---26
名字---惹我02---年龄---19
*/——————分割线——————
/*
比较字符串长度
字符串本身具备了比较性，但是不合适
就用比较器了
*/
import java.util.*;
class Jihe16
{
publicstatic void main(String[] args)
{
TreeSet a=new TreeSet(new Cdbijiao());
a.add("cyufihjv");
a.add("dzsrzx");
a.add("ihu");
a.add("erasdf");
a.add("vyivlbjkbui");
a.add("tydfy");
a.add("pjokn");
a.add("cryxtsbrnr");
Iterator it=a.iterator();
while(it.hasNext())
{
soc(it.next());
}
System.out.println("HelloWorld!");
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
class Cdbijiao implements Comparator
{
public int compare(Object a,Object b)
{
String na=(String)a;
String nb=(String)b;
if(na.length()==nb.length())
return na.compareTo(nb);
if(na.length()>nb.length())
{
return 1;
}
return -1;
}
}
/*
以上代码编译运行结果：
ihu
pjokn
tydfy
dzsrzx
erasdf
cyufihjv
cryxtsbrnr
vyivlbjkbui
Hello World!
*/——————分割线——————
/*
关于泛型的介绍：
*/
import java.util.*;
//Collection接口的体系放在Java.util包里面
class 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;
}
}
class Jihe17
{
publicstatic void main(String[] args)
{
ArrayList<Student> a= new ArrayList<Student>();
/*
这里的<>就是一种泛型的应用，一种保护机制。
这里的例子表示的就是ArrayList类型的容器中只能够装Student类型的元素
这样使用泛型这种保护机制后之前编译会出现的两行注意提示也没有了。
但是，如果此时往容器a里面添加的不是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));
a.add(new Student("haha07",76));
a.add(new Student("haha08",17));
a.add(new Student("haha09",17));
a.add(new Student("haha06",16));
// a.add("haha06");//这句话编译会出问题
Iterator<Student> it= a.iterator();
/*
表示返回迭代器里面的也是Student类型的元素，
那么到时候迭代器调用next方法时返回的就不是Object类型的元素，
而是Student类型的元素了。
*/
while(it.hasNext() )
{
//Student stu=(Student)it.next() ;
Student stu=it.next() ;
//这里就省去了类型转换的麻烦
soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
}
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
名字---haha01---年龄---12
名字---haha02---年龄---19
名字---haha03---年龄---26
名字---haha04---年龄---15
名字---haha05---年龄---1
名字---haha06---年龄---16
名字---haha07---年龄---76
名字---haha08---年龄---17
名字---haha09---年龄---17
名字---haha06---年龄---16
*/——————分割线——————
/*
关于泛型的一些知识点以及更多的关系应用：
加了<>实际上就是限制了只能够接收<>内部所表示的类型的参数
*/
import java.util.*;
//Collection接口的体系放在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(Object obj)
{
if( ! ( obj instanceof Student ) )
{
throw new RuntimeException("不是学生");
}
Student a=(Student)obj;
System.out.println("这是"+this.name+"和"+a.name+"比较");
if( this.age>a.age )
{
return 1;
}
if(this.age==a.age)
{
//主要条件相同要判断次要条件
return this.name.compareTo(a.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class Jihe18
{
publicstatic void main(String[] args)
{
TreeSet<Student> a= new TreeSet<Student>(new Bijiao());//把比较器放进TreeSet构造函数中
a.add(new Student("vdsfb1",12));
a.add(new Student("惹我02",19));
a.add(new Student("吧03",26));
a.add(new Student("haha04",15));
a.add(new Student("qwqwe5",1));
a.add(new Student("ahs6",16));
a.add(new Student("ibbf07",76));
a.add(new Student("cuhn8",17));
a.add(new Student("kvjakn09",17));
a.add(new Student("kvjakn09",16));
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<Student>
//Comparator<Student>强制指定比较器只可以比较Student类型的元素
//实际上也是Bijiao类实现了只能够接收Student类型参数的Comparator接口
{
public int compare(Student a,Student b)
{
//Student na=(Student)a;
//Student nb=(Student)b;
//以上两句话就可以省略了
int num=a.getName().compareTo(b.getName());
//这里的compareTo方法是字符串本身就具备的方法，按照字典排列字符串
if(num==0)
{
// return a.compareTo(b); //按照元素本身具备的比较性进行比较
return new Integer(a.getAge()).compareTo(new Integer(b.getAge()));
//Integer类里面也定义了自己的compareTo方法，比较的是数字的大小
}
return num;
}
}
/*
以上代码编译运行结果：
名字---ahs6---年龄---16
名字---cuhn8---年龄---17
名字---haha04---年龄---15
名字---ibbf07---年龄---76
名字---kvjakn09---年龄---16
名字---kvjakn09---年龄---17
名字---qwqwe5---年龄---1
名字---vdsfb1---年龄---12
名字---吧03---年龄---26
名字---惹我02---年龄---19
*/——————分割线——————
/*
泛型在自定义类中的使用：
*/
class Person<TTT>//这种类也被称之为泛型类，带着泛型的类
//表示接收由调用者定义的类型的参数
{
private TTT a;
public void seta(TTT a )
{
this.a=a;
}
public TTT geta()
{
return a;
}
}
class Teacher
{
private String name="张三";
private int age=25;
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
}
class Student
{
private String name="李四";
private int age=13;
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
}
class Jihe19
{
public static void main(String[] args) //主函数
{
method();
}
public static void method()
{
soc("下面是method----------------");
Person<Teacher> a=new Person<Teacher>();
//限制了接收的只能是Teacher类型的参数
a.seta(new Teacher());
soc(a.geta().getName());
Person<Student> b=new Person<Student>();
//对于Person类的b来说，接收的只能够是Student类的参数
//与上面的没有冲突
b.seta(new Student());
soc(b.geta().getName());
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
下面是method----------------
张三
李四
*/——————分割线——————
/*
泛型可以用在类上，也可以用在方法上
泛型方法的应用
*/
class Person //注意此时的类名后面没有加泛型！！！
{
public <E> void fanfa1(E e)//这个就是泛型方法
//这里的<>内的E只在这个方法内有效
{
System.out.println("这是fanfa1的e---"+e);
}
public <E> void fanfa2(E e)//这个就是泛型方法
//这里的<>内的E和fanfa1方法的E不是同一个E！！！
{
System.out.println("这是fanfa2的e---"+e);
}
}
class Student<E> //注意这里加了<E>
{
public void fanfa(E e) //注意这里的void前面没有加<E>
//fanfa方法中的E和 Student<E>的E是一样的！！！
{
System.out.println("这是fanfa的e---"+e);
}
public <E>void fanfa1(E e)//这个就是泛型方法，注意这里void前面加了<E>
//fanfa1方法中的E和 Student<E>的E是不相同的！fanfa1方法中的E只在fanfa1内部有效
{
System.out.println("这是fanfa1的e---"+e);
}
public <Q> void fanfa2(Q q)//这个就是泛型方法
//这里的Q与Studnet<E>中的E是不一样的
{
System.out.println("这是fanfa2的q---"+q);
}
/*
public static void fanfa3(E e)
这里的E与Studnet<E>中的E是一样的,由于这里是静态方法，
在对象建立之前就存在的，但是调用该方法需要建立对象时E对应的明确类型，
所以这种写法编译出问题。为了解决这个问题，可以把泛型就定义在方法上
*/
public static <R>void fanfa3(R r)
//这种写法才是正确的，而且泛型要放在返回值类型前！
//public <R> static void fanfa3(R r)//这种写法是错误的
{
System.out.println("这是fanfa3的r---"+r);
}
}
class Jihe20
{
public static void main(String[] args)
{
method();
method2();
}
public static void method()
{
soc("下面是menthod------");
Person per=new Person();
per.fanfa1(new Integer(25));
per.fanfa1(62);
per.fanfa1("hushu");
per.fanfa2(new Integer(25));
per.fanfa2(62);
per.fanfa2("hushu");
soc("HelloWorld!");
}
public static void method2()
{
soc("下面是menthod2------");
Student<String> stu=new Student<String>();
stu.fanfa("hfabf");//fanfa方法只能够接收String类型的参数
//stu.fanfa(45);//这句话编译出问题
//stu.fanfa(new Integer(25));//这句话编译出问题
stu.fanfa1("hfabf");
stu.fanfa1(45);//这句话也是可以编译运行成功的
stu.fanfa1(new Integer(25));
stu.fanfa2(78);//这句话也是可以编译运行成功的
stu.fanfa2("rtct");
stu.fanfa3("hfabf");//这句话也是可以编译运行成功的
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
/*
以上代码编译运行结果：
下面是menthod------
这是fanfa1的e---25
这是fanfa1的e---62
这是fanfa1的e---hushu
这是fanfa2的e---25
这是fanfa2的e---62
这是fanfa2的e---hushu
Hello World!
下面是menthod2------
这是fanfa的e---hfabf
这是fanfa1的e---hfabf
这是fanfa1的e---45
这是fanfa1的e---25
这是fanfa2的q---78
这是fanfa2的q---rtct
这是fanfa3的r---hfabf
*/版权声明：本文为博主原创文章，未经博主允许不得转载。
原文地址：http://blog.csdn.net/dangaodeaiyi/article/details/47280787
