JAVA基礎學習day15--集合二TreeSet和泛型

2019-11-14 15:33:57

字體：大中小

來源：轉載

供稿：網友

一、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());        }    }}

結果：

Dcaaahabcbcacda

示例二、使用對象

二、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:4print:heheshow:helloprint: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:heheprint:dfsdsprint:2323.3static:ffffstatic: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...23abc2...13abc3...33abc--1...23abc--2...13abc--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...13abc--3...33abc--5...23