------- android培训、java培训、期待与您交流！ ----------
15天-01-集合框架(TreeSet)
Set：无序，元素不可以重复。
|--HashSet：
|--TreeSet：可以对set集合中的数据排序。
底层数据是二叉树。
保证元素的唯一性的依据：compareTo方法return 0。
TreeSet排序的第一种方式：
让元素自身具备比较性。元素需要实现comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet排序的第二种方式：
当自然元素本身不具备比较性时，或者具备的比较性不是所需要的。这是就需要集合本身具备比较性，在集合初始化时，就有了比较性。
² 记住，再给一个类继承Comparable后时，重写compareTo方法时，当对象的主要条件相同时，一定要判断一下次要条件。
示例：
class Studentimplements Comparable<Student>{
private Stringname;
private int age;
public Student(String name,int age){
this.name = name;
this.age = age;
}
/*set和get方法省略*/
// @Override
// public int compareTo(Object o) {//未加入泛型前的方法操作
// if(o instanceofStudent){
// throw new RuntimeException("不是学生对象!");
// }
// Student s = (Student)o;
// if(this.age>s.age){
// return 1;
// }else if(this.age==s.age){
// return this.name.compareTo(s.name);
// }
// return -1;
// }
public int compareTo(Student o) {//当参数为null会报空指针异常
if(o instanceof Student){//加入泛型这句话可以不要
throw new RuntimeException("不是学生对象!");
}
Student s = (Student)o;//可以不要
if(this.age>s.age){
return 1;
}else if(this.age==s.age){
return this.name.compareTo(s.name);
}
return -1;
}
}
15天-04-集合框架(实现Comparator方式排序)
l 当元素本身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
示例1，继承Comparator不含泛型的比较：
class TreeSetDemo2 {
public static void main(String[] args){
TreeSet ts = new TreeSet(newMyCompare1());
//TreeSet<Student> ts1 = new TreeSet<Student>(newMyCompare2());
ts.add(new Student("lisi",01));
ts.add(new Student("wangwu",02));
}
}
class MyCompare1implementsComparator{//自定义比较器1
@Override
public int compare(Object o1, Object o2) {
Student stu1 =(Student)o1;
Student stu2 =(Student)o2;
int num =stu1.getName().compareTo(stu2.getName());
if(num==0){
if(stu1.getAge()>stu2.getAge()){
return 1;
}else if(stu1.getAge()==stu2.getAge()){
return 0;
}else{
return -1;
}
}
return num;
}
}
示例2，继承Comparator含泛型的比较：
class MyCompare2implementsComparator<Student>{//自定义比较器2
@Override
public int compare(Studentstu1, Student stu2) {
int num =stu1.getName().compareTo(stu2.getName());
if(num==0){
//Integer继承了Comparable接口，可以将int类型数据转换为Integer对象//进行比较。
return new Integer(stu1.getAge()).compareTo(newInteger(stu2.getAge()));
}
return num;
}
}
总结：类对象具有可比性，可以以两种方式实现：
1) 让用于比较的对象所属类继承Comparable接口。
示例：
public class TreeDemo{
publicstatic void main(String[] args){
TreeSet ts = new TreeSet();
…
}
}
class Student implements Comparable{//实现int compare
…
}
2) 定义比较器，让自定义比较器继承Comparator。
示例：
public class TreeDemo{
publicstatic void main(String[] args){
TreeSet ts = new TreeSet(newMyComparator());
…
}
}
class MyComparator implements Comparator{//实现 int compareTo(Object o1,Objecto2)方法。
…
}
15天-06-集合框架(泛型概述)
l 泛型：JDK1.5以后出现的新特性，用于解决安全问题，是一个安全机制。
l 泛型的好处：
1) 将运行时期出现的问题ClassCastException,转移到了编译时期，方便于程序员解决问题，让运行事情减少，安全。
2) 避免了强制转换的麻烦。
l 泛型格式：通过<>来定义要操作的引用数据类型。
在使用Java提供的对象时，什么时候写泛型呢？
通常在集合框架中和常见，只要见到<>就定义泛型。
其实，<>就是用来接受类型的。
当时用集合时，将集合中要存储的数据类型作为参数传递到<>中既可。
l 什么时候定义泛型呢?
当类中要操作的引用数据类型不确定的时候。
1) 早期定义Object类完成扩展。
class Utils{
privateObject q;
publicvoid setObject(Object q){
this.q = q;
}
public ObjectgetObject(){
return q;
}
}
public class Demo{
publicstatic void main(String[] args){
Utils u = new Utils();
u.setObject(new Student());
Student s = (Student)u.getObject();
}
}
2) 现在定义泛型来完成扩展。
class Utils<QQ>{
privateQQ q;
publicvoid setObject(QQ q){
this.q = q;
}
public QQgetObject(){
return q;
}
}
public class Demo{
publicstatic void main(String[] args){
Utils <Student>u = newUtils<Student>();
u.setObject(new Student());
Student s = u.getObject();
}
}
15天-09-集合框架(泛型方法)
l 泛型类定义的类型，在整个类中有效。如果被方法是用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
示例：
class Utils<QQ>{
publicvoid set(QQ q){
…
}
}
l 为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
class Demo{
public<T> void show(T t){//可以接受任意数据类型
…
}
public <Q>void print(Q q){
…
}
}
15天-10-集合框架(静态方法泛型)
l 静态方法不可以访问定义在类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
示例：
class Demo<T>{
publicvoid show(T t){//编译通过
//…
}
public <Q>void print(Q q){//编译通过
//…
}
public staticvoid method1(T t){//编译失败
//…
}
public static<W> void method2(W w){//编译通过
//…
}
}
15天-11-集合框架(泛型接口)
l 泛型定义在接口上
示例：
interface Inter<T>{
voidshow(T t);
}
class interImpl<T> implementsInter<T>{
publicvoid show(T t){
System.out.println(“show:”+t);
}
}
public class GenericDemo5{
publicstatic void main(String[] args){
InterImpl i = new InterImpl();
i.show(“hahah”);
i.show(123);
}
}
15天-12-集合框架(泛型限定)
l ？通配符，也可以理解为占位符。
泛型限定：
1) ? extends E：可以接受E类型或者E类型的子类型，上限。
2) ？super E：可以接收E类型或者E的父类型，下限。
示例：
class Person{
privateString name;
publicPerson(String name){
this.name = name;
}
public StringgetName(){
return name;
}
}
class Student extends Person implementsComparable<Person> {//<?superE>
publicStudent(String name){
super(name);
}
public intcompareTo(Person s){
return this,getName();
}
}
class Comp implementsComparator<Student>{
publicint compareTo(Stiudent st1,Student st2){
returnst1.getName().CompareTo(st2.getName());
}
}
TreeSet<Student> ts = newTreeSet<Student>(new Comp);
ts.add(new Srudent(“a01”));
ts.add(new Student(“a02”));
15天-13-集合框架(泛型限定2)
示例：
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
class Person{
private Stringname;
public Person(String name){
this.name = name;
}
public String getName(){
returnname;
}
public String toString(){
return"Person:"+name;
}
}
class Worker extends Person{
public Worker(String name){
super(name);
}
public String toString(){
return"Worker:"+this.getName();
}
}
class Student1extends Person{//注意，每个类都可以隐式地继承Object类，可以重写toString方法。
public Student1(String name){
super(name);
}
public String toString(){
return"Student:"+this.getName();
}
}
class Comp1 implements Comparator<Student1>{
public int compare(Student1 o1, Student1 o2) {
return o1.getName().compareToIgnoreCase(o2.getName());//只要重写了父类的toString方法，子类此时会调用子类的toString方法。
}
}
class Comp2 implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
return o2.getName().compareToIgnoreCase(o1.getName());
}
}
public class TreeSetComp01Demo {
public static void main(String[] args) {
// TreeSet<Student1> ts= new TreeSet<Student1>(new Comp1());
// ts.add(newStudent1("abc003"));
// ts.add(newStudent1("abc005"));
// ts.add(newStudent1("abc001"));
// ts.add(new Student1("abc002"));
//
// Iterator<Student1>it = ts.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
TreeSet<Worker> ts = newTreeSet<Worker>(new Comp2());//泛型 ? extends//Person的运用（Comp2限定了Person类，但是且可以运用到子类Worker中）
ts.add(new Worker("abc003"));
ts.add(new Worker("abc005"));
ts.add(new Worker("abc001"));
ts.add(new Worker("abc002"));
Iterator<Worker>it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}