【黑马程序员】集合工具类：Collections

最新推荐文章于 2022-10-20 09:54:03 发布
最新推荐文章于 2022-10-20 09:54:03 发布
阅读量539 收藏
点赞数

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

 jdk中提供了一种工具类用来方便的操作集合。这就是collections类。

常用方法有：

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)) 的行为是相同的，但在大多数实现下，此方法运行起来可能要快得多。

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)

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

 

永乐大帝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Collections类的常用方法！
刘珂的博客
10-05 2709
1.sort(Collection)方法的使用(含义：对集合进行排序)。 public class Practice { public static void main(String[] args){ List c = new ArrayList(); c.add("l"); c.add("o"); c.add("v"); c.add("e");
集合工具类：Collections
08-06
NULL 博文链接：https://chaoyi.iteye.com/blog/2086137
Collections常用方法总结
weixin_34061555的博客
05-16 97
2019独角兽企业重金招聘Python工程师标准>>> ...
collections的常用方法
jtjeeeee的博客
04-04 292
是针对集合操作的工具类 常用方法 sort()将列表升序排序 reverse()翻转指定列表的元素 shuffle()使用默认的随机源随机排列指定列表，即洗牌 示例：数字排序什么的没什么好说的，字符串也能排序（跟之前的Comparable有关系） import java.util.ArrayList; import java.util.Collections; import java.util.List; public class CollectionsTest { public stat
Collections类常用方法总结
mrdu_somefun的博客
06-06 432
1. sort对集合进行排序1 public static &lt;T extends Comparable&lt;? super T&gt;&gt; void sort(List&lt;T&gt; list) 2 3 public static &lt;T&gt; void sort(List&lt;T&gt; list, 4 Compa...
Collections类常用方法总结 【转】
老秦的博客
12-29 321
collections 是集合的一个util 平常都没怎么用，其实操作的集合的好多方法jdk 就给你写过了，你自己写的既慢又不见得比人家的安全，收集以备日后不时之需。 原文见 https://www.cnblogs.com/sunhaoyu/p/5909196.html Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程...
Java操作集合工具类Collections使用详解
08-25
Java操作集合工具类Collections使用详解 Java操作集合工具类Collections是Java语言中一个非常重要的工具类，主要用于操作Set、List和Map等集合。Collections工具类提供了大量方法对集合元素进行排序、查询和修改等...
JAVA集合框架工具类自定义Collections集合方法
08-26
Java集合框架工具类自定义Collections集合方法 Java集合框架工具类自定义Collections集合方法是Java开发中常用的技术之一，用于对集合进行处理和操作。本文将详细介绍如何自定义Collections集合方法，以便更好地...
Java使用Collections工具类对List集合进行排序
08-25
Java使用Collections工具类对List集合进行排序 Java使用Collections工具类对List集合进行排序是Java编程中一个常见的操作。Collections工具类提供了一个sort方法，可以对List集合进行排序。下面我们将详细介绍如何...
黑马程序员Javase笔记
01-18
增强for循环（也称为foreach循环）简化了对集合的遍历，而`Collections`类提供了许多对集合操作的静态方法，例如排序和过滤。 最后，关于泛型，它们允许在类、接口和方法中定义类型参数，提高了代码的复用性和安全...
Collections类常用方法
最新发布
yhc_817的博客
10-20 281
介绍几种Collections类中常用的方法
Collections类中的常用方法 [Java]
m0_57001006的博客
12-21 209
Collections工具类中的常用方法: reverse(List list); 反转list集合中的元素 shuffle(List list); 对list集合元素进行随机排序 sort(List list); 根据元素的自然排序对指定的List集合元素按升序排序 sort(List list , Comparator comparator); 根据指定的Comparator类中指定的排序方法进行排序 Object max(Collection collection)
Collections的常用方法
TTYYNX的博客。
01-15 144
package com.hncu.collections; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Demo { //collections的常用方法 public static void main(String[] args) { List<Integer> list = new ArrayList<&g.
Collections常用方法
weixin_40650583的博客
12-03 134
public class CollectionsTest { public static void main(String[] args) { List list = new ArrayList(); list.add(34); list.add(55); list.add(56); list.add(89); list.add(12); list.add(23); list.add(12...
Collections中常用方法
Dimples.
08-30 6681
1、排序方法Collections.sort(List&lt;E&gt;  list) 想使用此方法，两种方式。 注意：Collections.sort(List&lt;E&gt; list);此方法中参数类型为List。这说明此方法只能对list集合中的元素进行排序。 一、在自定义类型（E）中实现Comparable&lt;E&gt;接口，重写其中的compareTo()方法，这样Coll...
Collection的常用方法
qq_45495899的博客
10-10 348
1.add（E e）方法 向集合中添加元素e 语法 Boolean add(E e) 2.addAll（Collection e）方法 向当前集合中添加e集合中所有元素，e集合可以的类型可以是当前类也可以是当前类的子类 语法 Boolean add(Collection<? extends E> e) 1.add（E e）方法 向集合中添加元素e 语法 Boolean add(E e)...
Collections类 [Java]
m0_57001006的博客
12-14 288
Collections工具类 Collections是一个操作Collection集合和Map集合的工具类 Collections不仅仅是操作Collection集合,还可以操作Map集合 Collection和Collections有什么区别? Collection是一个接口,而Collections是一个类 Collections集合中有很多的操作Collection集合和Map集合的方法,并且这些操作集合的方法都是一些静态方法,我们直接使用类名去调用就可以 在Collection工具类中有如下
Java集合操作：Collections工具类详解
`java.util.Collections` 是一个实用工具类，它提供了多种对集合进行操作的方法，如添加元素、打乱顺序、排序等。下面我们将详细探讨这些知识点。 1. 往集合中一次性添加多个元素 `Collections.addAll()` 方法允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值