黑马程序员——17，集合，TreeSet，二叉树，泛型

最新推荐文章于 2021-06-06 00:47:21 发布
最新推荐文章于 2021-06-06 00:47:21 发布
阅读量595 收藏 1
点赞数
分类专栏： Java学习笔记 文章标签： 黑马程序员 二叉树 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dangaodeaiyi/article/details/47280787
版权

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

          

                    黑马程序员——17，集合，TreeSet，二叉树，泛型

 

/*

  TreeSet:可以自动对容器内部元素排序

*/

import java.util.*;
//Collection接口的体系放在Java.util包里面
 
class  Jihe13
{
         publicstatic void main(String[] args)
         {
       method();
         }
         public   static void   method()
         {
                   soc("下面是method------");
             TreeSet  a=  new   TreeSet();
                   a.add("haha01");
             a.add("iujha02");
                   a.add("Ufwqha03");
                   a.add("fha01");
             a.add("haha02");
                   a.add("Fsfsda05");
                   a.add("hvdv05");
                   a.add("vadba03");
                   a.add("Nhna02");
                   a.add("tyra07");
                   a.add("25D");
                   Iterator   it= a.iterator();
                   while(it.hasNext()        )
                   {
                          
            soc(it.next());
                   }
                   /*
                   TreeSet的容器里面元素被打印出来都是逐位比对之后的结果，
                   在逐位比对时，常见的优先顺序：数字>大写字母>小写字母，
                   */              
         }
          public static   void     soc(Object obj)
         {
              System.out.println(obj);  
         }
}
/*
以上代码编译运行结果：
下面是method------
25D
Fsfsda05
Nhna02
Ufwqha03
fha01
haha01
haha02
hvdv05
iujha02
tyra07
vadba03
 
*/

——————分割线——————

 

/*

   TreeSet存储自定义对象的例子：

         TreeSet的元素一定要有比较性，而且TreeSet可以自动把具有比较性的元素排序

         这也是底层调用的一种表现形式TreeSet里面不可以存放重复元素，重复元素将会会被删除

*/

 

import java.util.*;
//Collection接口的体系放在Java.util包里面
class  Student      implements   Comparable//Comparable接口强制学生类的实例个体具备了比较性
 
{
    private  String  name  ;
          private    int   age;
         Student(String  name,int age)
         {
                this.name=name;
                      this.age=age;
 
         }
   public    int   compareTo(Object  obj)
         {
                  
              if( ! ( obj  instanceof  Student  ) )
                    {
                         throw new  RuntimeException("不是学生");          
                    }
                    Student  a=(Student)obj;
                    System.out.println("这是"+this.name+"和"+a.name+"比较");
        if( this.age>a.age    )
                    {
                          return 1;   
                    }
                    if(this.age==a.age)
                    {
                             //主要条件相同要判断次要条件
 
                          return this.name.compareTo(a.name);
                               //String类也实现了Comparable接口，也有compareTo方法
                               //如果这里直接写return  0;的话就表示了对象是相同的
                     }
 
                         return  -1;
                          /*
 TreeSet排序的原理是二叉树排序：（底层数据结构二叉树结构）
 所谓的二叉树，例如：就是第一个元素进去，第二个元素进去判断若是比第一个元素大则放在右下边，(返回正数)
 若是比第一个元素小则是放在左下边(返回负数)若是相同元素（返回0）则是被剔除掉。如此类推下去就会形成一个叉型树。
 不过，如果元素个数过多的话，进来的元素会挑二叉树中的某一个元素做比较：
        1，若是比那某个元素大则放在那某个元素的右下边，若是相等则是被剔除，
        2，若是比那某个元素小泽放在左下边，
        3，但是如果比那某个元素右下边的元素都大就跳到那某个元素的上一层继续比较，
              就这样子，一步步确定自己在二叉树中的位置。
也可以利用这个原理，让compareTo方法返回值固定为正数或者负数，使得添加的元素按照添加顺序排序了（正序或者倒序）。
 最后逐个输出的时候也是从最左边的开始按照二叉树顺序输出。
               */
 
         }
   public   String   getName()
         {
                 return  name;    
         }
   public   int   getAge()
         {
                 return  age;    
         }
 
 
}
class  Jihe14
{
         publicstatic void main(String[] args)
         {
       TreeSet   a=  new  TreeSet();
                   a.add(new   Student("haha01",12));
             a.add(new  Student("haha02",19));
                   a.add(new   Student("haha03",26));
                   a.add(new   Student("haha04",15));
             a.add(new  Student("haha05",1));
                   a.add(new   Student("haha06",16));
                   a.add(new   Student("haha07",76));
                   a.add(new   Student("haha08",17));
       a.add(new  Student("haha09",17));
                   a.add(new   Student("haha06",16));
    //TreeSet与一个Comparable接口相关，该接口强制对实现它的每一个类的对象排序
          /*Comparable接口之所以有这种强制排序能力，因为该接口有一个用来比较的compareTo方法。
      所以这对于TreeSet存储自定义对象时候就可以利用实现Comparable接口，并且复
            写compareTo方法
     */
                   Iterator   it= a.iterator();
                   while(it.hasNext()        )
                   {
                        Student  stu=(Student)it.next()    ;  
            soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
                   }
         }
 
