JAVA基础学习day15--集合二 TreeSet和泛型

一、TreeSet

1.1、TreeSet

Set:hashSet:数据结构是哈希表。线程是非同步的。

       保证元素唯一性的原理：判断元素的HashCode值是否相同。

        如果相同，还会判断元素的equals方法是否为true;

      TreeSet: 可以去Set集合中的元素时行 排序。

　　使用二叉树的数据结构。

     保证元素唯一性的依据：compareTo()方法return 0

　　

使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 

示例一、

package com.pb.treeset.demo1;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * 
 * @author Denny
 * TreeSet
 * 可以对Set集合的元素进行自然排序
 *
 */
public class TreeSetDemo1 {

    public static void main(String[] args) {
        TreeSet ts=new TreeSet();
        ts.add("abc");
        ts.add("aah");
        ts.add("cda");
        ts.add("bca");
        ts.add("Dca");
        for(Iterator it=ts.iterator();it.hasNext();){
            System.out.println(it.next());
        }

    }

}

结果：

Dca
aah
abc
bca
cda

示例二、使用对象

二、Comparable

TreeSet排序：

第一种方式，让元素自身具备比较性，元素实现Comparable接口，重写compareTo()方法。自然顺序排序

2.1、Comparable接口

public interface Comparable<T>

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

使用TreeSet存多个对象时，要在该对象类中实现Comparable接口，以实现TreeSet的排序，不然就会报java.lang.ClassCastException:

cannot be cast to java.lang.Comparable

方法摘要
int	compareTo(T o) 比较此对象与指定对象的顺序。

 

参数：

o - 要比较的对象。

返回：

负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

抛出：

ClassCastException - 如果指定对象的类型不允许它与此对象进行比较。

排序时：当主要条件相同时，要判断次要条件。

package com.pb.treeset.demo1;

public class Person implements Comparable{
    private String name;//姓名
    private int age;//年龄
    private String gender;//性别
    
    
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }


    public Person(String name, int age, String gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }


    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 getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }
    
    //显示所有属性
    public void show(){
        System.out.println("姓名："+this.name+"........年龄："+this.age+"...........性别："+this.gender);
    }

    /*
     * 按照年龄大小排序，年龄相同按姓名排序
     */
    @Override
    public int compareTo(Object obj) {
        if(!(obj instanceof Person)){
            try {
                throw new Exception("不是人类对象");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        Person p=(Person)obj;
        if(this.age>p.age){
            return 1;
        }else if(this.age<p.age){
            return -1;
        }else{
            return this.name.compareTo(p.name);
        }
    }

}

package com.pb.treeset.demo1;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo2 {

    public static void main(String[] args) {
        Person p1=new Person("lisi007",19,"man");
        Person p2=new Person("lisi003",20,"woman");
        Person p3=new Person("zhangsan002",19,"man");
        Person p4=new Person("abc009",20,"woman");
        Person p5=new Person("ndd011",19,"man");
        Person p6=new Person("qq005",16,"woman");
        //声明TreeSet集合
        TreeSet<Person>ts=new TreeSet<Person>();
        //添加对象元素
        ts.add(p1);
        ts.add(p2);
        ts.add(p3);
        ts.add(p4);
        ts.add(p5);
        ts.add(p6);
        //遍历
        for(Iterator<Person> it=ts.iterator();it.hasNext();){
            Person p=it.next();
            p.show();
        }
    }

}

结果：

姓名：qq005........年龄：16...........性别：woman
姓名：lisi007........年龄：19...........性别：man
姓名：ndd011........年龄：19...........性别：man
姓名：zhangsan002........年龄：19...........性别：man
姓名：abc009........年龄：20...........性别：woman
姓名：lisi003........年龄：20...........性别：woman

示例：如果按存入顺序取出只需要CompareTo方法return 1

package com.pb.treeset.demo1;

public class Person implements Comparable{
    private String name;//姓名
    private int age;//年龄
    private String gender;//性别
    
    
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }


    public Person(String name, int age, String gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }


    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 getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }
    
    //显示所有属性
    public void show(){
        System.out.println("姓名："+this.name+"........年龄："+this.age+"...........性别："+this.gender);
    }

    /*
     * 按照年龄大小排序，年龄相同按姓名排序
     */
    @Override
    public int compareTo(Object obj) {
        //存出顺序
        return 1;
        //倒序
        //return -1
        //如果返回0就只有一个元素
    }

}

