Collections类中常用方法总结

今天面试,被问到集合的东西,进而延伸到了Collections中的静态方法上来,答的稀烂,眼睁睁的看着一大好机会又从眼前溜走,痛定思痛的整理了下Collections提供的帮助方法。

此类完全由在 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(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(List<?> list, Random rnd)
          使用指定的随机源对指定列表进行置换。 同上

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

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

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(Collection<? extends T> coll, Comparator<? super T> comp)
          根据指定比较器产生的顺序,返回给定 collection 的最大元素。

eg:

public class CollectionsTest {
    public static void main(String[] args) {
        List<String> l = new ArrayList<String>();
        CollectionsTest.add(l);
        Collections.addAll(l,"Y","B");
        String s = Collections.max(l,Comparator1.getComparator());//有比较器的时候最大为Y   a b B c d e f Y

        //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(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(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。

相关文章
相关标签/搜索