         public   static  void  soc(Object  obj)
         {
                System.out.println(obj);
         }
}
 
/*
以上代码编译运行结果：
这是haha01和haha01比较
这是haha02和haha01比较
这是haha03和haha01比较
这是haha03和haha02比较
这是haha04和haha02比较
这是haha04和haha01比较
这是haha05和haha02比较
这是haha05和haha01比较
这是haha06和haha02比较
这是haha06和haha01比较
这是haha06和haha04比较
这是haha07和haha02比较
这是haha07和haha03比较
这是haha08和haha02比较
这是haha08和haha01比较
这是haha08和haha04比较
这是haha08和haha06比较
这是haha09和haha02比较
这是haha09和haha01比较
这是haha09和haha06比较
这是haha09和haha08比较
这是haha06和haha06比较
名字---haha05---年龄---1
名字---haha01---年龄---12
名字---haha04---年龄---15
名字---haha06---年龄---16
名字---haha08---年龄---17
名字---haha09---年龄---17
名字---haha02---年龄---19
名字---haha03---年龄---26
名字---haha07---年龄---76
 
 
*/

——————分割线——————

 

 

/*

但是如果元素自己没有或者自己本身具备的比较性不适合：

例如：

学生个体已经具备年龄的比较性，但是排序的时候需要按照名字排序，

这个时候就需要定义一个类实现Comparator接口，覆盖compare方法，该类一个比较器类，

该类的实例就是一个比较器。

把比较器放入TreeSet构造函数中，就会优先用比较器进行元素排列（不管元素本身是否具备比较性）

*/

 

import java.util.*;
//Collection接口的体系放在Java.util包里面
class  Student      implements   Comparable//Comparable接口强制学生类的实例个体具备了比较性
 
{
    private  String  name  ;
          private    int   age;
         Student(String  name,int age)
         {
                this.name=name;
                      this.age=age;
 
         }
   public    int   compareTo(Object  obj)
         {
                  
              if( ! ( obj  instanceof  Student  ) )
                    {
                         throw new  RuntimeException("不是学生");          
                    }
                    Student  a=(Student)obj;
                    System.out.println("这是"+this.name+"和"+a.name+"比较");
        if( this.age>a.age    )
                    {
                          return 1;   
                    }
                    if(this.age==a.age)
                    {
                             //主要条件相同要判断次要条件
 
                          return this.name.compareTo(a.name);
                     }
 
                         return  -1;
 
         }
   public   String   getName()
         {
                 return  name;    
         }
   public   int   getAge()
         {
                return   age;    
         }
 
 
}
class  Jihe15
{
         publicstatic void main(String[] args)
         {
       TreeSet   a=  new  TreeSet(new   Bijiao()   );//把比较器放进TreeSet构造函数中
                   a.add(new   Student("vdsfb1",12));
             a.add(new  Student("惹我02",19));
                   a.add(new   Student("吧03",26));
                   a.add(new   Student("haha04",15));
             a.add(new  Student("qwqwe5",1));
                   a.add(new   Student("ahs6",16));
                   a.add(new   Student("ibbf07",76));
                   a.add(new   Student("cuhn8",17));
       a.add(new  Student("kvjakn09",17));
                   a.add(new   Student("kvjakn09",16));
 
                   Iterator   it= a.iterator();
                   while(it.hasNext()        )
                   {
                        Student  stu=(Student)it.next()    ;  
            soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
                   }
         }
 
