TreeSet

TreeSet集合:可以对Set集合中的元素进行排序。是不同步i的。

                       判断元素唯一性的方式:根据比较方法的返回值来判断。是0(零)就存入集合,不是0就不存。因为Set集合是不能有重复的元素,无序。

                        既然是无序的集合。我们有时为了到达需求,需要使它变得有序,那怎么办呢?

  TreeSet对元素排序的方式一:
                       让元素自身具备比较排序功能,具备比较排序功能的元素只需要实现Comparable 接口。覆盖接口中CompareTo方法。

public class TreeSetDemo {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        demo1();
    }
 
 
 
    /**
     * 
     */
    public static void demo1() {
        TreeSet ts = new TreeSet();
        
        ts.add("abc");
        ts.add("zaa");
        ts.add("aa");
        ts.add("nba");
        ts.add("cba");
        
        Iterator it = ts.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
 
}
              控制台输出集合。无序。但是这看似无序的集合其中却是有序的,字符串按照字典顺序排序输出。

查看API发现TreeSet集合是按照元素的自然顺序进行排序。

使用自定义对象存入集合试一下。

先初建一个bean。

package cn.itcast.p.bean;
 
public class Person extend Object {
 
    private String name;
    private int age;
    
    
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    
    
    @Override
    public int hashCode() {
//        System.out.println(this+".......hashCode");
        
        return name.hashCode()+age*27;       //将age和name设置成为hashCode。
//        return 100;
    }
    @Override
    public boolean equals(Object obj) {
        
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");
        
//        System.out.println(this+"....equals....."+obj);
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;   //通过对比当前对象与下个将要比较的对象的姓名和age 是否相同来确定是否为同一个对象。
    }
    
 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString(){
        return name+":"+age;
    }
    
    
    }
 创建自定义对象

import java.util.Iterator;
import java.util.TreeSet;
 
import cn.itcast.p.bean.Person;
 
 
 
 
 
public class TreeSetDemo {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        TreeSet ts = new TreeSet();
        
        /*
         * 以Person对象年龄进行从小到大的排序。
         * 
         */
        
        
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhangsan",28));
        
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("wangu",24));
        
        Iterator it = ts.iterator();
        
        while(it.hasNext()){
            Person p = (Person)it.next();
            
            System.out.println(p.getName()+":"+p.getAge());
        }
    
    }
 
 
 
 
}
运行结果

却发现报错。报错原因是:java.lang.ClassCastException: cn.itcast.p.bean.Person cannot be cast to java.lang.Comparable

Person类不能被转换。 类型转换错误。并支出java.lang.Comparable。

去API查看Comparable 发现了如下特点。

有一个方法。

 原来是个排序的接口。那么就让Person类实现这个接口试试。

实现接口以后发现这个接口中的ComparaTo()方法默认的返回值是0。

运行集合发现,已经不报错,但是只输出集合中添加的头元素。

这是因为ComparTo()方法是一个比较方法,比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。默认为零系统认为都是同一个对象,所以只存入一个,因为Set集合的无序、唯一性。

那么想让自定义对象通过年龄大小,从小到大排序该怎么办呢?

  就得让自定义对象具备比较方法,ComparaTo(),在ComparaTo()方法中写入年龄的比较

@Override
    public int compareTo(Object o) {
        
        Person p = (Person)o;
        
    /*  int  temp =this.age-p.age;
     return temp==0?this.name.compareTo(p.name):temp;
        */
        
        if(this.age>p.age)
            return 1;
        if(this.age<p.age)
            return -1;
        return 0;
            
        
    }
 通过年龄的比较我们得到了年龄从小到大的对象排序。

但是有一种情况,在集合中添加对象时,如果两个对象的名字不同,年龄相同的对象怎么办? 结合是存还是不存该对象?

我们通过代码看一下。

/*这是存入集合的对象*/
    ts.add(new Person("lisi",21));
        ts.add(new Person("zhangsan",28));
        
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("mazi",25));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("wangu",24));
结果发现集合中没有存入异名同年龄的对象。这是因为我们在比较方法中是用年龄作为对比条件,年龄相同,就视为同一个对象。为了避免这种情况的出现,我们得给比较方法增加一个次要条件,把对象的年龄也作为比较条件。如果年龄相同,则比较姓名,姓名不同则存入集合,相同则不存。

Person  p=(Person)o;
if(this.age>p.age)
return 1;
if(this.age<p.age)
return -1;
   
        
else{
            
return this.name.compareTo(p.name);
}
结果输出正常:

接口三目运算符,优化比较排序ComparaTo()方法代码:

    @Override
    public int compareTo(Object o) {
        
        Person p = (Person)o;
        
      int  temp =this.age-p.age;
     return temp==0?this.name.compareTo(p.name):temp;
        }
 二、方式二 :让集合自身具备比较功能,定义一个类实现Comparator接口,覆盖compare方法。
       

package cn.itcast.p5.comparator;
 
import java.util.Comparator;
 
 
import cn.itcast.p.bean.Person;
/**
 * 创建了一个根据Person类的name进行排序的比较器。
 */
public class ComparatorByName implements Comparator {
 
    @Override
    public int compare(Object o1, Object o2) {
 
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        
        int temp = p1.getName().compareTo(p2.getName());
        
        return temp==0?p1.getAge()-p2.getAge(): temp;
//        return 1;//有序。
    }
 
}
创=创建对象时,传递一个针对性的比较器进去。

    将该类对象作为参数传递给TreeSet集合的构造函数。

    TreeSet ts = new TreeSet(new ComparatorByLength());
集合输出结果是按照名字排序。

三、比较器比较字符床长度。

 1、  先写一个字符串长度比较器:

import java.util.Comparator;
 
public class ComparatorByLength implements Comparator {
 
