黑马程序员——19，Collections工具类，Arrays工具类，高级for循环，可变参数，静态导入

最新推荐文章于 2020-07-22 14:22:59 发布

蓝莓浆糊饼干

最新推荐文章于 2020-07-22 14:22:59 发布

阅读量931

点赞数

分类专栏： Java学习笔记文章标签：黑马程序员

本文链接：https://blog.csdn.net/dangaodeaiyi/article/details/47337489

版权

Java学习笔记专栏收录该内容

40 篇文章 0 订阅

订阅专栏

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

黑马程序员——19，Collections工具类，Arrays工具类

Collections是一个类，注意，这里后面带有一个s

千万不要和Collection弄混了！Collection只是接口而已。

两者要区别开来。

Collections是一个工具类。

这个类里面全部方法都是静态的，可以直接类名调用。

什么时候用到这个工具类呢？

例如，List集合里面可以有重复元素，但是想要对这些元素排列的话，怎么办？

这个时候就要用到这个工具类了。

这个工具类就是专门针对集合进行操作的工具类。

例如这个工具类里面有一个定义好的静态方法sort

public static <T extend Comparable<? super T>> void sort(List<T> list)

调用的时候直接Collections.sort(li);

其中，li是List<Teacher>的实例，那么这就要求Teacher类的对象本身要具备比较性

还有一个常用的方法

public static <T>void sort(List<T>list, Comparator<? super T> c)

调用的时候直接Collections.sort(li,compa);

其中，li是List<Teacher>的实例,

而compa是实现了Comparator接口的子类的实例，

这个比较器操作的是Teacher类或者Teacher类的子类的对象。

那么这个时候，就会按照比较器的规则来对元素排序。

import  java.util.*;
class   Je
{
         public   static  void main(String[] args)
         {
         
         method(fh());
                     method2(fh());
                     method3(fh());
                   System.out.println("HelloWorld!");
         }
         public   static  List<String>   fh()
         {
             List<String>   biaoge=new  ArrayList<String>();  
              biaoge.add("bfuibag");
                    biaoge.add("ibu");
                    biaoge.add("ibu");//注意这里有重复元素
                    biaoge.add("uitweru");
              biaoge.add("fvgfiberbrt"); 
                    biaoge.add("zz");
        biaoge.add("juykui");
      
 
        soc("原本biaoge---"+biaoge);//先打印原本顺序的biaoge                   
        return    biaoge;
         }
         public   static  void  method(List<String>   biaoge)
         {
                   soc("下面是method------");
                    Collections.sort(biaoge);//按照元素的自然顺序排列
        soc("新排列biaoge---"+biaoge);
                    //接着再打印使用Collections.sort()方法排列好的biaoge
        //String类的对象字符串本身就具备比较性
                    //使用Collections.sort()进行排序，遇到了重复元素也不会剔除掉的
        
         }
   public  static   void  method2( List<String>  biaoge)
         {
             soc("下面是method2------");
                    Collections.sort(biaoge,new  Bijiao());//按照比较器比较排列
        soc("新排列biaoge---"+biaoge);
                    //这里即便是使用比较器比较，重复元素也不会被剔除       
         }
         public  static void  method3(List<String>  biaoge)
         {
                   //取得最大值
                soc("下面是method3------");
                      String max=Collections.max(biaoge);
                      //按照元素自然顺序取得最大值，注意并不是按照角标取最大值！
                      soc("max="+max); 
                      Collections.sort(biaoge);     
                      max=Collections.max(biaoge);
                      soc("max="+max);
                  max=Collections.max(biaoge,new  Bijiao());
                      //按照比较器取得最大值
                      soc("max="+max);
         
 
         }
 
 
         public   static  void  soc(Object   obj)
         {
              System.out.println(obj);            
         }
}
class  Bijiao   implements   Comparator<String>
{
   public   int     compare(String  s1,String s2)
         {
             if(s1.length()>s2.length())
                   {
                       return 1;      
                   }
             if(s1.length()==s2.length())
                   {
                        return s1.compareTo(s2);      
                   }
                      return  -1;      
         }
 
}
 
/*
 
以上代码编译运行结果；
原本biaoge---[bfuibag,ibu, ibu, uitweru, fvgfiberbrt, zz, juykui]
下面是method------
新排列biaoge---[bfuibag,fvgfiberbrt, ibu, ibu, juykui, uitweru, zz]
原本biaoge---[bfuibag,ibu, ibu, uitweru, fvgfiberbrt, zz, juykui]
下面是method2------
新排列biaoge---[zz, ibu,ibu, juykui, bfuibag, uitweru, fvgfiberbrt]
原本biaoge---[bfuibag,ibu, ibu, uitweru, fvgfiberbrt, zz, juykui]
下面是method3------
max=zz
max=zz
max=fvgfiberbrt
Hello World!
 
 
*/

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