         public   static  void  soc(Object  obj)
         {
                System.out.println(obj);
         }
}
class   Bijiao   implements   Comparator
{
           public  int   compare(Object  a,Object b)
           {
                 Student   na=(Student)a;   
                       Student  nb=(Student)b;
                            int  num=na.getName().compareTo(nb.getName());
                            //这里的compareTo方法是字符串本身就具备的方法，按照字典排列字符串
                            if(num==0)
                       {
                               return  na.compareTo(nb);   //按照元素本身具备的比较性进行比较   
                            }
                            return  num;
           }     
}
/*
以上代码编译运行结果：
这是vdsfb1和vdsfb1比较
这是kvjakn09和kvjakn09比较
名字---ahs6---年龄---16
名字---cuhn8---年龄---17
名字---haha04---年龄---15
名字---ibbf07---年龄---76
名字---kvjakn09---年龄---16
名字---kvjakn09---年龄---17
名字---qwqwe5---年龄---1
名字---vdsfb1---年龄---12
名字---吧03---年龄---26
名字---惹我02---年龄---19
 
*/

——————分割线——————

 

 

/*

    比较字符串长度

         字符串本身具备了比较性，但是不合适

         就用比较器了

*/

import  java.util.*;
class  Jihe16
{
         publicstatic void main(String[] args)
         {
                   TreeSet   a=new TreeSet(new  Cdbijiao());
             a.add("cyufihjv");
                   a.add("dzsrzx");
             a.add("ihu");
             a.add("erasdf");
                   a.add("vyivlbjkbui");
             a.add("tydfy");
             a.add("pjokn");
             a.add("cryxtsbrnr");
 
                   Iterator   it=a.iterator();
                   while(it.hasNext())
                   {
                        soc(it.next());    
                   }
 
                   System.out.println("HelloWorld!");
         }
         public  static   void   soc(Object  obj)
         {
             System.out.println(obj);            
                           
         }
 
}
class Cdbijiao   implements   Comparator 
{
     public  int  compare(Object  a,Object b)
           {
                 String na=(String)a;
                            String  nb=(String)b;
                            if(na.length()==nb.length())
                                     return   na.compareTo(nb);
 
                            if(na.length()>nb.length())
                       {
                                 return  1;    
                            }
 
                            return  -1;
           }
 
}
/*
以上代码编译运行结果：
ihu
pjokn
tydfy
dzsrzx
erasdf
cyufihjv
cryxtsbrnr
vyivlbjkbui
Hello World!
 
*/

——————分割线——————

/*

关于泛型的介绍：

*/

import java.util.*;
//Collection接口的体系放在Java.util包里面
class  Student     
 
{
    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;    
         }
 
 
}
class  Jihe17
{
         publicstatic void main(String[] args)
         {
       ArrayList<Student>   a=  new  ArrayList<Student>();
                   /*
                   这里的<>就是一种泛型的应用，一种保护机制。
                   这里的例子表示的就是ArrayList类型的容器中只能够装Student类型的元素
                   这样使用泛型这种保护机制后之前编译会出现的两行注意提示也没有了。
                   但是，如果此时往容器a里面添加的不是Student类型的元素的时编译就会出问题
                   */
                   a.add(new   Student("haha01",12));
             a.add(new  Student("haha02",19));
                   a.add(new   Student("haha03",26));
                   a.add(new   Student("haha04",15));
             a.add(new  Student("haha05",1));
                   a.add(new   Student("haha06",16));
                   a.add(new   Student("haha07",76));
                   a.add(new   Student("haha08",17));
       a.add(new  Student("haha09",17));
                   a.add(new   Student("haha06",16));
            // a.add("haha06");//这句话编译会出问题
 
                   Iterator<Student>   it= a.iterator();
                   /*
                   表示返回迭代器里面的也是Student类型的元素，
                   那么到时候迭代器调用next方法时返回的就不是Object类型的元素，
                   而是Student类型的元素了。
                   */
                   while(it.hasNext()        )
                   {
                        //Student  stu=(Student)it.next()    ;  
                             Student  stu=it.next()    ; 
                             //这里就省去了类型转换的麻烦
            soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
                   }
         }
 
