Collections类常用方法总结

Myth丶恋晨 2022-07-14 06:58 297阅读 0赞

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容

如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都将抛出 NullPointerException。

首先定义一个工具类：

public class UtilTools \{  
      
    public static void printCollection(Collection c)\{  
        Iterator it= c.iterator();  
        while(it.hasNext())\{  
            Object o = it.next();  
            System.out.println(o);  
        \}  
    \}  
      
    public static void printMap(Map m)\{  
        Set<Map.Entry<Object, Object>> me = m.entrySet();  
        printCollection(me);  
    \}  
      
    public static void printMapKey(Map m)\{  
        Set me = m.keySet();  
        printCollection(me);  
    \}  
      
    public static void printMapValue(Map m)\{  
        Collection me = m.values();  
        printCollection(me);  
    \}  
\}

1.**[addAll][]**([Collection][]<? super T> c, T... elements)  
        将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素，或者将它们指定为一个数组。此便捷方法的行为与 c.addAll(Arrays.asList(elements)) 的行为是相同的，但在大多数实现下，此方法运行起来可能要快得多。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        String\[\] s = \{"s1","s2"\};  
        Collections.addAll(l, s);  
        Collections.addAll(l, "a1","a2");  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c)\{  
        for(char i='a';i<'g';i++)\{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}

2.**[sort][]**([List][]<T> list)  
          根据元素的*自然顺序* 对指定列表按升序进行排序。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.sort(l);  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c)\{  
        for(char i='a';i<'g';i++)\{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}

3.**[sort][sort 1]**([List][]<T> list, [Comparator][]<? super T> c)  
          根据指定比较器产生的顺序对指定列表进行排序。

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.addAll(l, "S");  
        Collections.sort(l);  
//        UtilTools.printCollection(l);  
        Collections.sort(l, Comparator1.getComparator());  
        UtilTools.printCollection(l);  
    \}  
  
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}  
  
class Comparator1 \{  
    public static Comparator getComparator() \{  
        return new Comparator() \{  
            @Override  
            public int compare(Object o1, Object o2) \{  
                if (o1 instanceof String && o2 instanceof String) \{  
                    String s1 = ((String)o1).toLowerCase();  
                    String s2 = ((String)o2).toLowerCase();  
                    return s1.compareTo(s2);  
                \}else\{  
                    System.err.println("未找到合适的比较器");  
                    return 1;  
                \}  
            \}  
        \};  
    \}  
\}

3.**[shuffle][]**([List][]<?> list)  
          使用默认随机源对指定列表进行置换。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.addAll(l, "S");  
        Collections.shuffle(l);  
        UtilTools.printCollection(l);  
    \}  
  
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}

4.**[shuffle][shuffle 1]**([List][]<?> list, [Random][] rnd)  
          使用指定的随机源对指定列表进行置换。 同上

5.**[binarySearch][]**([List][]<? extends [Comparable][]<? super T>> list, T key)  
          使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的[自然顺序][Comparable]对列表进行升序排序（通过[sort(List)][sort]方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

**[binarySearch][binarySearch 1]**([List][]<? extends T> list, T key, [Comparator][]<? super T> c)  
          使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过 [ sort(List, Comparator)][sort 1] 方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

eg：public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.addAll(l,"Y","B");  
        Collections.sort(l,Comparator1.getComparator());  
        int num = Collections.binarySearch(l,"B",Comparator1.getComparator());  
        System.out.println(num);  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}  
  
class Comparator1 \{  
    public static Comparator getComparator() \{  
        return new Comparator() \{  
            @Override  
            public int compare(Object o1, Object o2) \{  
                if (o1 instanceof String && o2 instanceof String) \{  
                    String s1 = ((String)o1).toLowerCase();  
                    String s2 = ((String)o2).toLowerCase();  
                    return s1.compareTo(s2);  
                \}else\{  
                    System.err.println("未找到合适的比较器");  
                    return 1;  
                \}  
            \}  
        \};  
    \}  
\}

注意binarySearch使用比较器的时候，前面的sort也必须使用，如果list里有重复的情况（不分大小写），则结果不确定，看上例查找B 和 b的情况都是返回1

6.**[max][]**([Collection][]<? extends T> coll)  
          根据元素的*自然顺序*，返回给定 collection 的最大元素。

