黑马程序员——Java基础---集合（集合框架工具类：collections和Arrays）--第17天--第202-212集

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

第17天-第202-212集

学习视频下载地址链接：http://pan.baidu.com/s/1ntE8xnz 密码：tsf6

集合（集合框架工具类：collections和Arrays）:

第七讲       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集合进行排序，二分查找等方法

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

小练习：

 <span style="font-size:14px;">/*
 需求：使用Collections中的方法fill对List集合中的部分元素进行替换
 思路：1、将List集合中要替换的部分元素取出,并存入另一集合中
       2、将原集合中的要替换元素移除
       3、用fill将要替换的元素进行替换
       4、将取出的部分增加进集合
 */
 import java.util.*;
 class  FillTest
 {
     public static void main(String[] args)
     {
         List<String> list = new ArrayList<String>();

         list.add("abc");
         list.add("ab");
         list.add("abcd");
         list.add("a");
         list.add("abcde");

         try
         {
             fillSome(list,1,5,"shenma");
         }
         catch (InputException e)
         {
             System.out.println(e.toString());
         }
         System.out.println(list);
     }
     //替换部分元素方法
     public static void fillSome(List<String> list,int start,int end,String s)throws InputException
     {
         if(start>=end)
             throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start，则抛出异常

         //定义一个新集合
         List<String> li=new ArrayList<String>();

         //因为每移除一次，后面的元素就会补上，所以这里用y来控制次数
         for (int x=start,y=start;y<end ; y++)
         {
             li.add(list.get(x));//将需要替换的元素增加到新集合
             list.remove(x);//移除需要替换的元素
         }

         Collections.fill(li,s);//替换成需要的元素s

         list.addAll(start,li);//将替换的部分增加进原集合
     }

 }

 //自定义异常
 class InputException extends Exception
 {
     InputException(String Massage)
     {
         super(Massage);
     }
 }
 </span>

 

第八讲       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();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。

示例：

 <span style="font-size:14px;">import java.util.*;
 class  ArraysDemo
 {
     public static void main(String[] args)
     {
         int[] arr = {2,4,5};
         System.out.println(Arrays.toString(arr));//转换为字符串形式

         String[] arr = {"abc","cc","kkkk"};//字符串数组

         List<String> list = Arrays.asList(arr);
         sop("contains:"+list.contains("cc"));//判断是否存在"cc"这个元素

         Integer[] nums = {2,4,5};
         List<Integer> li = Arrays.asList(nums);
         sop("asList--Integer[]转集合:" + li);
     }

 //打印方法
     public static void sop(Object obj)
     {
         System.out.println(obj);
     }
 }
 </span>

三、集合变数组

        Collection接口中的toArray方法。

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

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

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

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

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

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

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

示例：

 <span style="font-size:14px;">import java.util.*;
 class  CollectionToArray
 {
     public static void main(String[] args)
     {
         ArrayList<String> al = new ArrayList<String>();

         al.add("abc1");
         al.add("abc2");
         al.add("abc3");
         //将集合变为String数组
         String[] arr = al.toArray(new String[al.size()]);
         //利用Arrays操作数组的方法
         System.out.println(Arrays.toString(arr));
     }
 }
 </span>

 

第九讲     扩展知识---1.5版本新特性

一、高级for

1、格式：

        for(数据类型变量名 :被遍历的集合（collection）或者数组) {执行语句}

2、说明

        a、对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。可以看作是迭代器的简写形式。

        b、迭代器除了遍历，还可以进行remove集合中元素的动作。如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。

3、传统for和高级for的区别：

        高级for有一个局限性。必须有被遍历的目标（集合或数组）。

        传统for遍历数组时有索引。

        建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

示例：

 <span style="font-size:14px;">import java.util.*;
 class For
 {
     public static void main(String[] args)
     {
         //定义一个ArrayList集合
         ArrayList<String> al = new ArrayList<String>();
         al.add("abc1");
         al.add("abc2");
         al.add("abc3");

         for(String s : al)
         {
             System.out.println(s);//用高级for遍历集合
         }

         //传统for与高级for遍历数组
         int[] arr = {3,5,1};

         for(int x=0; x<arr.length; x++)
         {
             System.out.println(arr[x]);
         }
         for(int i : arr)
         {
             System.out.println("i:"+i);
         }

         //定义一个HashMap集合
         HashMap<Integer,String> hm = new HashMap<Integer,String>();

         hm.put(1,"a");
         hm.put(2,"b");
         hm.put(3,"c");

         //keySet取出方式的高级for遍历
         Set<Integer> keySet = hm.keySet();
         for(Integer i : keySet)
         {
             System.out.println(i+"::"+hm.get(i));
         }

         //entrySet取出方式的高级for遍历
         for(Map.Entry<Integer,String> me : hm.entrySet())
         {
             System.out.println(me.getKey()+"------"+me.getValue());
         }

     }
 }
 </span>

 

二、方法的可变参数

        如果一个方法在参数列表中传入多个参数，个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。在JDK1.5版本后，就提供了一个新特性：可变参数。

        可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。

        在使用时注意：可变参数一定要定义在参数列表的最后面。

示例：

 <span style="font-size:14px;">class  ParamMethodDemo
 {
     public static void main(String[] args)
     {
         show("haha",2,3,4,5,6);
     }
     public static void show(String str,int... arr)//...就表示可变参数
     {
         System.out.println(arr.length);
     }
 }
 </span>

 

三、静态导入

1、写法：

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

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

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

2、注意：

        当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

       当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。

示例：

 <span style="font-size:14px;">import java.util.*;
 import static java.util.Arrays.*;
 import static java.lang.System.*;

 class  StaticImport //extends Object
 {
     public static void main(String[] args)
     {

         out.println("haha");//打印输出时就可以直接省略书写System.
         int[] arr = {3,1,5};

         sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.

         int index = binarySearch(arr,1);//半分查找也是一样可以省略
         out.println("Index="+index);

         //当没有指定继承时，所以类默认继承了Object，
        //因为toString方法都具备，所以为了区分，必须写上具体调用者
        out.println(Arrays.toString(arr));
     }
 }

 </span>

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------