         public   static  void  soc(Object  obj)
         {
                System.out.println(obj);
         }
}
/*
以上代码编译运行结果：
名字---haha01---年龄---12
名字---haha02---年龄---19
名字---haha03---年龄---26
名字---haha04---年龄---15
名字---haha05---年龄---1
名字---haha06---年龄---16
名字---haha07---年龄---76
名字---haha08---年龄---17
名字---haha09---年龄---17
名字---haha06---年龄---16
 
*/

——————分割线——————

/*

关于泛型的一些知识点以及更多的关系应用：

    加了<>实际上就是限制了只能够接收<>内部所表示的类型的参数

*/

import java.util.*;
//Collection接口的体系放在Java.util包里面
class  Student      implements   Comparable//Comparable接口强制学生类的实例个体具备了比较性
 
{
    private  String  name  ;
          private    int   age;
         Student(String  name,int age)
         {
                this.name=name;
                      this.age=age;
 
         }
   public    int   compareTo(Object  obj)
         {
                  
              if( ! ( obj  instanceof  Student  ) )
                    {
                         throw new  RuntimeException("不是学生");          
                    }
                    Student  a=(Student)obj;
                    System.out.println("这是"+this.name+"和"+a.name+"比较");
        if( this.age>a.age    )
                    {
                          return 1;   
                    }
                    if(this.age==a.age)
                    {
                             //主要条件相同要判断次要条件
 
                          return this.name.compareTo(a.name);
                     }
 
                         return  -1;
 
         }
   public   String   getName()
         {
                 return  name;    
         }
   public   int   getAge()
         {
                 return  age;    
         }
 
 
}
class  Jihe18
{
         publicstatic void main(String[] args)
         {
       TreeSet<Student>   a=  new  TreeSet<Student>(new  Bijiao());//把比较器放进TreeSet构造函数中
                   a.add(new   Student("vdsfb1",12));
             a.add(new  Student("惹我02",19));
                   a.add(new   Student("吧03",26));
                   a.add(new   Student("haha04",15));
             a.add(new  Student("qwqwe5",1));
                   a.add(new   Student("ahs6",16));
                   a.add(new   Student("ibbf07",76));
                   a.add(new   Student("cuhn8",17));
       a.add(new  Student("kvjakn09",17));
                   a.add(new   Student("kvjakn09",16));
 
                   Iterator<Student>   it= a.iterator();
                  while( it.hasNext()        )
                   {
                        Student  stu=it.next()    ;  
            soc("名字---"+stu.getName()+"---年龄---"+stu.getAge());
                   }
         }
 
         public   static  void  soc(Object  obj)
         {
                System.out.println(obj);
         }
}
class   Bijiao   implements   Comparator<Student>
    //Comparator<Student>强制指定比较器只可以比较Student类型的元素
          //实际上也是Bijiao类实现了只能够接收Student类型参数的Comparator接口
 
{
           public  int   compare(Student  a,Student b)
           {
                 //Student   na=(Student)a;   
                       //Student  nb=(Student)b;
                            //以上两句话就可以省略了
                            int  num=a.getName().compareTo(b.getName());
                            //这里的compareTo方法是字符串本身就具备的方法，按照字典排列字符串
                            if(num==0)
                       {
                              // return  a.compareTo(b);   //按照元素本身具备的比较性进行比较
                              return new Integer(a.getAge()).compareTo(new Integer(b.getAge()));
                              //Integer类里面也定义了自己的compareTo方法，比较的是数字的大小
                            }
                            return  num;
           }     
}
/*
以上代码编译运行结果：
名字---ahs6---年龄---16
名字---cuhn8---年龄---17
名字---haha04---年龄---15
名字---ibbf07---年龄---76
名字---kvjakn09---年龄---16
名字---kvjakn09---年龄---17
名字---qwqwe5---年龄---1
名字---vdsfb1---年龄---12
名字---吧03---年龄---26
名字---惹我02---年龄---19
 
*/

——————分割线——————

 

/*

泛型在自定义类中的使用：

*/

