java基础--15

1、TreeSet
 特点：可以对Set集合中的元素进行排序。
 底层数据结构式二叉树。
 保证元素唯一性的依据：compareTo方法return 0;

 TreeSet排序的第一种方式，让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法
  这种方式也成为元素的自然顺序或默认顺序
2、存储自定义对象
 Comparable该接口强制让学生具备比较性
 import java.util.*;

public class TreeSetDemo
{
 public static void main(String[] args)
 {
  TreeSet ts=new TreeSet();
  
  ts.add(new Student("lisi02",22));
  ts.add(new Student("lisi007",20));
  ts.add(new Student("lisi09",19));
  ts.add(new Student("lisi08",19));
  
  Iterator it=ts.iterator();
  while(it.hasNext())
  {
   Student s=(Student)it.next();
   System.out.println(s.getName()+"···"+s.getAge());
  }
 }
}

class Student implements Comparable
{
 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 compareTo(Object obj)
 {
  if(!(obj instanceof Student))
  {
   throw new RuntimeException("不是学生对象");
  }
  Student s=(Student)obj;
  if(this.age>s.age)
  {
   return 1;
  }
  if(this.age==s.age)
  {
   return this.name.compareTo(s.name);
  }
  return -1;
 }
}
3、二叉树
4、实现Comparator方式排序
 TreeSet的第二种排序方式
 当元素自身不具备计较性时，或者具备的比较性不是所需要的。
 这时需要让集合自身具备比较性，在集合一初始化时就有了比较方式
 定义了比较强，将比较强对象作为参数传递给TreeSet集合的构造函数

 当两种排序都存在时，以比较器为主
 
 定义一个类，实现Comparator接口，覆盖compare方法
 import java.util.*;

public class TreeSetDemo2
{
 public static void main(String[] args)
 {
  TreeSet ts = new TreeSet(new MyCompare());

  ts.add(new Student("lisi02",22));
  ts.add(new Student("lisi02",21));
  ts.add(new Student("lisi007",20));
  ts.add(new Student("lisi09",19));
  ts.add(new Student("lisi06",18));
  ts.add(new Student("lisi06",18));
  ts.add(new Student("lisi007",29));

  Iterator it = ts.iterator();
  while(it.hasNext())
  {
   Student stu = (Student)it.next();
   System.out.println(stu.getName()+"..."+stu.getAge());
  }
 }
}

class MyCompare implements Comparator
{
 public int compare(Object o1,Object o2)
 {
  Student s1=(Student)o1;
  Student s2=(Student)o2;
  int num=s1.getName().compareTo(s2.getName());
  if(num==0)
  {
   return (new Integer(s1.getAge())).compareTo(new Integer(s2.getAge()));
  }
  return num;
 }
}

class Student implements Comparable
{
 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 compareTo(Object obj)
 {
  if(!(obj instanceof Student))
  {
   throw new RuntimeException("不是学生对象");
  }
  Student s=(Student)obj;
  if(this.age>s.age)
  {
   return 1;
  }
  if(this.age==s.age)
  {
   return this.name.compareTo(s.name);
  }
  return -1;
 }
}
5、TreeSet练习
 /*
 练习：按照字符串长度排序。
 字符串本身具备比较性。但是它的比较方式不是所需要的。
 这时就只能使用比较器。
 */
 import java.util.*;

public class TreeSetTest
{
 public static void main(String[] args)
 {
  TreeSet ts=new TreeSet(new StrLenCompare());
  ts.add("abcd");
  ts.add("cc");
  ts.add("cba");
  ts.add("aaa");
  ts.add("z");
  ts.add("hahaha");
  
  Iterator it=ts.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
 }
}

class StrLenCompare implements Comparator
{
 public int compare(Object o1,Object o2)
 {
  String s1=(String)o1;
  String s2=(String)o2;
  
  int num=s1.length()-s2.length();
  if(num==0)
  {
   return s1.compareTo(s2);
  }
  return num;
 }
}
6、泛型概述
 jdk1.5版本后出现的新特性，用于解决安全问题，是一个类型安全机制。
 好处：
  将运行时期出现的问题ClassCaseException，转移到了编译时期，方便于程序员解决问题，让运行
  避免了强制转换的麻烦
7、泛型使用
 泛型格式：通过<>来定义要操作的引用数据类型
 在使用java提供的对象时，什么时候写泛型呢？
 通常在集合框架中很常见，只要见到<>就要定义泛型

 其实<>就是用来接收类型的。

 当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
8、泛型类
 class Utils<QQ>
{
 private QQ q;
 public void setObject(QQ q)
 {
  this.q=q;
 }
 
 public QQ getObject()
 {
  return q;
 }
}
 什么时候定义泛型类？
  当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。
9、泛型方法
 泛型类定义了泛型在整个类中有效，如果被方法是用，泛型类的对象明确要操作的类型后，所有要操作的类型就已经固定了。
 为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上
 class Demo
{
 public <T> void show(T t)
 {
  System.out.println("show:"+t);
 }
 
 public <T> void print(T t)
 {
  System.out.println("show:"+t);
 }
}
10、静态方法泛型
 静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
 public static <T> void method(T t)
{
 System.out.pritln("method"+t);
}
11、泛型定义在接口上
12、泛型限定
 ArrayList<?>
 ArrayList<? extends Person>

 ?通配符，也可以理解为占位符
 泛型的限定：
 ? extends E:可以接受E类型或者E的子类型。上限
 ? super E:可以接受E类型或者E的父类型。下限