Java：集合框架的工具类

集合框架的工具类

Arrays:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

包括：

1、asList将数组变成list集合：

static <T> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表。

//例子1：

import java.util.*;
class ArraysTest
{
    public static void sop(Object obj)
    {
      System.out.println(obj);
    }
    public static void main(String[] args)
    {
      BasicTypetolist();
      ObjecttoList();
      tostring();
    }

    public static void tostring()
    {
       String[] str = {"aaa","bc","kkkk","qq"};

       //字符串形式返回数组内容
       sop(Arrays.toString(str));
    }

    public static void BasicTypetolist()
    {
       int[] nums = {4,8,9,10};
       List<int[]> list = Arrays.asList(nums);
       sop(list);
       /*
        数组中的元素如果是对象，那么数组变成集合后，数组中的元素就直接变为集合中的元素存在；
        数组中的元素如果是基本数据类型，那么数组变成集合后，数组就直接变为集合中的元素存在；
       */
       //Integer[] inte = {4,8,9,10};
       //List<Integer> list = Arrays.asList(inte);
       //sop(list);
    }

    public static void ObjecttoList()
    {
       String[] str = {"aaa","bc","kkkk","qq"};

       //将字符数组转换为集合
       /*
         好处：可以使用集合中的思想来操作数组。
         注意：将数组变成集合，不可以使用集合的增删操作方法.因为数组的长度是固定的。
               如果进行增删操作，就会产生不支持操作异常...
       */
       List<String> list =  Arrays.asList(str);
       sop("contains:"+list.contains("qq"));

      // sop(list.add("zz"));//UnsupportedOperationException
       sop(list);
    }
}

2、二分方查找：

基本数据类型：byte、short、int、double、float、long、char

static int binarySearch(基本数据类型[] a, 基本数据类型 key)

使用二分搜索法来搜索指定的基本数据类型数组类型数组，以获得指定的值。

static int binarySearch(基本数据类型[] a, int fromIndex, int toIndex, 基本数据类型 key)

使用二分搜索法来搜索指定的基本数据类型数组类型数组的范围，以获得指定的值。

static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)

使用二分搜索法来搜索指定数组的范围，以获得指定对象。

static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)

使用二分搜索法来搜索指定数组的范围，以获得指定对象。

static <T> int  binarySearch(T[] a, T key, Comparator<? super T> c)

使用二分搜索法来搜索指定数组，以获得指定对象。

//例子2：

import java.util.*;
class CollectionsbinarySearch
{
    public static void main(String[] args)
    {
       binarySearchdemo1();
       binarySearchdemo2();
    }
    public static void binarySearchdemo1()
    {
       List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("z");
       list.add("cdefg");
       list.add("kkkkkkk");
       list.add("qq");
       sop("list:"+list);
       Collections.sort(list);
       sop("list:"+list);

       //使用二分搜索法搜索指定列表，以获得指定对象。
       sop("index="+Collections.binarySearch(list,"z")+"\n");
    }

    public static void binarySearchdemo2()
    {
       List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("z");
       list.add("cdefg");
       list.add("kkkkkkk");
       list.add("qq");
       sop("list:"+list);
       Collections.sort(list,new Mycomparator());
       sop("list:"+list);

       //使用二分搜索法搜索指定列表，(按照比较器)以获得指定对象。
       sop("index="+Collections.binarySearch(list,"z",new Mycomparator()));

    }

    public static<T> void sop(T t)
    {
        System.out.println(t);
    }
}

class Mycomparator implements Comparator<String>  ////定义一个比较器
{
    public int compare(String str1,String str2)
    {
       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
       return num==0? str1.compareTo(str2):num;
    }
} 

3、复制指定的数组：

基本数据类型：boolean、byte、short、int、double、float、long、char

static 基本数据类型[] copyOf(基本数据类型[] original, int newLength)

复制指定的数组，截取或用 0或false或null填充（如有必要），以使副本具有指定的长度。

static <T> T[]  copyOf(T[] original, int newLength)

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

