黑马程序员——34，TreeSet与泛型

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

----------- android培训、java培训、java学习型技术博客、期待与您交流！------------  

黑马程序员——34，TreeSet与泛型

旧博客整理归纳：

一：TreeSet----》

        TreeSet集合的底层数据结构是二叉树结构，元素进入容器后会自动被排序，不可以存放重复元素，如果有重复元素，那么该重复元素会被剔除。

如果TreeSet集合内部存放的元素是字符串，那么内部排序的时候，会按照自然顺序把字符串逐位比较，然后排序，常见的有效顺序是：数字>大写字母>小写字母

TreeSet排序的原理是二叉树排序：（底层数据结构二叉树结构），所谓的二叉树，例如：就是第一个元素进去，第二个元素进去判断若是比第一个元素大则放在右下边，(返回正数)

         若是比第一个元素小则是放在左下边(返回负数)若是相同元素（返回0）则是被剔除掉。如此类推下去就会形成一个叉型树。

         不过，如果元素个数过多的话，进来的元素会挑二叉树中的某一个元素做比较：

 1，若是比那某个元素大则放在那某个元素的右下边，若是相等则是被剔除，

 2，若是比那某个元素小泽放在左下边，

3，但是如果比那某个元素右下边的元素都大就跳到那某个元素的上一层继续比较，就这样子，一步步确定自己在二叉树中的位置。

        也可以利用这个原理，让compareTo方法返回值固定为正数或者负数，使得添加的元素按照添加顺序排序了（正序或者倒序）。

         最后逐个输出的时候也是从最左边的开始按照二叉树顺序输出。

        当存放的对象是自定义类的实例的时候，怎么办？

        这个时候就需要用到Comparable接口，用例子演示：

import java.util.*;//导入相关包
class  Student      implements   Comparable//Comparable接口强制Student具备了比较性
 
{
          private  String  name  ;
          private    int  age;
         Student(String  name,int age)
         {
               this.name=name;
                this.age=age;
 
         }
         public    int  compareTo(Object  obj)  //覆盖Comparable类中的compareTo方法        
         {
                 
              if( ! ( obj  instanceof Student  ) )
                    {
                         thrownew  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;
         }
   public   String  getName()//获取名字的方法
         {
                 return  name;   
         }
   public   int  getAge()//获取年龄的方法
         {
                 return  age;   
         }
 
 
}
class   Xjhe4
{
         public  static 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();//注意类型转换 
                       sop("名字---"+stu.getName()+"---年龄---"+stu.getAge());
                   }
         }
 
         public   static void  sop(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方法。

        如果一个类实现了Comparator类，那么该类就是一个比较器类，  该类的实例对象就是一个比较器。我们在写自定义类的时候可以另外写一个类实现这个Comparator接口 ，并且覆盖compare方法，该类就是一个比较器类，新建一个该类的对象，该对象就是一个可用的比较器。

        比较器可以放进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  ) )
                    {
                         thrownew  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
{
         Public  static   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
 
*/

        另外一道题目：按照字符串长度排序，因为字符串自己已经有了自然比较性，所以用比较器来比较。这种题目值得注意的就是比较器类的编写。      

  

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;
 
                      }
 
 
}

         我们可以从结果观察到在比较器中当a大于b时返回1，相同时比较次要条件，否则返回-1，现在得到的排序是从短的排到长的，那么我们可以把1和-1的位置调换，就得到从长到短的排序。但是在代码内部修改很麻烦，所以在此又做了一些改进。

  

 import  java.util.*;//导入相关包
class Xjhe5
{
        public  static void main(String[]args)
        {
                   TreeSet   a=new TreeSet(new  Cdbijiao(-12));
                   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   //建立比较类
{
         private    int  shuzi=0;
         Cdbijiao(int   shuzi)
         {
              this.shuzi=shuzi;   //由用户设定                  
         }
         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  shuzi;   
                            }
 
                            return -1*shuzi;//取相反数
                                                                 /*
                                   shuzi为正数，结果就是从短到长排序，shuzi为负数就是从长到短排序。
                            */  
                      }
 
 
}

 

二：泛型----》

        泛型：jdk1.5版本之后出现的特性，一种安全机制。把运行时出现问题ClassCastException转到编译时期：

        例如原本是这样定义的：ArrayList    a=new  ArrayList();但是添加元素时候既添加了String型的元素，又添加了int型的基本数据，这种情况下编译不会弹出错误，但是运行时候就会出问题，在实际开发中开发出来的产品给客户使用就会出问题。

        泛型就是限定了可以操作数据的类型，以下有例题说明：

importjava.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
 
