博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
Collections 常用方法
阅读量：4094 次
发布时间：2019-05-25

本文共 9628 字，大约阅读时间需要 32 分钟。

 

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

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

首先定义一个工具类：

public class UtilTools {

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

1.(<?super T> c,T... elements)

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

eg：

public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String>c){
      for(char i='a';i<'g';i++){
         c.add(String.valueOf(i));
      }
    }
}

2.(<T> list)

          根据元素的自然顺序对指定列表按升序进行排序。

eg：

public class CollectionsTest {

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

3.(<T> list,<? superT> c)

          根据指定比较器产生的顺序对指定列表进行排序。

public class CollectionsTest {

    publicstatic 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);
    }
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
}
class Comparator1 {
    publicstatic 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.(<?> list)

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

eg：

public class CollectionsTest {

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

4.(<?> list, rnd)

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

5.(<?extends <? superT>> list,T key)

          使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的对列表进行升序排序（通过方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

(<? extendsT> list, T key,<? superT> c)

          使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

eg：public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
}
class Comparator1 {
    publicstatic 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.(<?extends T> coll)

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

(<? extendsT> coll, <? superT> comp)

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

eg：

public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
}
class Comparator1 {
    publicstatic 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.(<?extends T> coll)

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

(<? extendsT> coll, <? superT> comp)

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

同上

8.(<?> source,<?> target)

          返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回-1。

eg：

public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
}

9.(<?> source,<?> target)

          返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回-1。

同上

10.(<T> list,T oldVal, T newVal)

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

eg：

public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
}

11.(<?> list)

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

12.(<?> list,int distance)

          根据指定的距离轮换指定列表中的元素。

eg：

public class CollectionsTest {

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

 13.()

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

(<T> cmp)

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

 eg：

public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
}
class Comparator1 {
    publicstatic 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.(T o)

          返回一个只包含指定对象的不可变set。此对象可以是任意对象

(T o)

          返回一个只包含指定对象的不可变列表。

(K key,V value)

          返回一个不可变的映射，它只将指定键映射到指定值。

eg:

public class CollectionsTest {

    publicstatic void main(String[] args) {
      Set<String> s = newHashSet<String>();
      List<String> l =new ArrayList<String>();
      Map<String,String>m = newHashMap<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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }
    
    publicstatic void addMap(Map<String,String>m) {
      for (char i = 'a'; i < 'g'; i++){
         m.put(i+"->", i+"");
      }
    }
}

15：(<?> list,int i, int j)

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

eg：

public class CollectionsTest {

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

}

16：(<?super T> list,T obj)

          使用指定元素替换指定列表中的所有元素。

eg：

public class CollectionsTest {

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

}

输出：b b b b b

17：(<?> c, o)

          返回指定collection 中等于指定对象的元素数。指定object o在c中出现的次数

eg：

public class CollectionsTest {

    publicstatic 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);
    }
    
    publicstatic void add(Collection<String> c){
      for (char i = 'a'; i < 'g'; i++){
         c.add(String.valueOf(i));
      }
    }

}

输出：2

18：
(<?> 

c1,<?> c2)

          如果两个指定collection 中没有相同的元素，则返回 true

转载地址：http://zvtii.baihongyu.com/

你可能感兴趣的文章
记录：iframe在IE下 document.createElement 兼容
查看>>
外部类为abstract时，出错记录。
查看>>
java变量
查看>>
equals：注意Sting类型和非String类型的比较
查看>>
Animal[] animals = new Animal[2];
查看>>
New Date();报错
查看>>
XML - -DOM解析
查看>>
DOS命令行窗口mysql显示乱码问题处理
查看>>
MySQL数据库备份与恢复
查看>>
直接双击启动tomcat中的startup.bat闪退原因及解决方法
查看>>
response.sendRedirect()与request.getRequestDispatcher().forward()区别
查看>>
Java Socket技术总结
查看>>
单列模式-编写类ConfigManager读取属性文件
查看>>
java中float和double的区别
查看>>
Statement与PreparedStatement区别
查看>>
Tomcat配置数据源步骤以及使用JNDI
查看>>
before start of result set 是什么错误
查看>>
MyEclipse 提示设置 JSP XML 自动提示
查看>>
(正则表达式)表单验证
查看>>
jsp...
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-09-20 20:26:12   当前IP: 3.144.116.22   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我