4、将指定原数组范围复制到新数组 ：

基本数据类型：boolean、byte、short、int、double、float、long、char

static 基本数据类型[] copyOfRange(基本数据类型[] original, int from, int to)

将指定数组的指定范围复制到一个新数组。

static <T> T[] copyOfRange(T[] original, int from, int to)

将指定数组的指定范围复制到一个新数组。

static <T,U> T[]  copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)

将指定数组的指定范围复制到一个新数组。

5、比较两个数组中的内容是否相同。

基本数据类型：boolean、byte、short、int、double、float、long、char

static boolean equals(基本数据类型[] a, 基本数据类型[] a2)

如果两个指定的基本数据类型数组彼此相等，则返回 true。

static boolean deepEquals(Object[] a1, Object[] a2)

如果两个指定数组彼此是深层相等 的，则返回 true。

6、返回数组的哈希值。

基本数据类型：boolean、byte、short、int、double、float、long、char

static int hashCode(基本数据类型[] a)

基于指定数组的内容返回哈希码。

static int deepHashCode(Object[] a)

基于指定数组的“深层内容”返回哈希码。

7、以字符串形式返回数组内容。

基本数据类型：boolean、byte、short、int、double、float、long、char

static String toString(基本数据类型[] a)

返回指定数组内容的字符串表示形式。

static String toString(Object[] a)

返回指定数组内容的字符串表示形式。

static String deepToString(Object[] a)

返回指定数组“深层内容”的字符串表示形式。

//例子7：

import java.util.*;
class CollectionToArray
{
    public static<T> void sop(T t)
    {
      System.out.println(t);
    }
    public static void main(String[] args)
    {
        colletiontoarray();
    }
    public static void colletiontoarray()
    {
      ArrayList<String> al = new ArrayList<String>();

      al.add("abc");
      al.add("bcd");
      al.add("kef");
      /*
      1、 指定类型的数组到底要多长呢？
          当指定类型的数组长度小于集合的Size，那么该方法内部会创建一个新的数组，长度为集合的size
          当指定类型的数组长度大于集合的Size，就不会再创建新数组。而是直接使用传递进来的数组。
          所以创建一个刚刚好的数组长度最好。即  集合.size()。

      2、 为什么要将集合变成数组呢？
          为了限制对集合中的元素进行操作。不需要再进行增删了。
      */

      String[] str1 = al.toArray(new String[0]);
      sop(Arrays.toString(str1));//结果是：[abc,bcd,kef]

      String[] str2 = al.toArray(new String[5]);
      sop(Arrays.toString(str2));//结果是：[abc,bcd,kef,null,null]

      String[] str3 = al.toArray(new String[al.size()]);
      sop(Arrays.toString(str3));//结果是：[abc,bcd,kef]
    }
}

8、用内容替换数组指定索引的内容、反转、替换  、交换

基本数据类型：boolean、byte、short、int、double、float、long、char

static void fill(基本数据类型[] a, int fromIndex, int toIndex, 基本数据类型 val)

将指定的基本数据类型值分配给指定基本数据类型数组指定范围中的每个元素。

static void fill(基本数据类型[] a, 基本数据类型 val)

将指定的基本数据类型值分配给指定基本数据类型数组的每个元素。

static void fill(Object[] a, int fromIndex, int toIndex, Object val)

将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。

static void fill(Object[] a, Object val)

将指定的 Object 引用分配给指定 Object 数组的每个元素。

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

使用另一个值替换列表中出现的所有某一指定值。

static void reverse(List<?> list)

反转指定列表中元素的顺序。

static void swap(List<?> list, int i, int j)

在指定列表的指定位置处交换元素。

//例子8：

import java.util.*;
class CollectionsFillReverseReplace
{
    public static void sop(Object obj)
    {
       System.out.println(obj);
    }
    public static void main(String[] args)
    {
        filldemo();
        replaceAlldemo();
        reversedemo();
    }
    public static void filldemo()
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        sop("list:"+list);

