JAVA基础学习(十五)--集合二--TreeSet和泛型

最新推荐文章于 2021-04-03 11:13:21 发布
最新推荐文章于 2021-04-03 11:13:21 发布
阅读量324 收藏
点赞数
分类专栏： JAVA基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ko0491/article/details/48720427
版权

一、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
 
 
 
  复制代码 
 
 

 

  

                

        

        

    




    

      

        

            

              
                
                  森林森
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java创建TreeSet泛型集合_Java-（泛型，集合-Set,HashMap,异常处理）

				
			

			

				

					weixin_39882317的博客
				

				

					03-01
					
					328
					
				

			

		

		

			
				
心得体会有时候上课认真听讲效率胜过课后自己花费大量时间再去学习，上课边听边有意识的整理笔记胜过课后去整理自己杂乱的笔记要来的轻松。如果自己在课上写代码的时候有意识的将代码模块化，课后再去整理就会轻松很多。一个好习惯的养成是长久的坚持。今日知识点1.泛型2.集合-Set(hashSet)3.TreeSet进行排序的两种办法4.HashMap的方法5.键值对的两种遍历方式6.异常处理具体操作1.泛型1...

			
		

	



                

              
                



	

		

			

				
					
Java集合、泛型和枚举

				
			

			

				

					06-14
				

			

		

		

			
				
Java集合框架是Java编程语言中不可或缺的一部分，它提供了...总的来说，Java集合、泛型和枚举是构建复杂数据结构和实现业务逻辑的关键工具。熟练掌握这些概念和它们的使用方法，将极大地提升Java编程的效率和代码质量。

			
		

	



                


  
              

                


	

		

			

				
					
Java基础之集合框架(二)--TreeSet、泛型

				
			

			

				

					枫叶的专栏
				

				

					06-30
					
					718
					
				

			

		

		

			
				
TreeSet类：
import java.util.*;