三、

3.1、实现指定的比较器实现Comparator 接口，重写compare方法

第二种方式：当元素自身不具备比较性时或者具备的比较性不是所需要的。

                这里就需要让集合自身具备比较性。

　　　　在集合初始化，就有了比较方式。

构造方法摘要

TreeSet()
构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。

TreeSet(Collection<? extends E> c)
构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。

TreeSet(Comparator<? super E> comparator)
构造一个新的空 TreeSet，它根据指定比较器进行排序。

TreeSet(SortedSet<E> s)
构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

 定义比较器，将比较器对象 作为参数转递给集合TreeSet的构造方法

示例一、

package com.pb.treeset.demo2;

public class Person{
    private String name;//姓名
    private int age;//年龄
    private String gender;//性别
    
    
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }


    public Person(String name, int age, String gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }


    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 getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }
    
    //显示所有属性
    public void show(){
        System.out.println("姓名："+this.name+"........年龄："+this.age+"...........性别："+this.gender);
    }

}

比较器

package com.pb.treeset.demo2;

import java.util.Comparator;
/**
 * 比较器，实现Comparator接口，
 * 并重写compare方法
 * @author Administrator
 *
 */
public class MyComparetor implements Comparator<Person>{

        /*
         * 按姓名排序，如果姓名相同，按年龄排序
         */
    @Override
    public int compare(Person p1, Person p2) {
        //比较姓名
        int num=p1.getName().compareTo(p2.getName());
        //如果姓名相同
        if(num==0){
            //比较年龄
            return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        }
        //返回结果
        return num;
    }


}

package com.pb.treeset.demo2;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo3 {

    public static void main(String[] args) {
        //声明TreeSet集合，并将比较器传入构造方法
        TreeSet<Person> ts=new TreeSet<Person>(new MyComparetor());
        //添加元素
        ts.add(new Person("lisi010",21,"man"));
        ts.add(new Person("lisi010",19,"man"));
        ts.add(new Person("lisi007",21,"woman"));
        ts.add(new Person("lisi002",16,"man"));
        ts.add(new Person("lisi022",21,"woman"));
        ts.add(new Person("lisi010",16,"man"));
        //遍历
        for(Iterator<Person> it=ts.iterator();it.hasNext();){
            Person p=it.next();
            p.show();
        }

    }

}

姓名：lisi002........年龄：16...........性别：man
姓名：lisi007........年龄：21...........性别：woman
姓名：lisi010........年龄：16...........性别：man
姓名：lisi010........年龄：19...........性别：man
姓名：lisi010........年龄：21...........性别：man
姓名：lisi022........年龄：21...........性别：woman

示例二、

package com.pb.treeset.demo2;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
 * 按照字符串长度排序
 */
public class TreeSetDemo4 {

    public static void main(String[] args) {
        TreeSet<String> ts=new TreeSet<String>(new MyCompare());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("Cba");
        ts.add("z");
        ts.add("NBA");
        ts.add("hehe");
        ts.add("A");
        for(Iterator<String> it =ts.iterator();it.hasNext();){
            System.out.println(it.next());
        }

    }

}
/*
 * 比较器
 */
class MyCompare implements Comparator<String>{

    @Override
    public int compare(String s1, String s2) {
        //比较长度
        int len=new Integer(s1.length()).compareTo(new Integer(s2.length()));
        //如果长度相同，比较内容
        if(len==0){
            return s1.compareTo(s2);
        }
        return len;
        
    }
    
}

四、泛型