       //使用指定元素替换指定列表中的所有元素。
       Collections.fill(list,"pp");
       sop("list:"+list+"\n");
    }

    public static void replaceAlldemo()
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("zz");
        list.add("kkkkk");
        sop("list:"+list);

      //使用另一个值替换列表中出现的所有某一指定值。
        sop(Collections.replaceAll(list,"zz","yy"));
        sop("list:"+list+"\n");
    }

    public static void reversedemo()
    {
        List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("zz");
       list.add("kkkkk");
       sop("list:"+list);

       //反转指定列表中元素的顺序。
       Collections.reverse(list);
       sop("list:"+list);
    }

    public static void swapdemo()
    {
        List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("zz");
       list.add("kkkkk");
       sop("list:"+list);

       //在指定列表的指定位置处(0和3位置处元素交换)交换元素。
       Collections.swap(list,0,3);
       sop("list:"+list);
    }

}

9、排序：

基本数据类型：byte、short、int、double、float、long、char

static void sort(Object[] a)

根据元素的自然顺序对指定对象数组按升序进行排序。

static void sort(Object[] a, int fromIndex, int toIndex)

根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。

static void sort(基本数据类型[] a)

对指定的基本数据类型数组按数字升序进行排序。

static void sort(基本数据类型[] a, int fromIndex, int toIndex)

对指定基本数据类型数组的指定范围按数字升序进行排序。

static <T> void  sort(T[] a, Comparator<? super T> c)

根据指定比较器产生的顺序对指定对象数组进行排序。

static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。

//例子9

import java.util.*;
class CollectionsSort
{
    public static void main(String[] args)
    {
        sortdemo();
    }
    public static void sortdemo()
    {
       List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("z");
       list.add("cdefg");
       list.add("kkkkkkk");
       list.add("qq");
       list.add("qq");

       sop(list); //排序前
       Collections.sort(list);
       sop(list); //排序后

       Collections.sort(list,new Mycomparator());
       sop(list); //传入比较器排序后
    }
    public static<T> void sop(T t)
    {
        System.out.println(t);
    }
}
class Mycomparator implements Comparator<String>   //定义一个比较器
{
    public int compare(String str1,String str2)
    {
       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
       return num==0? str1.compareTo(str2):num;
    }
}

/*
 List<Student> list = new ArrayList<Student>();
 list.add(new Student());

class Student
{

}

public static<T extends Comparable <? super T>> void sort(List<Student> list) //接受的对象泛型T必须具备比较性，所以
{                                                                             //可以继承Comparable，

}
*/

10.逆转比较器：

static <T> Comparator<T>  reverseOrder()

返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

//例子10：

import java.util.*;
class ReverseOrder
{
    public static void sop(Object obj)
    {
       System.out.println(obj);
    }
    public static void main(String[] args)
    {
        Set<String> ts1 = new TreeSet<String>();
        ts1.add("abcde");
        ts1.add("aaa");
        ts1.add("k");
        ts1.add("cc");

        sop("自然顺序排序：");
        Iterator<String> it1 = ts1.iterator();
        while(it1.hasNext())
        {
          String str = it1.next();
          sop(str);
        }

       reverseorderdemo1();

       Set<String> ts2 = new TreeSet<String>(new Mycomparator());
        ts2.add("abcde");
        ts2.add("aaa");
        ts2.add("k");
        ts2.add("cc");

        sop("自定义字符串长度顺序排序：");
        Iterator<String> it2 = ts2.iterator();
        while(it2.hasNext())
        {
          String str = it2.next();
          sop(str);
        }
       reverseorderdemo2();
    }

    public static void reverseorderdemo1()
    {
        Set<String> ts = new TreeSet<String>(Collections.reverseOrder());
        ts.add("abcde");
        ts.add("aaa");
        ts.add("k");
        ts.add("cc");

        //返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
        //Comparator co = Collections.reverseOrder();

        sop("返回比较器后，逆转自然顺序排序：");
        Iterator<String> it = ts.iterator();
        while(it.hasNext())
        {
          String str = it.next();
          sop(str);
        }
    }

