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

------<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---[[[email protected]]
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);
         }
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-25 23:10:23

黑马程序员——19,Collections工具类,Arrays工具类,高级for循环,可变参数,静态导入的相关文章

黑马程序员——java集合框架(Map和工具类)

1.Map体系下有三个子类: HashMap    底层是哈希表数据结构,可以存入null键和null值,不同步---TreeMap    底层是二叉树数据结构,线程同步,可以用于给map集合中的键进行排序 和Set很像,Set底层是Map  添加元素时,如果出现相同键,那么厚添加的值会覆盖原有键对应的值,并且put方法会返回被覆盖的值 2.map集合的两种取出方式:  (1) keySet():将map中所有的键存入到Set集合,因为set具备迭代器                 可以以迭代

黑马程序员——面向对象(一)概述、类与对象、继承、抽象类、接口、多态、内部类

一.面向对象概述 1.面向对象:是一个很抽象的概念,它相对面向过程而言,是一种程序设计的思想. 2.面向对象的特点: * 符合人们思考习惯的思想 * 可以将复杂的事情简单化 * 将程序员从执行者转换成了指挥者 * 完成需求时:只需要寻找具备所需功能的对象或者创建所需功能的对象即可,简化开发效率并提高对象的复用性. 3.面向对象的三个特征:封装(Encapsulation).继承(Inheritance).多态(Polymorphism). 二.类与对象 (一)类与对象之间的关系 1.类的定义:类

黑马程序员-IO流其他流与File类

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 1:其他的流 1: DataOutputStream ;多了一些操作基本数据类型的功能 DataInputStream:读取文件. 用DataOutputStream流写进去的数据,就用DataInputStream流来读取. 1 imp

黑马程序员(Java)----API之常用类(数组的高级操作、正则表达式)

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 4.7 Array的高级操作 4.7.1 排序 1.冒泡排序 相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处. import java.awt.image.BufferStrategy; public class ArrayDemo2 { public static void main(String[] args) { // 定义一个数组 int[] arr = { 24,

黑马程序员——Java基础---StringBuffer、Arrays、包装类

--Java培训.Android培训.iOS培训.UI培训.PHP培训.期待与您交流! -- 一.StringBuffer类和StringBuilder类 1. StringBuffer类是线程安全的可变字符序列 2. StringBuffer和String的区别 String是一个不可变的字符序列 StringBuffer是一个可变的字符序列 3.构造方法和方法 StringBuffer的构造方法: public StringBuffer():无参构造方法 public StringBuffe

黑马程序员_IOS开发_Objective-C学习笔记_类(对象)

1.面向对象编程基本介绍: 面向对象程序设计(英语:Object-oriented programming,缩写:OOP),指一种程序设计范型,同时也是一种程序开发的方法.对象指的是类的集合,类是对象的模板,它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的安全性.重用性.灵活性和扩展性. 2.面向对象与面向过程 面向过程就是分析出解决问题所需要的步骤,然后基于这些步骤用代码和函数把这些步骤一步一步实现. 面向对象是把构成问题事务分解成各个对象,然后各个对象分别对相关的程序功能做出处

黑马程序员-Java基础-面向对象—多态、Object类、内部类、异常

第一讲  多态 1.  定义 可以理解为事物存在的多种体现形态. 在java中,当函数的功能内容不确定时,可以将此方法定义为抽象方法,让其子类去实现.当子类对象不同时,调用同一个函数名,会执行不同的函数体,得到不同的结果,从而体现了多态性. 2.  多态的体现形式 父类的引用指向了自己的子类对象:Fu f = new Zi(): 父类的引用也可以接受自己的子类对象: 3.  多态的前提条件 必须是类与类之间有关系,要么继承,要么实现(接口): 函数之间存在覆盖(重写): 4.  多态的好处 大大

黑马程序员-JAVA学习之反射以及Class类的常用方法

--------android培训.java培训.期待与你交流!-------- Class类 Class 类的实例表示正在运行的 Java 应用程序中的类和接口.枚举是一种类,注释是一种接口.每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象.基本的 Java 类型(boolean.byte.char.short.int.long.float 和 double)和关键字 void 也表示为 Class 对象. Class 没有公共构造方法

黑马程序员--Java基础学习笔记【Object类、String类】

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- Object类 在Java类继承结构中,java.lang.Object类位于顶端. 所有类都直接或间接继承Object类. (接口不能继承Object类,接口中隐含定义了Object类的所有公共方法,但是全抽象) Object类型的引用变量可以指向任何类型对象. Object类成员方法 public String toString() { return getClass().getName(