/*
Set:无序，不可以重复元素。
	|--HashSet：数据结构是哈希表。线程是非同步的。
				保证元素唯一性的原理：判断元素的hashCode值是否相同。
				如果相同，还会继续判断元素的equals方法，是否为true。

	|--TreeSet：可以对Set集合中的元素进行排序。
				底层数据结构是二叉树。

			
		

	





	

		

			

				
					
黑马程序员java基础之集合Set中的TreeSet和泛型

				
			

			

				

					yueye12的专栏
				

				

					01-24
					
					590
					
				

			

		

		

			
				
Set集合中的TreeSet的使用以及泛型的使用方法，还有泛型的高级使用泛型限定

			
		

	



		

			
		



	

		

			

				
					
day15_集合框架2(TreeSet,泛型)

				
			

			

				

					weixin_30667301的博客
				

				

					04-11
					
					73
					
				

			

		

		

			
				
1.TreeSet排序两种方式:


/*
 set:无序,元素不重复
   <-HashSet:数据结构是哈希表,线程是非同步的
             保证元素唯一性的原理:判断元素的hashCode值是否相同
             如果相同,还会继续判断元素的equals方法,是否为true.
   
   <-TreeSet:可以对set集合中的元...

			
		

	





	

		

			

				
					
java现有一个泛型类 提供数组排序功能_JavaSE面试详解35题

				
			

			

				

					weixin_42314399的博客
				

				

					02-28
					
					366
					
				

			

		

		

			
				
1.抽象类和接口的区别1.解释抽象类的诞生过程：由于继承的子类中方法很相似，只是实现的内容不同，那么抽取共性放在父类中，共性的方法只能有方法声明，没有具体的方法体(以猫狗为例)2.一句话解释：没有具体方法体的方法就是抽象方法，有抽象方法的类就是抽象类3.介绍抽象类的特点：3.1抽象类里面有抽象方法3.2抽象类和抽象方法都需要使用abstract修饰3.3抽象类里面可以有非抽象方法3.4一个类继承抽...

			
		

	





	

		

			

				
					
java基础知识学习教程-9集合与泛型.pptx

				
			

			

				

					10-30
				

			

		

		

			
				
Java基础知识学习教程-9集合与泛型  Java集合框架是Java语言中的一种数据结构，用于存储和操作数据。集合框架提供了多种类型的集合，包括Collection、Set、List、Queue、Map等。这些集合类型都继承自Collection接口...

			
		

	





	

		

			

				
					
Java基础精品课17-集合框架.zip

				
			

			

				

					05-20
				

			

		

		

			
				
在Java集合框架中，泛型是一个关键特性，它允许我们在创建集合时指定元素类型，增强了代码的安全性和可读性。此外，迭代器（Iterator）和foreach循环是遍历集合的主要方式。  理解`Collections`类和`Arrays`类也是很...

			
		

	





	

		

			

				
					
Java-Java集合教程

					
最新发布

				
			

			

				

					11-13
				

			

		

		

			
				
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了数据结构和算法的实现，使得在处理对象集合时更加高效和灵活。Java集合教程通常会涵盖以下关键知识点：  1. **集合接口**：  - `Collection`：这是...

			
		

	





	

		

			

				
					
java基础核心总结归纳---参考手册--心得手册-学习资料-总结经验

				
			

			

				

					12-20
				

			

		

		

			
				
 - 集合框架：如ArrayList、Vector、LinkedList、HashSet、TreeSet、LinkedHashSet、HashMap等，用于存储和操作对象。  - 泛型：提供类型安全，允许在类、接口和方法中指定参数类型。  - 反射：运行时动态获取类的...

			
		

	





	

		

			

				
					
JAVA代码训练营救——TreeSet的泛型实现

				
			

			

				

					Jungle_hello的博客
				

				

					05-09
					
					524
					
				

			

		

		

			
				
import java.util.*;
class GenericDemo2
{
    public static void main(String[] args)
    {
        TreeSet<String>ts = new TreeSet<String>(new LenComparator());
        ts.add("abcd");
        ts.add("c

			
		

	





	

		

			

				
					
TreeSet＜E＞ 泛型类

				
			

			

				

					静Yu的博客
				

				

					01-26
					
					399
					
				

			

		

		

			
				
TreeSet泛型类
1.TreeSet泛型类在java.util包中
2.TreeSet泛型类创建的对象称为树集
创建TreeSet泛型类对象
假设已经声明了学生类Student，可以创建学生树集
TreeSet tree=new TreeSet ();
• tree可以存储Student对象的集合。
• tree可以调用
add(Student s)
将Student对象添加到树集中。
• TreeSet泛型类的其他常用方法，请自行
查阅Java API
以下源代码可以创建字符串树集，并且按照字典序升序

			
		

	





	

		

			

				
					
java---HashSet、TreeSet、泛型

				
			

			

				

					qq_17503037的博客
				

				

					04-11
					
					282
					
				

			

		

		

			
				
Vector

集合 的体系：

–| Collection 单例集合的根接口

—–| List  如果是实现了List接口的集合类，具备的特点： 有序，可重复。 

———| ArrayList  ArrayList 底层是维护了一个Object数组实现的。 特点： 查询速度快，增删慢。

———| LinkedList LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度...

			
		

	





	

		

			

				
					
60 java集合和泛型_10 _Set实现类 _TreeSet

				
			

			

				

					wang_luwei的博客
				

				

					07-17
					
					176
					
				

			

		

		

			
				
文章目录Set实现类TreeSet存储结构：红黑树TreeSet的使用Comparator 接口TreeSet案例
Set实现类


HashSet 【重点】 :

基于HashCode计算元素存放位置，实现元素不重复。（存储结构是一个哈希表）
当存入元素的哈希码相同时，会调用equals进行确认， 如结果为true, 则拒绝后者存入。



TreeSet：（set集合是无序的，而TreeSet，对元素进行了排序）

基于排列顺序实现元素不重复。
实现了SortedSet接口，对集合元素自动排序。
元素对

			
		

	





	

		

			

				
					
java创建TreeSet泛型集合_TreeSet集合中的 泛型限定 super 问题

				
			

			

				

					weixin_42516119的博客
				

				

					03-01
					
					141
					
				

			

		

		

			
				
该楼层疑似违规已被系统折叠隐藏此楼查看此楼import java.util.*;class Person {private String name;Person(String name) {this.name = name;}public String getName() {return name;}}class Student extends Person {Student(String na...

			
		

	





	

		

			

				
					
HashSet、TreeSet及泛型

				
			

			

				

					yangruijing1990的专栏
				

				

					03-06
					
					380
					
				

			

		

		

			
				
Set：无序（存入和取出的顺序不一定一致），不能重复，Set集合的功能和Collection是一致的
1、常见的子类：
HashSet：底层数据结构是哈希表
      HashSet是通过元素的两个方法，hashCode和equals来完    成，如果元素的HashCode值相同，才会判断equals是否为 true，如果元素的hashCode值不同，不会调用equals。
注意：对于

			
		

	





	

		

			

				
					
TreeSet的使用

				
			

			

				

					muyuxifeng的博客
				

				

					04-03
					
					2391
					
				

			

		

		

			
				
TreeSet是一个有序的集合，它支持自然排序和根据实现Comparator或Comparable接口进行排序。下面通过案例来看一下TreeSet的使用
1、使用TreeSet对String类型的数据进行存储，存储顺序默认按字母升序排序。
在本例题中，定义TreeSet集合，并添加多个字符串到集合中，然后对集合进行遍历输出，并通过first()和last()方法来获取集合中的第一个和最后一个元素
package com.jinglan.sort;

import java.util.TreeSet;

pu

			
		

	





	

		

			

				
					
利用Filter解决乱码问题

				
			

			

				

					谷哥的小弟
				

				

					11-18
					
					1144
					
				

			

		

		

			
				
利用EncodingFilter统一处理GET和POST的请求及其响应从而避免乱码的出现。

			
		

	





	

		

			

				
					
Java泛型与集合基础操作详解

				
			

			

				

					
				

			

		

		

			
				
Java集合和泛型是Java编程语言中两个重要的概念，它们有助于提高代码的灵活性、可重用性和类型安全。泛型是一种强大的工具，它允许程序员在编写通用代码时指定类型参数，从而创建可以在多种数据类型上工作的类和方法...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值