黑马程序员----------Java基础------------Collections和Arrays

黑马程序员—Java基础—Collections和Arrays

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

一.Collections

类Collections是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

• Collections中常用的方法：

  • sort()排序方法
    函数定义：public static < T extends Comparable< ? super T > > void sort(List< T > list) ，根据元素的自然顺序对指定列表按升序进行排序。
    参数：要排序的列表。
    函数定义： public static < T > void sort(List< T > list,Comparator< ? super T > c)，根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较。
    参数：list-要排序的列表；c-确定列表顺序的比较器。

  • binarySearch()二分查找方法
    函数定义：public static < T > int binarySearch(List< ? extends Comparable< ? super T > > list,T key)
    使用二分搜索法搜索指定列表，以获得指定对象，在进行此方法调用前比较要将列表元素按照升序排序，否则结果不确定，此方法会执行O(n)次链接遍历和O(log n)次元素比较。
    参数: list-要搜索的链表，key-要搜索的键。

    函数定义： public static < T > int binarySearch(List< ? extends T > list, T key, Comparator< ? super T > c) 根据指定的比较器对列表进行升序排序。
    参数：list-要搜索的列表，key-要搜索的键，c-排序列表的比较器。

  • reverse()反转方法
    函数定义：public static void reverse(List< ? > list)，反转指定列表中元素的顺序，此方法以线性时间运行。
    参数：list-元素要被反转的列表。

  • shuffle()改组方法
    函数定义：public static void shuffle(List< ? > list)，使用默认随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的。
    参数：list-要改组的列表
    函数定义：public static void shuffle(List< ? > list,Random rnd),使用指定的随机源对指定列表进行置换。
    参数：list-要改组的列表，rnd-用来改组列表的随机源。

  • swap()交换方法
    函数定义：public static void swap(List< ? > list,int i，int j)，在指定列表的指定位置处交换元素。
    参数：list-进行元素交换的列表，i-要交换的一个元素的索引，j-要交换的另一个元素的索引。

  • fill()替换方法
    函数定义：public static < T > void fill(List< ? super T > list,T obj)，使用指定元素替换指定列表中的所有元素，线性时间运行。
    参数:list-使用指定元素填充的列表，obj-用来填充指定列表的元素。

  • copy()复制方法
    函数定义：public static < T > void copy(List< ? super T > dest,List< ? extends T > src)，将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引，目标列表的长度至少必须等于源列表。
    参数：dest-目标列表，src-源列表。

  • min()最小值法
    函数定义：public static < T extends Object & Comparable< ? super T > > T min(Collection< ? extends T > coll)，根据元素的自然顺序返回给定Collection的最小元素，Collection中的所有元素必须实现Comparable接口，此外，collection中的所有元素都必须是可相互比较的。
    参数：coll-将确定其最小元素的collection。
    函数定义：public static < T > T min(Collection< ? extends T > coll,Comparator< ? super T > comp),根据指定比较器产生的顺序，返回给定collection的最小元素。
    参数：coll-将确定其最小元素的collection，comp-用来确定最小元素的比较器。

  • max()最大值方法
    函数定义：public static < T extends Object & Comparable< ? super T > > T max(Collection< ? extends T > coll)，根据元素的自然顺序，返回给定collection的最大元素。
    参数：coll-将确定其最大元素的collection。
    函数定义：public static < T > T max(Collection< ?extends T > coll,Comparator< ? super T > comp)，根据指定比较器产生的顺序，返回给定collection的最大元素。
    参数：coll-将确定其最大元素的collection，comp-用来确定最大元素的比较器。

  • rotate()轮换方法
    函数定义：public static void rotate(List< ? > list，int distance)，根据指定的距离轮转指定列表中的元素。
    参数：list-要轮换的列表，distance-列表轮换的距离，可以使0、负数或者大于list.size()的数。

  • replaceAll()替换所有函数
    函数定义：public static < T > boolean replaceAll(List< T > list,T oldVal,T newVal)，使用另一个值替换列表总出现的所有的某一指定值。
    参数：list-在其中进行替换的列表；oldVal-将被替换的原值；newVal-替换oldVald的新值。

示例代码：

public class Hello {
public static void main(String[] args) {
        System.out.println("sort");
        List list=new ArrayList<Double>();
       double array[] = {112, 111, 23, 456, 231 };
        for (int i = 0; i < array.length; i++) {
            list.add(new Double(array[i]));
        }
        Collections.sort(list);//自然排序
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("shuffle");

        Collections.shuffle(list);//置换
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        Collections.sort(list);//自然排序
        System.out.println("reverse");
        Collections. reverse (list);//反转
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        Collections.sort(list);//自然排序
        System.out.println("copy");
        List li = new ArrayList();
        double arr[] = {1131,333};
        for(int j=0;j<arr.length;j++){
            li.add(new Double(arr[j]));
        }
        Collections.copy(list,li);//拷贝
        for (int i = 0; i <list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("min");
        System.out.println(Collections.min(list));//返回最小值
        System.out.println("max");
        System.out.println(Collections.max(list));//返回最大值
        System.out.println("rotate");
        Collections.rotate(list,-1);//循环
        for (int i = 0; i <list.size(); i++) {
            System.out.println( list.get(i));
        }
         System.out.println("binarySearch");
        Collections.sort(list);
        System.out.println(list);
        System.out.println(Collections.binarySearch(list, 333.0));//二分查找
    }
}

二.Arrays

Arrays:用于操作数组的工具类。里面都是静态方法。

• List asList(T… a)//返回一个受指定数组支持的固定大小的列表。
• List asList( 数组 ) //返回一个受指定数组支持的固定大小的列表。
  注意：转换的List不能进行增删操作
• int binarySearch(数组，key)//使用二分搜索法来搜索指定的数组，以获得指定元素的下标。
• int binarySearch(数组，int fromIndex, int toIndex,key) //使用二分搜索法来搜索指定的数组的范围，以获得指定元素的下标。
• int binarySearch(T[] a, T key, Comparator< ? super T > c) //使用指定的比较器 用二分搜索法来搜索指定数组，以获得指定对象。
• int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator< ? super T > c) //使用指定的比较器 用二分搜索法来搜索指定数组的范围，以获得指定对象。
• copyOf(数组, int newLength) //复制指定的数组，截取或用默认值填充（如有必要），以使副本具有指定的长度。
• copyOfRange(数组, int from, int to)//将指定数组的指定范围复制到一个新数组。
• boolean equals(数组1, 数组2)//如果两个指定的数组彼此相等，则返回 true。
• boolean Equals(数组1, 数组2)//如果两个指定的数组深层相等，则返回 true。
• fill(数组a , val) //将指定的类型的值分配给指定对应类型数组的每个元素。
• fill(数组a , int fromIndex, int toIndex, val)//将指定的类型的值分配给指定对应类型数组指定范围中的每个元素。
• sort(数组) // 对指定的类型数组按升序进行排序。
• sort(数组，int fromIndex, int toIndex)// 对指定的类型数组的指定范围按升序进行排序。
• String toString(boolean[] a) //返回指定数组内容的字符串表示形式。