    public static void reverseorderdemo2()
    {
        Set<String> ts = new TreeSet<String>(Collections.reverseOrder(new Mycomparator()));
        ts.add("abcde");
        ts.add("aaa");
        ts.add("k");
        ts.add("cc");

        //返回一个比较器，它强行逆转指定比较器的顺序（假如之前自定义设定的按照字符串长度）。
        //Comparator co = Collections.reverseOrder(new Mycomparator());

        sop("返回比较器后，逆转自定义字符串长度顺序排序：");
        Iterator<String> it = ts.iterator();
        while(it.hasNext())
        {
          String str = it.next();
          sop(str);
        }
    }
}

class Mycomparator implements Comparator<String>  ////定义一个比较器
{
    public int compare(String str1,String str2)
    {
       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
       return num==0? str1.compareTo(str2):num;
    }
}

11、Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

例如(求集合元素最值)：

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

根据元素的自然顺序，返回给定 collection 的最大元素。

static <T> T  max(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

根据元素的自然顺序 返回给定 collection 的最小元素。

static <T> T  min(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最小元素

//例子11：

import java.util.*;
class CollectionsMaxMin
{
    public static void main(String[] args)
    {
        maxdemo();
        mindemo();
    }
    public static void maxdemo()
    {
       List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("z");
       list.add("cdefg");
       list.add("kkkkkkk");
       list.add("qq");
       list.add("qq");
       sop("list:"+list);
       Collections.sort(list);
       sop(list);

       //根据元素的自然顺序，返回给定ArrayList集合中的最大元素
       String s1 = Collections.max(list);
       sop("max1="+s1);

       //根据指定比较器产生的顺序，返回给定ArrayList的最大元素（返回最长的字符串）。
       String s2 = Collections.max(list,new Mycomparator());
       sop("max2="+s2);
    }

    public static void mindemo()
    {
       List<String> list = new ArrayList<String>();
       list.add("abcd");
       list.add("aaa");
       list.add("z");
       list.add("cdefg");
       list.add("kkkkkkk");
       list.add("qq");
       list.add("qq");
       sop("list:"+list);
       Collections.sort(list);
       sop(list);

       //根据元素的自然顺序，返回给定ArrayList集合中的最小元素
       String s1 = Collections.min(list);
       sop("min1="+s1);

       //根据指定比较器产生的顺序，返回给定ArrayList的最小元素（返回最短的字符串）。
       String s2 = Collections.min(list,new Mycomparator());
       sop("min2="+s2);
    }

    public static<T> void sop(T t)
    {
        System.out.println(t);
    }
}

class Mycomparator implements Comparator<String>  ////定义一个比较器
{
    public int compare(String str1,String str2)
    {
       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
       return num==0? str1.compareTo(str2):num;
    }
}

12、Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

例如(集合加锁，让线程同步、随机排序)：

static <T> Collection<T>  synchronizedCollection(Collection<T> c)

返回指定 collection 支持的同步（线程安全的）collection。

static <T> List<T>  synchronizedList(List<T> list)

返回指定列表支持的同步（线程安全的）列表 。

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

返回由指定映射支持的同步（线程安全的）映射。

static <T> Set<T> synchronizedSet(Set<T> s)

返回指定 set 支持的同步（线程安全的）set。

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

返回指定有序映射支持的同步（线程安全的）有序映射 。

static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)

返回指定有序 set 支持的同步（线程安全的）有序 set。

static void shuffle(List<?> list)

使用默认随机源对指定列表进行置换。

static void shuffle(List<?> list, Random rnd)

使用指定的随机源对指定列表进行置换。

//例子12：

import java.util.*;
class CollectionsSynchronizedShuffle
{
    public static<T> void sop(T t)
    {
       System.out.println(t);
    }
    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");
       sop("list:"+list);

       //使用默认随机源对指定列表进行置.（每一次运行结果可能都不一样）
       Collections.shuffle(list);
       sop("list:"+list+"\n");
    }
}