4.1、泛型概述

JDK1.5出现新特性，用于解决安全问题，是一个安全机制

如：ArrayList<String> a1=new ArrayList<String>();

声明一个字符串类型的arraylist容器，只能存String类型

优点：将运行时期出现的问题ClassCastException，转移到了编译时期。

        方便程序员解决问题，让运行时问题送减少，同时安全。

    避免了强制类型转换麻烦。

package com.pb.fanxing.demo1;

import java.util.ArrayList;
import java.util.Iterator;

public class ArryListDemo1 {

    public static void main(String[] args) {
        //声明一个Arraylist集合，只能存放String类型
        ArrayList<String> al=new ArrayList<String>();
        al.add("abcd");
        al.add("adc");
        al.add("NBA");
        al.add("CFO");
        //遍历
        Iterator<String> it=al.iterator();
        while(it.hasNext()){
            String str=it.next();
            System.out.println(str);
        }
        
    }

}

 

五、泛型使用

5.1、使用泛型

通过<>来定义泛型

通常在集合框架中很常见，只要见到<>就要定义泛型。

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

当使用集合时，将集合要存储的数据类型作为参数传递到<>中.

package com.pb.fanxing.demo1;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
//倒序排列

public class Demo2 {

    public static void main(String[] args) {
        TreeSet<String> ts=new TreeSet<String>(new MyCompare());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("Cba");
        ts.add("z");
        ts.add("NBA");
        ts.add("hehe");
        ts.add("A");
        for(Iterator<String> it =ts.iterator();it.hasNext();){
            System.out.println(it.next());
        }

    }

}
/*
 * 比较器
 */
class MyCompare implements Comparator<String>{

    @Override
    public int compare(String s1, String s2) {
        //比较长度
        //倒序排列
        int len=new Integer(s2.length()).compareTo(new Integer(s1.length()));
        //如果长度相同，比较内容
        if(len==0){
            return s2.compareTo(s1);
        }
        return len;
        
    }
}

hehe
abcd
cba
NBA
Cba
cc
z
A

六、泛型类

6.1、泛型类的使用

package com.pb.fanxing.demo2;
/**
 * 当类中要操作的引用数据类型不确定的时候
 * 早期定主Object来完成扩展
 * 现在定义泛型来完成扩展
 *
 */
class Person{
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.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;
    }
    
    
    
}
class Student extends Person{
    private int id;

    
    
    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    
}
/*
 * 泛型类
 */
class Utils<T>{
    
    private T t;
    public void setT(T t){
        this.t=t;
    }
    public T getT(){
        return t;
    }
}

public class GenericDemo1 {

    public static void main(String[] args) {
        Utils<Person> u=new Utils<Person>();
        u.setT(new Person("张三",23));
        Person person=u.getT();
        System.out.println(person.getName()+"......"+person.getAge());

    }

}

泛型类定义的泛型，在整个类中有效，如果被方法使用

泛型类的对象明克要操作的具体类型后，所有 要操作的类型已经固定

七、泛型方法

7.1、泛型类的方法

为了让不同方法可以操作不同类型，而且类型还不确定，

可以将泛型定义在方法上

package com.pb.fanxing.demo2;

/**
 * 泛型方法
 *
 */
class Demo{
    public<T> void show(T t){
        System.out.println("show:"+t);
    }
    public <T> void print(T t){
        System.out.println("print:"+t);
    }
}

public class GenericDemo2 {

    public static void main(String[] args) {
        Demo d=new Demo();
        d.show(4);
        d.print("hehe");
        d.show("hello");
        d.print(3.4);

    }

}

结果：

show:4
print:hehe
show:hello
print:3.4

八、静态泛型方法

8.1、静态泛型方法

静态方法不可以访问类上定义的泛型。

如果静态方法访问的类型不确定，可以将泛型定义在方法上

package com.pb.fanxing.demo2;