*/

        另外还有一些关于泛型的知识点：更加确切的说，<>里面就是定义了需要操作的引用数据类型

        Comparator也可以使用泛型，例如前面的比较器类的泛型改写：

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;
                 //这里的类型转换就可以省略了
                 //其他内容…
           }
}

       Comparable接口也可以有泛型，但是，这里需要非常注意：并不是说用了泛型之后就可以省略类型转换了，如果是遇到hashCode和equals这些复写Object类的方法，接收过来的参数类型都是Object的，就要用到类型转换了，因为Object类中没有泛型。

        当需要操作的引用数据类型不确定时候就使用泛型类或者泛型方法。

泛型类：

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()
         {
                returnname;      
         }
}
class  Student      /*学生类*/         
{
 
          private  String  name="李四";
             private   int  age=13;
         public   int getAge()
         {
             return  age;         
         }
         public   String getName()
         {
                returnname;      
         }
}
 
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     study(E e)//这个就是泛型方法
   //这里<E>的E只在这个方法内有效
 
   {
      System.out.println("Person类study---"+e);
   }
  public  <E> void     sleep(E e)//这个就是泛型方法
   // sleep方法的E和study方法的E不是同一个E！！！
   {
      System.out.println("Person类sleep---"+e);
   }
}
   class    Fxin2
{
         public  static void main(String[] args)
         {
                   soc("下面是menthod------");
                   Person   per=new Person();
                  per.study(new  Integer(25));
                  per.study(62);
                  per.study("hushu");
                  //此时study和sleep接收的参数各不干扰
                   per.sleep(new  Integer(27));
                  per.sleep(67);
                  per.sleep("人民");
                  per.sleep(new  int[]{12,30,5});
 
         }
 
         public  static   void   soc(Object  obj)//打印方法
         {
             System.out.println(obj);  
         }
}

        如果泛型类里面还有泛型方法，也会有一些小知识点需要注意的：