    @Override
    public int compare(Object o1, Object o2) {
        
        String s1 = (String)o1;
        String s2 = (String)o2;
        
        int temp = s1.length()-s2.length();
        
        return temp==0? s1.compareTo(s2): temp;
    }
 
}
2、再将比较器作为参数传递给TreeSet()集合构造器。

 
import java.util.Iterator;
import java.util.TreeSet;
 
import cn.itcast.p5.comparator.ComparatorByLength;
 
/* 
 * 对字符串进行长度排序。
 * 
 * "20 18 -1 89 2 67"
 */
 
public class TreeSetTest {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        TreeSet ts = new TreeSet(new ComparatorByLength());
 
        ts.add("aaaaa");
        ts.add("zz");
        ts.add("nbaq");
        ts.add("cba");
        ts.add("abc");
        
        Iterator it = ts.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
 
}
控制台输出:

 总结:

ComparaTo()方法和Comparator()方法的区别:

 ComparaTo()方法只需要传递一个参数对象,与本类对象进行比较。它是元素的比较方法。

Comparator()方法是集合的比较方法。强行对某个对象 collection 进行整体排序 的比较函数

上限的体现:

package cn.itcast.p5.generic.advance.demo;
 
import java.util.ArrayList;
 
import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;
 
public class GenericAdvanceDemo3 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        ArrayList<Person> al1 = new ArrayList<Person>();
        
        al1.add(new Person("abc",30));
        al1.add(new Person("abc4",34));
        
        ArrayList<Student> al2 = new ArrayList<Student>();
        
        al2.add(new Student("stu1",11));
        al2.add(new Student("stu2",22));
        
        
        ArrayList<Worker> al3 = new ArrayList<Worker>();
        
        al3.add(new Worker("stu1",11));
        al3.add(new Worker("stu2",22));
        
        ArrayList<String> al4 = new ArrayList<String>();
        al4.add("abcdeef");
//        al1.addAll(al4);//错误,类型不匹配。
        
        al1.addAll(al2);
        al1.addAll(al3);
        
        System.out.println(al1.size());
        
        
//        printCollection(al2);
//        printCollection(al);
    }
    
    
 
}
 
/*
 * 一般在存储元素的时候都是用上限,因为这样取出都是按照上限类型来运算的。不会出现类型安全隐患。 
 * 
 */
 
class MyCollection<E>{
    public void add(E e){
    
    }
    public void addAll(MyCollection<? extends E> e){
        
    }
}
       

下限的体现

 什么时候用下限呢?通常对集合中的元素进行取出操作时,可以是用下限。
 

package cn.itcast.p5.generic.advance.demo;
 
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
 
import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;
 
public class GenericAdvanceDemo4 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        TreeSet<Person> al1 = new TreeSet<Person>(new CompByName());
        
        al1.add(new Person("abc4",34));
        al1.add(new Person("abc1",30));
        al1.add(new Person("abc2",38));
        
        TreeSet<Student> al2 = new TreeSet<Student>(new CompByName());
        
        al2.add(new Student("stu1",11));
        al2.add(new Student("stu7",20));
        al2.add(new Student("stu2",22));
        
        
        TreeSet<Worker> al3 = new TreeSet<Worker>();
        
        al3.add(new Worker("stu1",11));
        al3.add(new Worker("stu2",22));
        
        TreeSet<String> al4 = new TreeSet<String>();
        al4.add("abcdeef");
//        al1.addAll(al4);//错误,类型不匹配。
        
//        al1.addAll(al2);
//        al1.addAll(al3);
        
//        System.out.println(al1.size());
        
        
        
        Iterator<Student> it = al2.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        
    }
}
 
 
/*
 * class TreeSet<Worker>
 * {
 *         Tree(Comparator<? super Worker> comp);
 * }
 * 
 * 什么时候用下限呢?通常对集合中的元素进行取出操作时,可以是用下限。
 * 
 */
 
class CompByName implements Comparator<Person>{
 
    @Override
    public int compare(Person o1, Person o2) {
        
        int temp = o1.getName().compareTo(o2.getName());
        
        return temp==0? o1.getAge()-o2.getAge():temp;
    }
    
}
 
class CompByStuName implements Comparator<Student>{
 
    @Override
    public int compare(Student o1, Student o2) {
        
        int temp = o1.getName().compareTo(o2.getName());
        
        return temp==0? o1.getAge()-o2.getAge():temp;
    }
    
}
 
class CompByWorkerName implements Comparator<Worker>{
 
    @Override
    public int compare(Worker o1, Worker o2) {
        
        int temp = o1.getName().compareTo(o2.getName());
        
        return temp==0? o1.getAge()-o2.getAge():temp;
    }
    
}
 
 
 
 
 
 
通配符的体现:、

       

package cn.itcast.p5.generic.advance.demo;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
 
import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;
 
public class GenericAdvanceDemo5 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        ArrayList<Person> al1 = new ArrayList<Person>();
        
        al1.add(new Person("abc",30));
        al1.add(new Person("abc4",34));
        ArrayList<Person> al2 = new ArrayList<Person>();
        
        al2.add(new Person("abc22222",30));
        al2.add(new Person("abc42222222",34));
        
        
        ArrayList<String> al4 = new ArrayList<String>();
        al4.add("abcdeef");
        al4.add("abc");
        
        al1.containsAll(al4);
        
        
//        "abc".equals(new Person("ahahah",20));
        
        
        
        
    }
    public static void printCollection(Collection<?> al){
        Iterator<?> it = al.iterator();
        
        while(it.hasNext()){
            
            System.out.println(it.next().toString());
        }
    }
}
 
class MyCollection2<E>{
    public boolean containsAll(Collection<?> coll){
        
        
        return true;
    }
}
 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值