• 黑马程序员——Java基础工具类---Collections、Arrays、超级for循环、静态导入、方法可变参数


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

                                Collections

    一、概述

            Collections是对集合框架的一个工具类。它里边的方法都是静态的,不需要创建对象。并未封装特有数据。

            在Collections工具类中大部分方法是用于对List集合进行操作的,如比较,二分查找,随机排序等。

    二、常见操作

    1、查找

            Tmax(Collection<? extends T> coll);//根据集合的自然顺序,获取coll集合中的最大元素

            Tmax(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序,获取coll集合中的最大元素

            intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象

    2、替换

            voidfill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj

            booleanreplaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值

            void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素

    3排序:

            void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序

            void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序

            voidsort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序

    4、反转

            reverse(List<?> list);//反转list集合中元素的顺序

            Comparator reverseOrder();//返回一个比较器,强行逆转了实现Comparable接口的对象的自然顺序

            ComparatorreverseOrder(Comparator<T> cmp);//返回一个比较器,强行逆转了指定比较器的顺序

    5、同步的集合

            List<T>synchronizedList(List<T> list);//返回支持的同步(线程安全的)List集合

            Map<K,V>synchronizedList(Map<K,V> m);//返回支持的同步(线程安全的)Map集合

    三、Collections和Collection的区别

            Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。

            它有两个常用的子接口:

                    List:对元素都有定义索引。有序的。可以重复元素。        

                    Set:不可以重复元素。无序

            Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序,二分查找等方法

           通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。

                                   Arrays

    一、概述

            Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。

           把数组变成List集合的好处:可以使用集合的思想和方法来操作数组中的元素。如:contains,get,indexOf,subList等方法。

    二、常见方法

    1、Lsit<T> asList(T... a);//将数组转换为集合

    注意:

            a、将数组转换成集合,不可使用集合的增删方法,因为数组的长度是固定的。如果进行增删操作,则会产生UnsupportedOperationException的编译异常。

            b、如果数组中的元素都是对象,则变成集合时,数组中的元素就直接转为集合中的元素。

            c、如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。

    2、binarySearch():二分查找方法,fill():替换方法,sort():排序方法等

           特点:可对数组元素进行相应操作,可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数,且还可以对指定元素的范围,并可根据指定比较器进行相应的操作。

           如:sort(T[]a,Comparator<? super T> c)

                    fill(int[]a,int from,int to)等

    3、String toString();//可以接收各种数组类型参数,并返回指定数组内容的字符串表现形式。

     1 /*
     2 Arrays: 用于操作数组的工具类
     3 里面都是静态方法
     4 
     5 
     6 int[]转字符串  Arrays.toString(arr);
     7 asList:将数组变成list集合
     8 List<String> list=Arrays.asList(arr);
     9 */
    10 import java.util.*;
    11 class ArraysDemo
    12 {
    13     public static void sop(Object obj)
    14     {
    15         System.out.println(obj);
    16 
    17     }
    18     public static void main(String[] args)
    19     {
    20         //int[] arr={2,4,5};
    21         //sop(Arrays.toString(arr));
    22         String[] arr = {"abc","cc","kkkk"};
    23         /*把数组变成list集合有什么好处?
    24         可以使用集合的思想和方法来操作数组中的元素。
    25 
    26         注意:将数组变成集合,不可以使用集合的增删方法。
    27         因为数组的长度是固定的。
    28             contains   
    29             get
    30             indexOf()
    31             subList()
    32             如果增删。那么会发生UnsupportedOperationException,
    33         */
    34         List<String> list=Arrays.asList(arr);
    35         sop("contains"+list.contains("cc"));//判断有无该成员元素
    36         //list.add("qq");//    UnsupportedOperationException
    37         sop(list);
    38         //int nums[]={2,4,5};//后面将会获取到地址值
    39         Integer nums[]={2,4,5};
    40         List<Integer> li=Arrays.asList(nums);
    41         sop(li);
    42 
    43         /*如果数组中的元素都是对象。那么变成集合时,
    44                 数组中的元素就直接转变成集合中的元素
    45             如果数组中的元素都是基本数据类型,
    46                 那么会将该数组作为集合中的元素存在
    47         */
    48 
    49     
    50     }
    51     public static boolean myCollections(String[]arr,String key)
    52     {
    53         for(int x=0;x<arr.length;x++)
    54         {
    55             if(arr[x].equals(key))
    56                 return true;
    57         }
    58             return false;
    59     }
    60 }

    三、集合变数组

            Collection接口中的toArray方法。

            <T> T[]toArray(T[] a);将集合变为指定类型的数组。

    1、指定类型的数组到底要定义多长呢?

            当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组。长度为集合的size。

             当指定类型的数组长度大于了集合的size,就不会新创建了数组。而是使用传递进来的数组。

             所以创建一个刚刚好的数组最优。

    2、为什么要将集合变数组?

             为了限定对元素的操作。不需要进行增删了。

    示例:

     1 import java.util.*;
     2 class  CollectionToArray
     3 {
     4     public static void main(String[] args) 
     5     {
     6         ArrayList<String> al = new ArrayList<String>();
     7 
     8         al.add("abc1");
     9         al.add("abc2");
    10         al.add("abc3");
    11         //将集合变为String数组
    12         String[] arr = al.toArray(new String[al.size()]);
    13         //利用Arrays操作数组的方法
    14         System.out.println(Arrays.toString(arr));
    15     }
    16 }

          

                              扩展知识---1.5版本新特性

    一、高级for

     1 /*
     2 高级for循环
     3 格式
     4 for(数据类型  变量名:被遍历的集合(collection)或者数组)
     5 {
     6 }
     7 
     8 对集合遍历。
     9 只能获取集合元素。但是不能对集合进行操作
    10 
    11 迭代器除了遍历,还可以进行remove集合中元素的动作
    12 
    13 如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作
    14 
    15 传统for和高级for有什么区别呢?
    16 高级for有一个局限性。必须有被遍历的目标。
    17 建议在遍历数组的时候,还是希望是使用传统for。因为传统for可以定义角标
    18 
    19 */
    20 import java.util.*;
    21 class ForEachDemo
    22 {
    23     public static void main(String[] args)
    24     {
    25         ArrayList<String> al=new ArrayList<String>();//创建集合
    26         al.add("abc1");
    27         al.add("abc2");
    28         al.add("abc3");
    29 
    30         for(String s:al)//超级for循环遍历
    31         {
    32             System.out.println(s);
    33         }
    34         System.out.println(al);
    35         /*
    36         Iterator<String>it=al.iterator();//调用集合迭代器
    37         while(it.hasNext())
    38         {
    39             System.out.println(it.next());
    40         }*/
    41         int[]arr={3,5,1};
    42         for(int x=0;x<arr.length;x++)//打印arr数组
    43         {
    44             System.out.println(arr[x]);
    45         }
    46         for(int i:arr)
    47         {
    48             System.out.println("i:"+i);
    49         }
    50         
    51         HashMap<Integer,String> hm=new HashMap<Integer,String>();//创建map集合
    52         
    53         hm.put(1,"a");
    54         hm.put(2,"b");
    55         hm.put(3,"c");
    56 
    57         Set<Integer>keySet=hm.keySet();//调用集合中的  迭代器
    58         for(Integer i:keySet)//超级for 循环遍历  keySet 集合中的元素
    59         {
    60             System.out.println(i+"::"+hm.get(i));
    61 
    62         }
    63         Set<Map.Entry<Integer,String>>entrySet=hm.entrySet();//将Map集合中的关系存入集合中
    64         for(Map.Entry<Integer,String>me: entrySet)//超级for 循环遍历
    65         {
    66             System.out.println(me.getKey()+"------"+me.getValue());
    67         }
    68 
    69     }
    70 }

    二、方法的可变参数

     1 /*
     2 JDK1.5版本出现的新特性。
     3 
     4 方法的可变参数。
     5 在使用时注意:可变参数一定要定义在参数列表最后面。
     6 
     7 */
     8 
     9 class  ParamMethodDemo
    10 {
    11     public static void main(String[] args) 
    12     {
    13         //show(3,4);
    14         /*
    15         //虽然少定义了多个方法。
    16         但是每次都要定义一个数组。作为实际参数。
    17 
    18         int[] arr = {3,4};
    19         show(arr);
    20 
    21         int[] arr1 = {2,3,4,5};
    22         show(arr1);
    23         */
    24 
    25         /*
    26          可变参数。
    27          其实就是上一中数组参数的简写形式。
    28          不用每一次都手动的建立数组对象。
    29          只要将要操作的元素作为参数传递即可
    30          隐式将这些参数封装成了数组
    31 
    32         */
    33         show("haha",2,3,4,5,6);
    34         //show(2,3,4,5,6,4,2,35,9,"heh");
    35         //show();
    36 
    37     }
    38     public static void show(String str,int... arr)
    39     {
    40         System.out.println(arr.length);
    41     }
    42     
    43 }

    三、静态导入

    1、写法:

            import staticjava.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。

            import staticjava.lang.System.*//导入了Ssytem类中所以静态成员。

           没加static导入的是类,加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如:Arrays.sort(数组);就可以直接写sort(数组);

     1 /*
     2 StaticImport   静态导入。
     3 
     4 当类名重名时,需要指定具体的包名。
     5 当方法重名时,指定具备所属的对象或者类。
     6 
     7 */
     8 import java.util.*;
     9 import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
    10 import static java.util.Collections.*;
    11 /*
    12 packa/Demo.class 
    13 packb/Demo.class
    14 
    15 import packa.*;
    16 import packb.*;
    17 */
    18 import static  java.lang.System.*;//导入了System类中所有静态成员
    19 class StaticImport//extends Object
    20 {
    21     public static void main(String[] args)
    22     {
    23         out.println("haha");//因为导入了System类中所有静态成员,所以可以省略System.in不写
    24         int arr[]={1,3,5};
    25 
    26         Arrays.sort(arr);
    27         int index= Arrays.binarySearch(arr,1);
    28         out.println(Arrays.toString(arr));
    29         System.out.println("Index="+index);
    30 
    31         ArrayList al=new ArrayList();
    32 
    33         al.add(1);
    34         al.add(3);
    35         al.add(2);
    36 
    37         out.println(al);
    38 
    39         sort(al);
    40         out.println(al);
    41     }
    42 }

    自我总结:

        java中的工具类,虽然不需要全部书写出原理,但查了API就一定要会用,而常用的则必定要记住。工具类方便了我们的使用。

  • 相关阅读:
    Lock接口与等待唤醒机制
    线程同步(线程安全处理Synchronized)与死锁
    关于线程安全的例子(电影票出售)
    线程池
    多线程
    commons-IO工具包
    打印流
    关于web的安全问题
    防止手机页面软键盘调出时布局被挤压
    css3新特性归总笔记
  • 原文地址:https://www.cnblogs.com/ktlshy/p/4716871.html
走看看 - 开发者的网上家园