/*
Collections中的常用方法的调用
*/
import  java.util.*;
class  Je2
{
         public   static   void   main(String[] args)
         {
        fillDemo(fh());
                    replaceAllDemo(fh());
                    reverseDemo(fh());
                    reverseOrderDemo();
                                                         
         }
   public  static  List<String>    fh()
         {
            List<String>   biaoge=new  ArrayList<String>();  
              biaoge.add("bfuibag");
                    biaoge.add("ibu");
                    biaoge.add("ibu");//注意这里有重复元素 
              biaoge.add("cfff"); 
                    biaoge.add("zz");
                    biaoge.add("rrr");
        biaoge.add("juykui"); 
                    return  biaoge;
         }
         public   static void  binarySearchDemo(List<String>  biaoge)
         {
               soc("下面是binarySearchDemo---");
 
                    Collections.sort(biaoge);//排序
        soc(biaoge);
                    
        int   jb= Collections.binarySearch(biaoge,"rrr") ;      
        //用折半查找法在biaoge中寻找"ddd"，返回对应的角标
                    soc("jb="+jb);
                    int  cz= Collections.binarySearch(biaoge,"rkk") ;
        soc("cz="+cz);//这句话打印的是cz=-6
       /*
                   用Collections.binarySearch()找不到列表中的元素时候,
       返回的一定是负数，负号表示不存在，之后的数值是如果
                   不影响元素排列顺序的话合适的插入位置。
                   Set集合有内部隐藏自己的排列方式，所以该方法是用于List集合的。
 
                   如果元素本身不具备比较性，可以加一个比较器，写法如下：
       int cz=Collections.binarySearch(biaoge,"rkk",biComparator) ; 
                   其中biComparator是实现了Comparator<String>接口
       */    
                             
         }
         public  static void fillDemo(List<String>  biaoge)
         {
               soc("下面是fillDemo---");
                     soc("原本的biaoge---"+biaoge);
                    Collections.fill(biaoge,"yyyyyy");//把所有元素替换成"yyyyyy"
                     soc(biaoge);
         }
         public  static  void replaceAllDemo(List<String>  biaoge)
         {
               soc("下面是replaceAllDemo---");
                     soc("原本的biaoge---"+biaoge);
         Collections.replaceAll(biaoge,"rrr","kkk");
                     //把rrr替换成了kkk，按照元素替换元素非常方便
                     soc(biaoge);                                   
         }
         public  static void reverseDemo(List<String>  biaoge)
         {
               soc("下面是reverseDemo---");
          soc("原本的biaoge---"+biaoge);
                     Collections.reverse(biaoge);//把List集合的元素翻转排列
         soc("reverse后的biaoge---"+biaoge);
                         
         }
         public  static   void      reverseOrderDemo()
         {
               soc("下面是reverseOrderDemo---");
                    TreeSet<String>   tg=new TreeSet<String>();
        tg.add("bfuibag");
                    tg.add("ibu");
                    tg.add("ibu");//注意这里有重复元素
              tg.add("cfff"); 
                    tg.add("zz");
                    tg.add("rrr");
        tg.add("juykui");
                    soc("下面是没有加Collections.reverseOrder()的TreeSet集合tg");
        soc(tg);
                    TreeSet<String>   ts=new TreeSet<String>(Collections.reverseOrder());
        ts.add("bfuibag");
                    ts.add("ibu");
                    ts.add("ibu");//注意这里有重复元素
              ts.add("cfff"); 
                    ts.add("zz");
                    ts.add("rrr");
        ts.add("juykui");
                   soc("下面是加了反向比较器后ts");
        soc(ts);
                    /*
                    Collections.reverseOrder()会返回一个反向比较器，这里打印出来的都是反向
                    还有一种用法举一个例子：
        TreeSet<String>  ts=new TreeSet<String>(Collections.reverseOrder(ggg));
                    其中ggg是本人随便取名的比较器，这个比较器有自己的规则，但是
        Collections.reverseOrder(ggg)把ggg的规则翻转了，那么传给new  TreeSet<String>的
                    规则就是翻转ggg比较规则之后的规则。
                    */
                           
         }
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);             
         }
}
/*
以上代码编译运行结果：
下面是fillDemo---
原本的biaoge---[bfuibag,ibu, ibu, cfff, zz, rrr, juykui]
[yyyyyy, yyyyyy, yyyyyy, yyyyyy, yyyyyy,yyyyyy, yyyyyy]
下面是replaceAllDemo---
原本的biaoge---[bfuibag,ibu, ibu, cfff, zz, rrr, juykui]
[bfuibag, ibu, ibu, cfff, zz, kkk, juykui]
下面是reverseDemo---
原本的biaoge---[bfuibag,ibu, ibu, cfff, zz, rrr, juykui]
reverse后的biaoge---[juykui, rrr, zz, cfff, ibu, ibu, bfuibag]
下面是reverseOrderDemo---
下面是没有加Collections.reverseOrder()的TreeSet集合tg
[bfuibag, cfff, ibu, juykui, rrr, zz]
下面是加了反向比较器后ts
[zz, rrr, juykui, ibu, cfff, bfuibag]
*/

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