class  Person<TTT>//这种类也被称之为泛型类，带着泛型的类
//表示接收由调用者定义的类型的参数
{
    private   TTT   a;
          public  void   seta(TTT  a )
          {
                 this.a=a;
          }
          public  TTT   geta()
          {
              return a;              
          }
}
class  Teacher
{
 
    private   String   name="张三";
            private  int   age=25;
         public   int  getAge()
         {
             return  age;          
         }
         public   String getName()
         {
                return name;       
         }
}
class  Student
{
 
          private  String   name="李四";
             private   int   age=13;
         public   int  getAge()
         {
             return  age;          
         }
         public   String getName()
         {
                return name;       
         }
}
 
class  Jihe19
{
         public  static void   main(String[] args) //主函数
         {
         method();
                  
         }
         public   static   void  method()
         {
                   soc("下面是method----------------");
            Person<Teacher>   a=new  Person<Teacher>();
                   //限制了接收的只能是Teacher类型的参数
                   a.seta(new  Teacher());
       soc(a.geta().getName());
 
 
       Person<Student>   b=new   Person<Student>();
                   //对于Person类的b来说，接收的只能够是Student类的参数
                   //与上面的没有冲突
        b.seta(new  Student());
       soc(b.geta().getName());           
         }
         public  static    void   soc(Object  obj)
         {
             System.out.println(obj);   
         }
}
/*
以上代码编译运行结果：
下面是method----------------
张三
李四
 
*/

——————分割线——————

 

/*

泛型可以用在类上，也可以用在方法上

泛型方法的应用

*/

 

class  Person   //注意此时的类名后面没有加泛型！！！
{
  public  <E> void     fanfa1(E  e)//这个就是泛型方法
   //这里的<>内的E只在这个方法内有效
  
   {
       System.out.println("这是fanfa1的e---"+e);
   }
  public  <E> void     fanfa2(E  e)//这个就是泛型方法
   //这里的<>内的E和fanfa1方法的E不是同一个E！！！
   {
       System.out.println("这是fanfa2的e---"+e);
   }
}
 
class   Student<E>  //注意这里加了<E>
{
         public    void   fanfa(E   e) //注意这里的void前面没有加<E>
         //fanfa方法中的E和 Student<E>的E是一样的！！！
         {
               System.out.println("这是fanfa的e---"+e);       
         }
   public  <E>void     fanfa1(E  e)//这个就是泛型方法，注意这里void前面加了<E>
   //fanfa1方法中的E和 Student<E>的E是不相同的！fanfa1方法中的E只在fanfa1内部有效
   {
       System.out.println("这是fanfa1的e---"+e);
   }
  public  <Q> void     fanfa2(Q  q)//这个就是泛型方法
   //这里的Q与Studnet<E>中的E是不一样的
   {
       System.out.println("这是fanfa2的q---"+q);
   }
 
   /*
  public  static  void    fanfa3(E   e)
   这里的E与Studnet<E>中的E是一样的,由于这里是静态方法，
   在对象建立之前就存在的，但是调用该方法需要建立对象时E对应的明确类型，
   所以这种写法编译出问题。为了解决这个问题，可以把泛型就定义在方法上
   */
   public  static  <R>void     fanfa3(R r)
         //这种写法才是正确的，而且泛型要放在返回值类型前！
         //public <R> static  void     fanfa3(R r)//这种写法是错误的
   {
        System.out.println("这是fanfa3的r---"+r);
   }
}
class  Jihe20
{
         public  static void  main(String[] args)
         {
       method();
                   method2();
 
         }
         public   static  void  method()
         {
                   soc("下面是menthod------");
                Person   per=new  Person();
                   per.fanfa1(new  Integer(25));
                   per.fanfa1(62);
                   per.fanfa1("hushu");
             per.fanfa2(new  Integer(25));
             per.fanfa2(62);
                   per.fanfa2("hushu");
                   soc("HelloWorld!");
         }
         public  static void  method2()
         {
              soc("下面是menthod2------");
                    Student<String>   stu=new Student<String>();
 
                    stu.fanfa("hfabf");//fanfa方法只能够接收String类型的参数
        //stu.fanfa(45);//这句话编译出问题
                    //stu.fanfa(new  Integer(25));//这句话编译出问题
 
 
                    stu.fanfa1("hfabf");
        stu.fanfa1(45);//这句话也是可以编译运行成功的
                    stu.fanfa1(new Integer(25));
 
                    stu.fanfa2(78);//这句话也是可以编译运行成功的
                    stu.fanfa2("rtct");
        stu.fanfa3("hfabf");//这句话也是可以编译运行成功的
 
         }
         public  static    void   soc(Object  obj)
         {
             System.out.println(obj);   
         }
}
/*
以上代码编译运行结果：
下面是menthod------
这是fanfa1的e---25
这是fanfa1的e---62
这是fanfa1的e---hushu
这是fanfa2的e---25
这是fanfa2的e---62
这是fanfa2的e---hushu
Hello World!
下面是menthod2------
这是fanfa的e---hfabf
这是fanfa1的e---hfabf
这是fanfa1的e---45
这是fanfa1的e---25
这是fanfa2的q---78
这是fanfa2的q---rtct
这是fanfa3的r---hfabf
 
*/

