黑马程序员——集合框架类(Collections、Arrays)

——- android培训、java培训、期待与您交流！ ———-

1.1，Collections
Collections:集合框架的工具类，里面定义的都是静态方法。

1.2，Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。

Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

1.3，Collections常见操作
1，查找
max(list);//根据集合的自然顺序，获取集合中的最大元素
max(list,Comparator comp);//根据指定比较器comp的顺序，获取集合中的最大元素
intbinarySearch(list,Tkey);//二分法搜索list集合中的指定对象

2，替换
fill(list,obj);//将list集合中的全部元素替换成指定对象obj
replaceAll(lsit,oldVal,newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素

3，排序：
shuffle(list);//使用默认随机源对list集合中的元素进行随机排序
sort(list);//根据自然顺序对list集合中的元素进行排序
sort(lsit,Comparator c);//根据指定比较器c的排序方式对list集合进行排序

4，反转
reverse(list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自

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

顺序

5，同步的集合
synchronizedList(list);//返回支持的同步（线程安全的）List集合

示例：

import java.util.*;class  CollectionsDemo{    public static void main(String[] args)     {        sortDemo();    }    public static void binarySearchDemo()    {        List<String> list = new ArrayList<String>();        list.add("abcd");        list.add("aaa");        list.add("zz");        list.add("kkkkk");        list.add("qq");        list.add("z");        Collections.sort(list,new StrLenComparator());        sop(list);        //int index = Collections.binarySearch(list,"aaaa");        //int index = halfSearch(list,"cc");        int index = halfSearch2(list,"aaaa",new StrLenComparator());        sop("index="+index);    }    public static int halfSearch(List<String> list,String key)    {        int max,min,mid;        max = list.size()-1;        min = 0;        while(min<=max)        {            mid = (max+min)>>1;//  /2;            String str = list.get(mid);            int num = str.compareTo(key);            if(num>0)                max = mid -1;            else if(num<0)                min = mid + 1;            else                return mid;        }        return -min-1;    }    public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)    {        int max,min,mid;        max = list.size()-1;        min = 0;        while(min<=max)        {            mid = (max+min)>>1;//  /2;            String str = list.get(mid);            int num = cmp.compare(str,key);            if(num>0)                max = mid -1;            else if(num<0)                min = mid + 1;            else                return mid;        }        return -min-1;    }    public static void maxDemo()    {        List<String> list = new ArrayList<String>();        list.add("abcd");        list.add("aaa");        list.add("zz");        list.add("kkkkk");        list.add("qq");        list.add("z");        Collections.sort(list);        sop(list);        String max = Collections.max(list/*,new StrLenComparator()*/);        sop("max="+max);    }    public static void sortDemo()    {        List<String> list = new ArrayList<String>();        list.add("abcd");        list.add("aaa");        list.add("zz");        list.add("kkkkk");        list.add("qq");        list.add("z");        sop(list);        //Collections.sort(list);        Collections.sort(list,new StrLenComparator());        //Collections.swap(list,1,2);        sop(list);    }    public static void sop(Object obj)    {        System.out.println(obj);    }}class StrLenComparator implements Comparator<String>{    public int compare(String s1,String s2)    {        if(s1.length()>s2.length())            return 1;        if(s1.length()<s2.length())            return -1;        return s1.compareTo(s2);    }}/*class Student{}list.add(new Student());public static <T extends Comparable<? super T>> void sort(List<T> list){}*/

示例：

import java.util.*;class StrComparator implements Comparator<String>{    public int compare(String s1,String s2)    {        /*        int num = s1.compareTo(s2);        if(num>0)            return -1;        if( num<0)            return 1;        return num;        */        return s2.compareTo(s1);    }}class StrLenComparator implements Comparator<String>{    public int compare(String s1,String s2)    {        if(s1.length()>s2.length())            return 1;        if(s1.length()<s2.length())            return -1;        return s1.compareTo(s2);    }}class CollectionsDemo2 {    public static void main(String[] args)     {        shuffleDemo();    }    public static void shuffleDemo()    {        List<String> list = new ArrayList<String>();        list.add("abcd");        list.add("aaa");        list.add("zz");        list.add("kkkkk");        list.add("qq");        list.add("z");        sop(list);        Collections.shuffle(list);        sop(list);    }    public static void orderDemo()    {        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));        ts.add("abcde");        ts.add("aaa");        ts.add("k");        ts.add("cc");        Iterator it = ts.iterator();        while(it.hasNext())        {            System.out.println(it.next());        }    }    public static void replaceAllDemo()    {        List<String> list = new ArrayList<String>();        list.add("abcd");        list.add("aaa");        list.add("zz");        list.add("kkkkk");        sop(list);        Collections.replaceAll(list,"aaa","pp");        sop(list);        Collections.reverse(list);        sop(list);    }    /*    练习。fill方法可以将list集合中所有元素替换成指定元素。    ，将list集合中部分元素替换成指定元素。    */    public static void fillDemo()    {        List<String> list = new ArrayList<String>();        list.add("abcd");        list.add("aaa");        list.add("zz");        list.add("kkkkk");        sop(list);        Collections.fill(list,"pp");        sop(list);    }    public static void sop(Object obj)    {        System.out.println(obj);    }}

2.1，Arrays
Arrays:是用于操作数组的工具类,里边的方法也全是静态的。
把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，

get，indexOf，subList等方法。

2.1,Arrays的常见方法
1，asList()：将数组变成List集合
2，binarySearch()：二分查找方法
3，fill()：替换方法
4，sort()：排序方法
5，toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。

2.3，把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
contains()、get()、indexOf()、subList();

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定。如果你增删。那么会反生UnsupportedOperationException,

示例：

/*Arrays:用于操作数组的工具类。里面都是静态方法。asList:将数组变成list集合*/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集合有什么好处？        /*        可以使用集合的思想和方法来操作数组中的元素。        注意：将数组变成集合，不可以使用集合的增删方法。        因为数组的长度是固定。        contains。        get        indexOf()        subList();        如果你增删。那么会反生UnsupportedOperationException,        */        List<String> list = Arrays.asList(arr);        //sop("contains:"+list.contains("cc"));        //list.add("qq");//UnsupportedOperationException,        //sop(list);        //int[] nums = {2,4,5};        Integer[] nums = {2,4,5};        List<Integer> li = Arrays.asList(nums);        /*        如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。        如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。        */        sop(li);    }    public static boolean myContains(String[] arr,String key)    {        for(int x=0;x<arr.length; x++)        {            if(arr[x].equals(key))                return true;        }        return false;    }    public static void sop(Object obj)    {        System.out.println(obj);    }}

2.4，集合变数组：Collection接口中的toArray方法
1、指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

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

2、为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。

示例：

/*集合变数组。Collection接口中的toArray方法。*/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");        /*        1,指定类型的数组到底要定义多长呢？        当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。        当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。        所以创建一个刚刚好的数组最优。        2,为什么要将集合变数组？        为了限定对元素的操作。不需要进行增删了。        */        String[] arr = al.toArray(new String[al.size()]);        System.out.println(Arrays.toString(arr));    }}

3.1，高级for循环
1、格式：
for(数据类型变量名 :被遍历的集合（collection）或者数组)
｛

｝

2，高级for循环对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

3、传统for和高级for的区别：
高级for有一个局限性。必须有被遍历的目标（集合或数组）。
传统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);        }

4.1，方法的可变参数
JDK1.5版本出现的新特性
在使用时注意：可变参数一定要定义在参数列表最后面。

示例：

/*JDK1.5版本出现的新特性。方法的可变参数。在使用时注意：可变参数一定要定义在参数列表最后面。*/class  ParamMethodDemo{    public static void main(String[] args)     {        //show(3,4);        /*        //虽然少定义了多个方法。        但是每次都要定义一个数组。作为实际参数。        int[] arr = {3,4};        show(arr);        int[] arr1 = {2,3,4,5};        show(arr1);        */        /*        可变参数。        其实就是上一种数组参数的简写形式。        不用每一次都手动的建立数组对象。        只要将要操作的元素作为参数传递即可。        隐式将这些参数封装成了数组。        */        show("haha",2,3,4,5,6);        //show(2,3,4,5,6,4,2,35,9,"heh");        //show();    }    public static void show(String str,int... arr)    {        System.out.println(arr.length);    }    /*    public static void show(int[] arr)    {    }    */    /*    public static  void show(int a,int b)    {        System.out.println(a+","+b);    }    public static  void show(int a,int b,int c)    {}    */}

5.1，静态导入(StaticImport)
1，import staticjava.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。

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

——- android培训、java培训、期待与您交流！ ———-