**[max][max 1]**([Collection][]<? extends T> coll, [Comparator][]<? super T> comp)  
          根据指定比较器产生的顺序，返回给定 collection 的最大元素。

eg：

//String s = Collections.max(l);//没有比较器的话最大为f    B Y a b c d e f

System.out.println(s);  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}  
  
class Comparator1 \{  
    public static Comparator getComparator() \{  
        return new Comparator() \{  
            @Override  
            public int compare(Object o1, Object o2) \{  
                if (o1 instanceof String && o2 instanceof String) \{  
                    String s1 = ((String)o1).toLowerCase();  
                    String s2 = ((String)o2).toLowerCase();  
                    return s1.compareTo(s2);  
                \}else\{  
                    System.err.println("未找到合适的比较器");  
                    return 1;  
                \}  
            \}  
        \};  
    \}  
\}

7.**[min][]**([Collection][]<? extends T> coll)  
          根据元素的*自然顺序* 返回给定 collection 的最小元素。

**[min][min 1]**([Collection][]<? extends T> coll, [Comparator][]<? super T> comp)  
          根据指定比较器产生的顺序，返回给定 collection 的最小元素。

同上

8.**[indexOfSubList][]**([List][]<?> source, [List][]<?> target)  
          返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        List<String> l2 = new ArrayList<String>();  
        l2.add("c");  
        l2.add("d");  
        List<String> l3 = new ArrayList<String>();  
        l3.add("d");  
        l3.add("c");  
        int num1 = Collections.indexOfSubList(l, l2);  
        int num2 = Collections.indexOfSubList(l, l3);  
        System.out.println(num1+"/"+num2);  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}

9.**[lastIndexOfSubList][]**([List][]<?> source, [List][]<?> target)  
          返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。

同上

10.**[replaceAll][]**([List][]<T> list, T oldVal, T newVal)  
          使用另一个值替换列表中出现的所有某一指定值。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.addAll(l, "c","c");  
        Collections.replaceAll(l, "c", "c1");  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}

11.**[reverse][]**([List][]<?> list)  
          反转指定列表中元素的顺序。

12.**[rotate][]**([List][]<?> list, int distance)  
          根据指定的距离轮换指定列表中的元素。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.rotate(l, 1);//(i - distance) % list.size()  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}

13.**[reverseOrder][]**()  
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的*自然顺序*。返回反序排列的比较器

**[reverseOrder][reverseOrder 1]**([Comparator][]<T> cmp)  
          返回一个比较器，它强行逆转指定比较器的顺序。指定比较器的反序比较器

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.addAll(l, "Y","B");  
        Comparator ca = Collections.reverseOrder(Comparator1.getComparator());  
        Collections.sort(l, ca);  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
\}  
  
class Comparator1 \{  
    public static Comparator getComparator() \{  
        return new Comparator() \{  
            @Override  
            public int compare(Object o1, Object o2) \{  
                if (o1 instanceof String && o2 instanceof String) \{  
                    String s1 = ((String)o1).toLowerCase();  
                    String s2 = ((String)o2).toLowerCase();  
                    return s1.compareTo(s2);  
                \}else\{  
                    System.err.println("未找到合适的比较器");  
                    return 1;  
                \}  
            \}  
        \};  
    \}  
\}

14.**[singleton][]**(T o)  
          返回一个只包含指定对象的不可变 set。此对象可以是任意对象

**[singletonList][]**(T o)  
          返回一个只包含指定对象的不可变列表。

**[singletonMap][]**(K key, V value)  
          返回一个不可变的映射，它只将指定键映射到指定值。

eg:

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        Set<String> s = new HashSet<String>();  
        List<String> l = new ArrayList<String>();  
        Map<String,String> m = new HashMap<String,String>();  
        CollectionsTest.add(s);  
        CollectionsTest.add(l);  
        CollectionsTest.addMap(m);  
        //返回不可变的单一元素的set  
        Set<String> s1 = Collections.singleton("a");//参数是单个对象。这里"a"自动转化为String对象  
        //s1.add("b"); //针对set的改动操作会导致java.lang.UnsupportedOperationException  
        Set<Set<String>> s2 = Collections.singleton(s);//也可以是一个set句柄或其他任意对象  
        s.add("g");//这里单一不变指的是此对象句柄不变，但是里面的元素可以更改，比如这个就是合法的  
          
        List<String> l1 = Collections.singletonList("a");  
        Map<String,String> m1 = Collections.singletonMap("A->","A");  
          
        UtilTools.printCollection(l1);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}  
      
    public static void addMap(Map<String,String> m) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            m.put(i+"->", i+"");  
        \}  
    \}  