class Tool<T>{
    //和类上的泛型一至
    public<T> void show(T t){
        System.out.println("show:"+t);
    }
    //单独的和类上的不一样，但也可以使用类上的
    public <Q> void print(Q q){
        System.out.println("print:"+q);
    }
    //单独的和类上的不一样因为是static的，不能和类上的一样
    public static<W> void method(W t){
        System.out.println("static:"+t);
    }
}

public class GenericStaticDemo {

    public static void main(String[] args) {
        //定义字符串
        Tool<String> t=new Tool<String>();
        //传入字符串
        t.show("hehe");
        //传入字符串
        t.print("dfsds");
        //传入double
        t.print(2323.3);
        //传入字符串
        t.method("ffff");
        //传入int
        t.method(222);

    }

}

结果：

show:hehe
print:dfsds
print:2323.3
static:ffff
static:222

九、泛型接口

9.1、泛型接口

package com.pb.fanxing.demo2;

interface Test<T>{
    public void show(T t);
}
class TestImpl<T> implements Test<T>{

    @Override
    public  void show(T t) {
        System.out.println(t);
    }
    
}

public class GenericDemo3 {

    public static void main(String[] args) {
        Test<String> test=new TestImpl<String>();
        test.show("hello");
        
        Test<Integer> test1=new TestImpl<Integer>();
        test1.show(332);
    }

}

十、泛型限定

10.1、泛型限定

使用<?>来占位

package com.pb.fanxing.demo2;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericDemo4 {

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("aa");
        list.add("ab");
        list.add("ac");
        List<Integer> list1=new ArrayList<Integer>();
        list1.add(3);
        list1.add(1);
        list1.add(5);
        print(list);
        print(list1);

    }
    /*public static void print(List<?> list){ //不确定类型
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }*/
    //使用泛型T
    public static<T> void print(List<T> list){ //不确定类型
        Iterator<T> it=list.iterator();
        while(it.hasNext()){
            T t=it.next(); //使用泛型可以操作对象
            System.out.println(t);
        }
    }
}

aa
ab
ac
3
1
5

10.2、上限和下限

？：通配符，也可以理解为占位符。

泛型的限定

<? extends E>:可以接收E类型 或者E的子类 上限

<? super E> 可以接收E类型或者E的父类型。下限

package com.pb.fanxing.demo2;

import java.util.ArrayList;
import java.util.Iterator;

class Person{
    private String name;
    private int age;
    public 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{
    public Student(String name,int age){
        super(name,age);
    }
}
public class GenericDemo5 {

    public static void main(String[] args) {
        ArrayList<Person> a1=new ArrayList<Person>();
        a1.add(new Person("abc1",23));
        a1.add(new Person("abc2",13));
        a1.add(new Person("abc3",33));
        ArrayList<Student> a2=new ArrayList<Student>();
        a2.add(new Student("abc--1",23));
        a2.add(new Student("abc--2",13));
        a2.add(new Student("abc--3",33));
        
        print(a1);
        print(a2);
        
    }
    public static void print(ArrayList<? extends Person> list){//代表Person和Person的子类
        Iterator<? extends Person> it=list.iterator();
        while(it.hasNext()){
            Person p=it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }
}
//结果
abc1...23
abc2...13
abc3...33
abc--1...23
abc--2...13
abc--3...33

下限

package com.pb.fanxing.demo2;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

class Person{
    private String name;
    private int age;
    public 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{
    public Student(String name,int age){
        super(name,age);
    }
}
public class GenericDemo5 {

    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<Student>(new MyCompare());
            
        ts.add(new Student("abc--5",23));
        ts.add(new Student("abc--2",13));
        ts.add(new Student("abc--3",33));
        
        print(ts);
        
        
    }
    public static void print(Set<? extends Person> list){//代表Person和Person的子类
        Iterator<? extends Person> it=list.iterator();
        while(it.hasNext()){
            Person p=it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }
}
class MyCompare implements Comparator<Person>{

    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
    
}
//结果：

abc--2...13
abc--3...33
abc--5...23