蓝莓浆糊饼干
关注
专栏目录
黑马程序员——java基础---集合（第15天）
chao100ge的博客
07-06 365
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流----- 一、Set Set:元素无序，不可以存放重复元素        |--HashSet：数据结构是哈希表。线程是非同步的。                             保证元素唯一性的原理：判断元素的hashCode值是否相同。
黑马程序员——集合
wupengyu2012的专栏
07-20 875
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------           一、Collection单列集合 (一)List接口的实现类 1、ArrayList (1)构造函数： ArrayList arr = new ArrayList();    //创建一个初始容量为10的空列表 Array
JavaSE进阶笔记-集合02(Set,TreeSet,二叉树)
SUIT THUG!的博客
07-14 266
1.泛型 1.1泛型概述【理解】 泛型的介绍 ​ 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制 泛型的好处 把运行时期的问题提前到了编译期间 避免了强制类型转换 泛型的定义格式 <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V> 1.2泛型类【应用】 定义格式 修饰符 class 类名&
TreeSet
weixin_40426261的博客
11-11 140
test01
集合框架_TreeSet保证元素唯一性和自然排序的原理和图解(二叉树结构)
辐_射的博客
01-07 1028
二叉树TreeSet类的使用原理和compareTo()方法
whaleluo的博客
05-10 2714
类 TreeSet public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable 基于 TreeMap 的 NavigableSet 实现。 使用元素的自然顺序对元素进行排序， 或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 
二叉树--TreeSet数据结构
baidu_37278726的博客
04-15 1539
TreeSet：底层数据结构是二叉树。 保证元素唯一性的依据，compareTo方法return  0。 判断元素和remove删除元素都是依据的compareTo返回的数值。 排序方式：让元素自身具备比较线，让元素实现Comparable接口，覆盖compareTo方法。 顺序是从小（-1）到大（1）排序得。 二叉树只认比较返回的是-1,0,1。-1往左边放，1往右边
黑马程序员——34，TreeSet与泛型
dangaodeaiyi的专栏
08-30 469
黑马程序员——34，TreeSet与泛型 旧博客整理归纳： 一：TreeSet----》         TreeSet集合的底层数据结构是二叉树结构，元素进入容器后会自动被排序，不可以存放重复元素，如果有重复元素，那么该重复元素会被剔除。 如果TreeSet集合内部存放的元素是字符串，那么内部排序的时候，会按照自然顺序把字符串逐位比较，然后排序，常见的有效顺序是：数字>大写字母>小写字母
黑马程序员———java 集合框架
lqf123lrf的专栏
10-11 266
java 集合框架 集合类 为什么出现集合类？   面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，  集合就是存储对象最常用的一种方式。  数组和集合类同是容器，有何不同？  数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集  合只能存储对象。而数组里存的都是指定类型的元素，而集合中可存放不同类型
集合泛型
WYJ____的博客
11-12 1069
1.集合的概述 2.Collection 3.List 4.Vertor 5.Stack 6.ArrayList 7.LinkedList 8.Set 9.HashSet 10.TreeSet 11.泛型 12.Map 13.HashMap 14.Hashtable 15.TreeMap 16.LinkedHashMap 一、集合的概述 1.集合的概念 ...
14.list和泛型集合
m0_53222768的博客
06-06 199
@一贤不穿小鞋 1.集合 动态存储多个引用数据类型的容器.(动态数组) 2.集合中常用概念: 有序:按照添加顺序来存值叫有序. 可排序性:按照一定的规则来排列(按数字由小到大或由大到小,按字典顺序). 唯一性:不可重复. 3.集合家族系谱图: 3.1:Collection:存储无序,可重复单一对象. 3.1.1:List:存储有序,可重复的单一对象. ArrayList:存储有序的,可重复的单一对象.底层采用Object[]结构存值. LinkedList:存储有序的,可重复的单一对象.底层采用
重温数据结构：平衡二叉树（AVL树）、红黑树、TreeSet与TreeMap
郑海波(莫川)的CSDN博客
04-09 4949
写作目的：本博客的目的是认识和复习数据结构中的平衡二叉树和红黑树，以及由红黑树实现的TreeSet和TreeMap1.二叉搜索树的弊端二叉搜索树的查找,插入,删除的复杂度等于树的高度，时间复杂度是O(log(n)).但是，对于同一组数据，插入顺序的不同，可能会导致二叉搜索树的高度不同。如果是有序插入，二叉搜索树退化成链表，其查找的时间复杂度退化为O(log(n)).图 插入顺序不同对二叉搜索树的影
TreeSet（二叉树）
weixin_30340617的博客
07-30 409
　　TreeSet()是使用二叉树的原理对新ADD()的对象按照指定的顺序排序（升序、降序），每增加一个对象都会进行排序，将对象插入二叉树指定的位置，在Integer和String对象都可以进行默认的TreeSet排序，而自定义的对象不可以，必须实现Comparable接口，并且覆写相应的compareTo()函数才可以正常的使用TreeSet()。注意：在覆写compare()函数时...
Java之TreeSet集合(二叉树实现)以及Comparable接口介绍
Daniel丶
10-22 2641
TreeSet 集合类是Set的子类 固有保持数据不重复的属性，除此之外还有一个独有的功能就是排序 当然常见的Integer，String类中java都将其比较机制写的很完善了 但对于自定义类而言 ，想要去排序就要自己去实现了 假设录入一个 Person类 (new Person(“aa”,100))其属性为姓名和年龄 假设要求我需要对集合中Person的年龄进行排序的话 我们该怎么办呢？ Tre...
黑马程序员—— 4,二维数组，面向对象，制作帮助文档，静态代码块，构造代码块，构造函数，单例设计模式
dangaodeaiyi的专栏
07-18 990
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------               黑马程序员——  4,二维数组，面向对象 二维数组 格式：int[][] a=newint[5][9];      二维数组名字a,其中有5个一维数组，      每个一维数组里面有9个元素      一维数组的名称分别为：a[0],a[1],a[2],a
黑马程序员——19，Collections工具类，Arrays工具类，高级for循环，可变参数，静态导入
dangaodeaiyi的专栏
08-07 931
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------                                黑马程序员——19，Collections工具类，Arrays工具类   /* Collections是一个类，注意，这里后面带有一个s 千万不要和Collection弄混了！Collection只是接口而已。 两者要区
黑马程序员——21，字符流FileReader,FileWriter,BufferedWriter,BufferedReader，装饰设计模式，LineNumberReader
dangaodeaiyi的专栏
08-09 915
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------                  黑马程序员——21，字符流FileReader,FileWriter,BufferedWriter,BufferedReader，装饰设计模式，LineNumberReader /* 字符流的缓冲区技术： 对于一些大文件，如果读取一个字符才写一个字符，
黑马程序员——22,字节流InputStream,OutputStream,字节流缓冲区技术,BufferedInputStream,BufferedOutputStream
dangaodeaiyi的专栏
08-09 915
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------                     黑马程序员——22,字节流InputStream,OutputStream,字节流缓冲区技术,BufferedInputStream,BufferedOutputStream   /* 字节流的相关讲解： InputStream(读操作),Ou
Java基础：集合框架详解- TreeSet、二叉树与泛型【13节视频】
课程共包含13节课，涵盖了关键知识点如TreeSet（有序集合）的原理与使用，以及二叉树在数据结构中的应用。此外，课程还着重介绍了Java中的泛型概念，这是面向对象编程中一个重要的特性，它有助于提高代码的类型安全...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值