/*
Collections工具类里面的一些常用方法
*/
import  java.util.*;
class  Je3
{
         public   static   void   main(String[] args)
         {
       swapDemo(fh());
       shuffleDemo(fh());
 
                                                         
         }
   public  static  List<String>    fh()
         {
            List<String>   biaoge=new  ArrayList<String>();  
              biaoge.add("bfuibag");
                    biaoge.add("ibu");
                    biaoge.add("ibu");//注意这里有重复元素 
              biaoge.add("cfff"); 
                    biaoge.add("zz");
                    biaoge.add("rrr");
        biaoge.add("juykui"); 
                    return   biaoge;
         }
         public   static void  swapDemo(List<String>  biaoge)
         {
               soc("下面是swapDemo---");
                     soc(biaoge);
                     Collections.swap(biaoge,3,4);
                     //换位操作，把第三位和第四位换一下位置
                     soc("换位后的biaoge---"+biaoge);
 
         }
         public  static void   shuffleDemo(List<String>   biaoge)
         {
                soc("下面是shuffleDemo---");
                      soc(biaoge);
          Collections.shuffle(biaoge); //把元素顺序打乱
                      soc(biaoge);
                         
         }
 
 
 
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);             
         }
}
/*
以上代码编译运行结果：
下面是swapDemo---
[bfuibag, ibu, ibu, cfff, zz, rrr, juykui]
换位后的biaoge---[bfuibag,ibu, ibu, zz, cfff, rrr, juykui]
下面是shuffleDemo---
[bfuibag, ibu, ibu, cfff, zz, rrr, juykui]
[rrr, juykui, ibu, cfff, ibu, zz, bfuibag]
*/

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

Arrays类也是一个工具类针对数组操作的工具类。

Arrays类里面的都是静态类。

import java.util.*;
class  Je4
{
         public   static  void   main(String[] args)
         {
                     toStringDemo();
         asListDemo();                   
         }
         public  static void  asListDemo()
         {
                    soc("下面是asListDemo---");
              String[]  s={"sdf","hjk","yuiio"};
                    List<String>  k= Arrays.asList(s);
                   //k.add("kiuh");
                    /*
                    把数组s转换成了List集合，
                    但是由数组转成集合后不能对其进行增加或者删减操作，否则运行时异常
                    因为数组长度已经是固定好的了。
                    这里的数组里面的元素时String型，就是对象。
                    当数组里面元素时对象的时候，调用这个方法就可以直接转成List集合。
                    */
                    soc("k---"+k);
 
        int[]   s2={12,36,14,45};
                    List k2=Arrays.asList(s2);
                    //此句等同于List<int[]> k2=Arrays.asList(s2);
                    soc("k2---"+k2);
                    /*
                    这里打印出来的是数组对应的哈希值,
                    如果数组中的元素为基本数据类型，
                    Arrays.asList()方法就会把整个数组作为一个元素存进List集合里面。
        */
 
                    Integer[]  s3={5,14,78,5,4};
                    //该数组元素是对象，注意分清。
                    List<Integer>   k3=Arrays.asList(s3);
                    soc("k3---"+k3);                                 
 
         }
 
         public  static void  toStringDemo()
         {
                     soc("下面是toStringDemo---");
               int[] x={12,85,4,74,32,46};                          
               soc(Arrays.toString(x));
                     //Arrays.toString(x)返回的是数组x的信息                   
         }
         public  static void  soc(Object  obj )
         {
            System.out.println(obj );             
         }
}
/*
以上代码编译运行结果：
下面是toStringDemo---
[12, 85, 4, 74, 32, 46]
下面是asListDemo---
k---[sdf, hjk, yuiio]
k2---[[I@659e0bfd]
k3---[5, 14, 78, 5, 4]
 
*/

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