class   Student<E>  //注意这里加了<E>
{
   public    void  drink(E   e) //注意这里的void前面没有加<E>
   //drink方法中的E和 Student<E>的E是一样的
   {
      System.out.println("drink---"+e);      
   }
   public  <E>void     run(E e)//这个就是泛型方法，注意这里void前面加了<E>
   //run方法中的E和 Student<E>的E是不相同的！run方法中的E只在run内部有效
   {
      System.out.println("run---"+e);
   }
  public  <Q> void     eat(Q q)//这个就是泛型方法
   //这里的Q与Studnet<E>中的E是不一样的
   {
      System.out.println("eat---"+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)
         {
                   method2();
 
         }
         public  static void method2()
         {
                   soc("下面是menthod2------");
                   Student<String>   stu=newStudent<String>();//只能够接收String类型
 
                   stu.drink("hfabf");//drink方法只能够接收String类型的参数
                   //stu.drink(45);//这句话编译出问题
                   //stu.drink(new  Integer(25));//这句话编译出问题
 
                   //以下都可以编译运行成功
                   stu.run("hfabf");
                   stu.run(45);
                   stu.run(new Integer(25));
                  //以下都可以编译运行成功   
                   stu.eat(78);
                   stu.eat("rtct");
                   stu.fanfa3("hfabf");
 
         }
         public  static   void   soc(Object  obj)
         {
            System.out.println(obj);  
         }
}


----------- android培训、java培训、java学习型技术博客、期待与您交流！------------

蓝莓浆糊饼干
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员Javase笔记
01-18
Java是世界上最流行的编程语言之一，尤其在...总结来说，"黑马程序员Javase笔记"涵盖了Java的基础语法、内存管理、面向对象编程、集合框架以及泛型和Map等内容，这些都是成为一名合格Java开发者必须掌握的核心知识。
集合与泛型
01-12
### 集合与泛型知识点总结 #### 泛型概览 - **引入原因**：在Java 1.5及之后的版本中，引入了泛型这一特性，旨在提高集合类使用的安全性与灵活性。主要解决的问题包括： - **元素存储的安全性问题**：在非泛型...
java创建TreeSet泛型集合_TreeSet集合中的 泛型限定 super 问题
weixin_42516119的博客
03-01 150
该楼层疑似违规已被系统折叠隐藏此楼查看此楼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...
黑马程序员——java基础之泛型
back
01-04 512
——- android培训、java培训、期待与您交流！ ———- 泛型一 初识泛型泛型:JDK1.5版本以后出现的新特性,用于解决安全问题 是一个类型安全机制 - JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。 - 泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类
黑马程序员——集合（中）——TreeSet、泛型
a378983320的博客
08-17 299
——- android培训、java培训、期待与您交流！ ———- 1.1，TreeSet TreeSet:可以对Set集合中的元素进行排序。 底层数据结构是二叉树。 保证元素唯一性的依据： compareTo方法return 0.1.2，TreeSet排序的两种方式 1，第一种方式：自然顺序 让元素
黑马程序员——其他5：泛型
axr1985lazy的专栏
02-15 2017
------- android培训、java培训、期待与您交流！ ---------- 1.     概述 1.1 问题的引出        我们在前面的内容中主要介绍了ArrayList、LinkedList、HashSet和TreeSet集合类及其使用方法、特点及底层数据结构等内容。下面我们主要以ArrayList为例，通过下面的代码来引出本篇博客的主题——泛型。这里需要声明一点，泛
黑马程序员——Java基础—泛型
qq_22909255的专栏
01-11 305
泛型 Generic： 在JDK1.5版本之后出现的新特性。是一个类型安全机制，用于解决安全问题。 泛型的好处： 1.将运行时期出现的问题ClassCastException转移到了编译时期，方便程序员解决问题，减少运行时期的问题，提高了安全性。 2.避免了强制转换的麻烦。 泛型的格式：通过 泛型通常在集合框架中很常见，在使用java提供的对象时，只要见到是用来接收类型的。 当使用集
黑马程序员————Java5的泛型（第八篇）
让风继续吹
08-14 352
一、泛型概述 二、泛型的使用 三、泛型类
黑马程序员——java中的泛型
xyyancsd的专栏
02-16 430
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 1.      什么是泛型： 泛型本质上是提供类型的"类型参数"，也被称为参数化类型（parameterizedtype）或参量多态（parametric polymorphism）。 泛型是JDK 1.5的新特性，可以用在类、
黑马程序员——Java基础——泛型类、包装类
dillinger_liu的专栏
06-16 412
泛型集合框架_泛型概述**泛型：**JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制 好处： 1. 将运行时期出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题。让运行事情问题减少，安全 2. 避免了强制转换的麻烦集合框架_泛型的使用泛型格式：通过<>来定义要操作的引用数据类型集合框架_泛型类当类中要操作的引用数据类型不确定的时候，早期
黑马程序员——第15天——（API）集合框架（TreeSet，泛型）
lgl092389的专栏
01-09 556
Set:无序，不可以重复元素。 |--HashSet：数据结构是哈希表。线程是非同步的。 保证元素唯一性的原理：判断元素的hashcode值是否相同。 如果相同，还会继续判断元素的equals方法，是否为true. |--TreeSet: 可以对Set集合中的元素进行排序。 底层数据结构是二叉树。 保证元素唯一性的依据： compareTo方法return 0。
第14章元素增删检索——集合与泛型.ppt
01-08
《第14章元素增删检索——集合与泛型》主要涵盖了Java编程中关于集合框架和泛型的重要概念，这是理解和高效使用Java集合类库的关键。以下是对这些知识点的详细阐述： 1. **集合框架与泛型**： - 集合框架是一套...
Java-集合的例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
本资料包是黑马程序员提供的详细教程，涵盖了Java集合的例题、源码以及配套的PPT教学文档，旨在帮助学习者深入理解和掌握Java集合的使用。 首先，我们来探讨Java集合框架的基本概念。Java集合框架包括接口和实现类...
黑马程序员入学Java精华总结
11-07
### 黑马程序员入学Java精华总结 #### 一、Java概述与基础知识 1. **何为编程？** - 编程是指通过编写计算机能够理解的指令来解决问题或完成特定任务的过程。这些指令通常被组织成算法，并使用某种编程语言实现。...
黑马程序员—— 4,二维数组，面向对象，制作帮助文档，静态代码块，构造代码块，构造函数，单例设计模式
dangaodeaiyi的专栏
07-18 963
------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 928
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------                                黑马程序员——19，Collections工具类，Arrays工具类   /* Collections是一个类，注意，这里后面带有一个s 千万不要和Collection弄混了！Collection只是接口而已。 两者要区
黑马程序员——22,字节流InputStream,OutputStream,字节流缓冲区技术,BufferedInputStream,BufferedOutputStream
dangaodeaiyi的专栏
08-09 912
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------                     黑马程序员——22,字节流InputStream,OutputStream,字节流缓冲区技术,BufferedInputStream,BufferedOutputStream   /* 字节流的相关讲解： InputStream(读操作),Ou
黑马程序员——21，字符流FileReader,FileWriter,BufferedWriter,BufferedReader，装饰设计模式，LineNumberReader
dangaodeaiyi的专栏
08-09 908
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------                  黑马程序员——21，字符流FileReader,FileWriter,BufferedWriter,BufferedReader，装饰设计模式，LineNumberReader /* 字符流的缓冲区技术： 对于一些大文件，如果读取一个字符才写一个字符，
Java集合类与泛型程序设计详解
"第8章 集合类与泛型程序设计" 在Java编程中，集合类和泛型是核心的工具，它们极大地提升了代码的灵活性和可维护性。本章将深入探讨这两个主题，主要涵盖了以下几个方面： 1. **Java中的集合类结构** Java集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值