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

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

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

一：Collections：----》

        Collections是一个类，注意，这里后面带有一个s。千万不要和Collection弄混了！Collection只是接口而已。这个类里面全部方法都是静态的，可以直接类名调用。这个工具类就是专门针对集合进行操作的工具类。

其中也有常用的方法：

public    static<T> boolean  addAll(Collection<? super T> c, T... elements)  //把指定元素添加到集合中

public    static<T> int   binarySearch(List<? extends Comparable<? super T>> list, T key)  //通过二分法寻找指定列表中的元素的位置

public    static<T> int   binarySearch(List<? extends T> list, T key,

Comparator<? super T> c)   //先用指定的比较器排序列表，再二分法寻找指定元素的位置，如果找不到返回负数，负号表示不存在，负号后面的数字是表示不影响元素排列顺序情况下合适的插入位置（Set集合内部有自己的排列方式，该方法主要用于List集合）
public    static<T> void copy(List<? super T> dest, List<? extends T> src)// 把src 源列表复制到dest目标列表

public    static <T> void fill(List<? super T> list, T obj)//使用是定元素替换指定列表中所有元素

public   static <T  extends Object & Comparable<? super  T>> T max(Collection<? extends T> coll)         //返回集合中最大值

public    static<T> boolean  replaceAll(List<T> list, T  oldVal, T newVal)     //把指定列表中的某个特定值替换成另外一个值

public   static  void  reverse(List<?> list)      //反转指定列表

public    static <T> Comparator<T> reverseOrder()    //强行逆转实现了 Comparable 接口的对象 collection 的自然顺序  

public    static <T> Comparator<T> reverseOrder(Comparator<T>   cmp)   //返回一个反转比较规则后的比较器

int  hashCode()   //返回哈希值

boolean    isEmpty()   //判断是否为空

public   static <T extends Comparable<? super T>> void sort(List<T> list) //排序

public  static <T>void  sort(List<T> list, Comparator<? super T> c)//按照指定比较器排序

public   static   void swap(List<?> list, int i, int j)//指定某列表中的两个位置的元素换位

二：Arrays----》

        Arrays类也是一个工具类针对数组操作的工具类。Arrays类里面的很多方法都是静态的。通过调用Arrays的asList方法可以使得数组变成列表集合，可以用几点需要注意的。

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方法直接打印数组元素                  
         }
        public  static void  soc(Object obj )//打印方法
         {
           System.out.println(obj );            
         }
}

既然有数组转换成集合，那么一定有集合转换成数组：

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

三：高级for循环----》

    

        高级for循环的格式如下：  

 

for(数据类型  变量：遍历对象)

{

       //内容…            

}

jdk1.5版本才出现的高级for循环，其中的变量就如同指针一样指向被遍历的元素。举一个例子：

      List<String>   s=new ArrayList<String>();
            s.add("hjk");
            s.add("yhdn");
            s.add("vgbda");
            s.add("tr");
            for(String a:  s)
            {
                //引用变量a指向s的元素
                 //自定义内容
            }

 

三：可变参数----》

        可变参数也是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，也可以是其他类型或者是自己定义的类型
         {
              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);                
         }
}

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