/*
集合转成数组：
*/
import java.util.*;
class  Je5
{
         public   static  void  main(String[] args)
         {
        List<String>   s=new   ArrayList<String>(); 
                    s.add("sss01");
        s.add("sss02");
                    s.add("sss03");
                    s.add("sss04");
                    soc("s---"+s);
        String[]   z=   s.toArray(new  String[7]);  
                    /*
                    toArray()方法是Collection接口的方法。
                    如果没有new  String[7]就会运行时候报错，
                    因为to Array()方法返回的是Object类对象的数组。
                    加入new String[7]后会建立并且返回一个长度为7的String类型数组，
                    []里的长度过长就会填充null，如果长度过短就又会新建一个合适长度的数组。
                    为了节约资源，应该刚好填合适长度的。
                    例如在这道题中，应该这么写：
                    String[] z=s.toArray(new String[s.length()]);
                    集合转成数组之后就不能增加删减操作了。
                    这也是为了限制对元素的操作。
 
                    */
                    soc("z---"+Arrays.toString(z));
                    
         }
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);           
         }
 
}
/*
以上代码编译运行结果：
s---[sss01, sss02, sss03, sss04]
z---[sss01, sss02, sss03, sss04, null,null, null]
*/

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

高级for循环

for(数据类型变量名：被遍历的集合或者数组)

{

语句;

}

高级for循环是从jdk1.5版本出现的，底层调用了迭代器

高级for循环不能对角标进行操作，这也是其不足之处。

import java.util.*;
class Je6
{
         publicstatic void main(String[] args)
         {
      List<String>   s=new  ArrayList<String>();
            s.add("hjk");
            s.add("yhdn");
            s.add("vgbda");
            s.add("tr");
            for(String a:  s)
            {
            a="233";              
                  soc(a);               
            }
     soc(s);
     /*这一点要注意：
           a原本只是指向被遍历对象而已，即便a被赋值了，
           依旧没有改变被遍历对象里面的值。
      */     
 
      for(String  a:  s)
            {
                      soc(a);               
            }
     soc(s);
          
     Map<String,String> m=new  HashMap<String,String>() ;
           m.put("yu01","李四");
           m.put("yu12","小姐");
           m.put("yu3","大炮");
     m.put("yu45","红的");
          Set<Map.Entry<String,String>>    rt   =    m.entrySet();
           for( Map.Entry<String,String>  me:  m.entrySet() )
           {
                soc( "Key---" +me.getKey()+"   Value---"+me.getValue());         
           }
 
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj);                               
         }
}
/*
以上代码编译运行结果：
233
233
233
233
[hjk, yhdn, vgbda, tr]
hjk
yhdn
vgbda
tr
[hjk, yhdn, vgbda, tr]
Key---yu01    Value---李四
Key---yu12    Value---小姐
Key---yu45    Value---红的
Key---yu3   Value---大炮
*/

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

/*
 jdk1.5版本出现的新特性：
     可变参数
*/
import java.util.*;
class  Je7
{
         public   static  void   main(String[] args)
         {
       kk(12,45,75,62);  //隐形的把这些数字封装成数组
                   //kk2(455,58,"hjn");//这句话编译错误
                   /*
                   为什么第二句的kk2(455,58,"hjn");编译时候会出错呢？
                   因为使用可变参数的时候，已经自动把括号里面的数字包装成数组了，
                   后面的"hjn"则是不能够被装进int型的数组里面。
                  
                   */
                   kk3("hjk",56,84,24);
                   //这句话编译运行成功的，表明可变参数要定义在括号的最后面
         }
         public static void  kk(int...  a)
  //当然这里不仅仅只可以写int，也可以是其他类型例如String等等或者是自己定义的类型
         {
              System.out.println(a.length);                             
         }
         /*
         public   static void  kk2(int...  a,String)//这句话编译出错
         {
             System.out.println(a.length);                      
         }
         */
         public   static void  kk3(String  a,int... b)
         {
                System.out.println(b.length);                                                             
         }
 
}

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

/*
静态导入
*/
import java.util.*;
import static  java.util.Arrays.*;//导入Arrays类中所有的静态成员
import static  java.lang.System.*;//导入System类中所有静态成员
 
class  Je8
{
         public   static  void   main(String[] args)
         {
                   int[]  x={12,65,75,48};
                   //Arrays.sort(x);
                   sort(x);//把数组排序
                   /*
                   因为之前导入Arrays类中所有的静态成员,
                   所以Arrays.sort(x);的Arrays可以省略。
                   */
                   soc(Arrays.toString(x));
       /*
        soc(toString(x));//这句话编译不通过  
                    
                   虽然前面导入了Arrays类里面的静态成员都导入了，
                   但是toString()这个方法在Object类里面也有，
                   所有的类都是直接或者间接继承Object类，
                   对于这种不同包里面有同名方法，
                   如果不明确写出哪一个包或者哪一个类的方法，
                   编译会出错。
                   */
        
                   System.out.println("HelloWorld!");
        out.println("huhu");
         }
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);                 
         }
}