\}

15：**[swap][]**([List][]<?> list, int i, int j)  
          在指定列表的指定位置处交换元素。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.swap(l, 1, 2);  
          
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}

16：**[fill][]**([List][]<? super T> list, T obj)  
          使用指定元素替换指定列表中的所有元素。

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        Collections.fill(l, "b");  
          
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}

输出：b b b b b

17：**[frequency][]**([Collection][]<?> c, [Object][] o)  
          返回指定 collection 中等于指定对象的元素数。指定object o在c中出现的次数

eg：

public class CollectionsTest \{  
    public static void main(String\[\] args) \{  
        List<String> l = new ArrayList<String>();  
        CollectionsTest.add(l);  
        l.add("a");  
        int num = Collections.frequency(l, "a");  
        System.out.println(num);  
        UtilTools.printCollection(l);  
    \}  
      
    public static void add(Collection<String> c) \{  
        for (char i = 'a'; i < 'g'; i++) \{  
            c.add(String.valueOf(i));  
        \}  
    \}

输出：2

18：**[disjoint][]**([Collection][]<?> c1, [Collection][]<?> c2)  
 如果两个指定 collection 中没有相同的元素，则返回 true。

[addAll]: http://../java/util/Collections.html#addAll%28java.util.Collection,%20T...%29
[Collection]: http://../java/util/Collection.html
[sort]: http://../java/util/Collections.html#sort%28java.util.List%29
[List]: http://../java/util/List.html
[sort 1]: http://../java/util/Collections.html#sort%28java.util.List,%20java.util.Comparator%29
[Comparator]: http://../java/util/Comparator.html
[shuffle]: http://../java/util/Collections.html#shuffle%28java.util.List%29
[shuffle 1]: http://../java/util/Collections.html#shuffle%28java.util.List,%20java.util.Random%29
[Random]: http://../java/util/Random.html
[binarySearch]: http://../java/util/Collections.html#binarySearch%28java.util.List,%20T%29
[Comparable]: http://../java/lang/Comparable.html
[binarySearch 1]: http://../java/util/Collections.html#binarySearch%28java.util.List,%20T,%20java.util.Comparator%29
[max]: http://../java/util/Collections.html#max%28java.util.Collection%29
[max 1]: http://../java/util/Collections.html#max%28java.util.Collection,%20java.util.Comparator%29
[min]: http://../java/util/Collections.html#min%28java.util.Collection%29
[min 1]: http://../java/util/Collections.html#min%28java.util.Collection,%20java.util.Comparator%29
[indexOfSubList]: http://../java/util/Collections.html#indexOfSubList%28java.util.List,%20java.util.List%29
[lastIndexOfSubList]: http://../java/util/Collections.html#lastIndexOfSubList%28java.util.List,%20java.util.List%29
[replaceAll]: http://../java/util/Collections.html#replaceAll%28java.util.List,%20T,%20T%29
[reverse]: http://../java/util/Collections.html#reverse%28java.util.List%29
[rotate]: http://../java/util/Collections.html#rotate%28java.util.List,%20int%29
[reverseOrder]: http://../java/util/Collections.html#reverseOrder%28%29
[reverseOrder 1]: http://../java/util/Collections.html#reverseOrder%28java.util.Comparator%29
[singleton]: http://../java/util/Collections.html#singleton%28T%29
[singletonList]: http://../java/util/Collections.html#singletonList%28T%29
[singletonMap]: http://../java/util/Collections.html#singletonMap%28K,%20V%29
[swap]: http://../java/util/Collections.html#swap%28java.util.List,%20int,%20int%29
[fill]: http://../java/util/Collections.html#fill%28java.util.List,%20T%29
[frequency]: http://../java/util/Collections.html#frequency%28java.util.Collection,%20java.lang.Object%29
[Object]: http://../java/lang/Object.html
[disjoint]: http://../java/util/Collections.html#disjoint%28java.util.Collection,%20java.util.Collection%29