2. 程式人生 > >Java 中Collections類的用法

Java 中Collections類的用法

阿新 • • 發佈：2018-11-22

參考：

Collections類常用方法總結

1. sort

對集合進行排序

 public static <T extends Comparable<? super T>> void sort(List<T> list)

 public static <T> void sort(List<T> list, Comparator<? super T> c)

在使用List時想根據List中儲存物件的某一欄位進行排序，那麼我們要用到Collections.sort方法對list排序，用Collections.sort方法對list排序有兩種方法：

  • 第一種是list中的物件實現Comparable介面；
  • 第二種方法是根據Collections.sort過載方法來實現。

demo：

public class SortTest {
    public static void main(String[] args) {
        List<String> listS = new ArrayList<String>();
        List<Employer1> list1 = new ArrayList<Employer1>();
        List<Employer2> list2 = new ArrayList<Employer2>();
        List<Employer3> list3 = new ArrayList<Employer3>();
        
        //一.將String型別的變數插入到listS中並排序
        //listS中的物件String 本身含有compareTo方法，所以可以直接呼叫sort方法，按自然順序排序，即升序排序
        listS.add("5");
        listS.add("2");
        listS.add("9");
        Collections.sort(listS);
        
        //二.將Employer1類的物件插入到list1中並排序
        //將已建立的實現了Comparator介面的比較類MyCompare傳入Collections的sort方法中即可實現依照MyCompare類中的比較規則。
        Employer1 a1 = new Employer1();
        Employer1 b1 = new Employer1();
        Employer1 c1 = new Employer1();
        a1.setName("a1");   a1.setAge(44);
        b1.setName("b1");   b1.setAge(55);
        c1.setName("b1");   c1.setAge(33);
        list1.add(a1);
        list1.add(b1);
        list1.add(c1);//Collections類的sort方法要求傳入的第二個引數是一個已實現Comparator介面的比較器
        Collections.sort(list1, new MyCompare());

        //三.將Employer2類的物件插入到list2中並排序
        //其實原理和上面的二類似，只是沒有單獨建立MyCompare類，而是用匿名內部類來實現Comparator接口裡面的具體比較。
        Employer2 a2 = new Employer2();
        Employer2 b2 = new Employer2();
        Employer2 c2 = new Employer2();
        a2.setName("a2");   a2.setAge(66);
        b2.setName("b2");   b2.setAge(33);
        c2.setName("b2");   c2.setAge(22);
        list2.add(a2);
        list2.add(b2);
        list2.add(c2); //Collections類的sort方法要求傳入的第二個引數是一個已實現Comparator介面的比較器
        Collections.sort(list2,new Comparator<Employer2>(){
            @Override
            public int compare(Employer2 a2, Employer2 b2) {
                return a2.getOrder().compareTo(b2.getOrder());
            }

        });

        //四.將Employer3類的物件插入到list3中並排序
        //被排序的類Employer3實現了Comparable介面,在類Employer3中通過過載compareTo方法來實現具體的比較。
        Employer3 a3 = new Employer3();
        Employer3 b3 = new Employer3();
        Employer3 c3 = new Employer3();
        a3.setName("a3");   a3.setAge(77);
        b3.setName("b3");   b3.setAge(55);
        c3.setName("b3");   c3.setAge(99);
        list3.add(a3);
        list3.add(b3);
        list3.add(c3);
        Collections.sort(list3);//Collections類的sort方法要求傳入的List中的物件是已實現Comparable介面的物件

        System.out.println(listS);
        System.out.println(list1);
        System.out.println(list3);
        System.out.println(list2);
    }
}
class Employer1{
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override//過載了Object類裡的toString方法，使之可以按照我們要求的格式列印
    public String toString() {
        return "name is "+name+" age is "+ age;
    }
}
class MyCompare implements Comparator<Employer1> {
    @Override//過載了Comparator接口裡面的compare方法實現具體的比較
    public int compare(Employer1 o1, Employer1 o2) {
        return o1.getAge().compareTo(o2.getAge());
    }
}
class Employer2{
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public Integer getOrder() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override//過載了Object類裡的toString方法，使之可以按照我們要求的格式列印
    public String toString() {
        return "name is "+name+" age is "+age;
    }
}
class Employer3 implements Comparable<Employer3>{
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override//過載了Object類裡的toString方法，使之可以按照我們要求的格式列印
    public String toString() {
        return "name is "+name+" age is "+age;
    }
    @Override//過載了Comparable接口裡的compareTo方法來實現具體的比較
    public int compareTo(Employer3 a) {
        return this.age.compareTo(a.getAge());
    }
}

列印結果：

[2, 5, 9]
[name is b1 age is 33, name is a1 age is 44, name is b1 age is 55]
[name is b3 age is 55, name is a3 age is 77, name is b3 age is 99]
[name is b2 age is 22, name is b2 age is 33, name is a2 age is 66]

compareTo()小結

　　由上面的程式我們可以看出，無論是實現了Comparable介面的方法還是實現了Comparator介面的方法，最終比較的返回值都是通過compareTo方法實現的，故就把compareTo方法單獨拿出來做個小結。

　　compareTo()的返回值是整型，它是先比較對應字元的大小(ASCII碼順序)，如果第一個字元和引數的第一個字元不等，結束比較，返回他們之間的差值，如果第一個字元和引數的第一個字元相等，則以第二個字元和引數的第二個字元做比較，以此類推，直至比較的字元或被比較的字元有一方全比較完，這時就比較字元的長度。例如：

String s1 = "abc"; 
String s2 = "abcd"; 
String s3 = "abcdfg"; 
String s4 = "1bcdfg"; 
String s5 = "cdfg"; 
System.out.println( s1.compareTo(s2) ); // -1 (前面相等,s1長度小1) 
System.out.println( s1.compareTo(s3) ); // -3 (前面相等,s1長度小3) 
System.out.println( s1.compareTo(s4) ); // 48 ("a"的ASCII碼是97,"1"的的ASCII碼是49,所以返回48) 
System.out.println( s1.compareTo(s5) ); // -2 ("a"的ASCII碼是97,"c"的ASCII碼是99,所以返回-2)

2. shuffle

對集合進行隨機排序

 public static void shuffle(List<?> list)

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

demo：

public class Practice {
    public static void main(String[] args){
        List c = new ArrayList();
        c.add("w");
        c.add("o");
        c.add("r");
        c.add("l");
        c.add("d");
        System.out.println(c);
        Collections.shuffle(c);
        System.out.println(c);
        Collections.shuffle(c);
        System.out.println(c);
    }
}

結果：

[w, o, r, l, d]
[l, d, w, o, r]
[o, r, d, l, w]

3. binarySearch

查詢指定集合中的元素，返回所查詢元素的索引，如果它包含在陣列中，則返回搜尋鍵的索引；否則返回 (-(插入點) - 1)。 插入點 被定義為將鍵插入陣列的那一點：即第一個大於此鍵的元素索引，如果陣列中的所有元素都小於指定的鍵，則為 a.length。注意，這保證了當且僅當此鍵被找到時，返回的值將 >= 0。

public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

demo：

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");
        System.out.println(c);
        int m = Collections.binarySearch(c, "o");
        int n = Collections.binarySearch(c, "p");
        System.out.println(m + "    " + n);
    }
}

結果:

[l, o, v, e]
1    -3

4. max

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

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

前者採用Collection內含自然比較法，後者採用Comparator進行比較.

5. min

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
public static <T> T min(Collection<? extends T> coll,Comparator<? super T> comp)

前者採用Collection內含自然比較法，後者採用Comparator進行比較。

6. indexOfSubList

查詢subList在list中首次出現位置的索引

public static int indexOfSubList(List<?> source,List<?> target)

demo:

public class Practice {
  public static void main(String[] args){
    List list = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(list);
    List subList = Arrays.asList("three four five six".split(" "));
    System.out.println(Collections.indexOfSubList(list, subList));
  }
}

結果：

[one, two, three, four, five, six, siven]
2

7. lastIndexOfSubList

使用與上例方法的使用相同。

8. replaceAll

替換批定元素為某元素,若要替換的值存在剛返回true,反之返回false

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

demo：

public class Practice {
  public static void main(String[] args){
    List list = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(list);
    List subList = Arrays.asList("three four five six".split(" "));
    System.out.println(Collections.replaceAll(list, "siven", "siven eight"));
    System.out.println(list);
  }
}

執行結果為：
[one, two, three, four, five, six, siven]
true
[one, two, three, four, five, six, siven eight]

9. reverse()

反轉集合中元素的順序

public static void reverse(List<?> list)

demo：

public class Practice {
  public static void main(String[] args){
    List list = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(list);
    Collections.reverse(list);
    System.out.println(list);
  }
}

執行結果為：
[one, two, three, four, five, six, siven]
[siven, six, five, four, three, two, one]

10. rotate

集合中的元素向後移m個位置，在後面被遮蓋的元素迴圈到前面來

 public static void rotate(List<?> list, int distance)

demo：

public class Practice {
  public static void main(String[] args){
    List list = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(list);
    Collections.rotate(list, 1);
    System.out.println(list);
  }
}
執行結果為：
[one, two, three, four, five, six, siven]
[siven, one, two, three, four, five, six]

11. copy

將集合n中的元素全部複製到m中,並且覆蓋相應索引的元素

1 public static <T> void copy(List<? super T> dest,  List<? extends T> src)
demo：

public class Practice {
  public static void main(String[] args){
    List m = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(m);
    List n = Arrays.asList("我 是 複製過來的哈".split(" "));
    System.out.println(n);
    Collections.copy(m,n);
    System.out.println(m);
  }
}
執行結果為：
[one, two, three, four, five, six, siven]
[one, two, four, three, five, six, siven]

12. swap

交換集合中指定元素索引的位置

public static void swap(List<?> list,int i,int j)
demo：
public class Practice {
  public static void main(String[] args){
    List m = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(m);
    Collections.swap(m, 2, 3);
    System.out.println(m);
  }
}
執行結果為：
[one, two, three, four, five, six, siven]
[one, two, four, three, five, six, siven]

13. fill

用物件o替換集合list中的所有元素

public static <T> void fill(List<? super T> list, T obj)
demo：
public class Practice {
  public static void main(String[] args){
    List m = Arrays.asList("one two three four five six siven".split(" "));
    System.out.println(m);
    Collections.fill(m, "haha52T25xixi");
    System.out.println(m);
  }
}
執行結果為：
[one, two, three, four, five, six, siven]
[haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi]

14. nCopies

返回大小為n的List，List不可改變,其中的所有引用都指向o

 public static <T> List<T> nCopies(int n, T o)
demo： 
public class Practice {
   public static void main(String[] args){
     System.out.println(Collections.nCopies(5, "haha"));
   }
 }

執行結果為：
[haha, haha, haha, haha, haha]

 

相關推薦

Java 中Collections類的用法

參考： Collections類常用方法總結 1. sort 對集合進行排序 public static <T extends Comparable<? super T>> void sort(List<T> list) public sta

java中Collections類的使用

示例：實體類實現Comparable介面，重寫compareTo方法 public class Person implements Comparable<Person>{ private String personId; private String rate;

java中Set類接口的用法

集合類型 aaa sys nbsp all spa 元素 equal stub 在Java中使用Set,可以方便地將需要的類型，以集合類型保存在一個變量中.主要應用在顯示列表. Set是一個不包含重復元素的collection。更確切地講，set 不包含滿足 e1.equa

Java中BigDecimal類介紹及用法

exceptio decimal body ue4 mage oat 比較運算符 mod 乘法 　　Java中提供了大數字(超過16位有效位)的操作類,即 java.math.BinInteger 類和 java.math.BigDecimal 類,用於高精度計算. 　　其

關於java中string類的用法！

String類代表字串 字串是常量，他們的值在建立之後不能改變 String類包括的方法有：檢查序列的單個字元；比較字串；搜尋字串；提取子字串；建立字串副本（在該副本中，所有的字元都被轉換為大寫或小寫形式）。 Java語言提供對字串串聯符號（“+”）和其他物件到

Java中Class類詳解、用法以及泛化

在前面我們將類的載入的時候，類載入一共有5步，載入，驗證，準備，解析和初始化。其中載入階段，除了將位元組碼載入到方法區，還生成了這個了的Java.lang.Class物件。那麼這個Class物件到底有什麼用呢？ 前面的關於反射的文章，我們多次都用到了Class類，可以用這個

Java多執行緒有哪幾種實現方式? Java中的類如何保證執行緒安全? 請說明ThreadLocal的用法和適用場景（面試題）

Java多執行緒有哪幾種實現方式? Java中的類如何保證執行緒安全? 請說明ThreadLocal的用法和適用場景 Java多執行緒有三種實現方式： (1)繼承Thread類，重寫run函式 (2)實現Runnable介面，重寫run函式 開啟執行緒：Thread t

Java中Date類與Calendar類的用法和轉化

Date類在JDK1.0中，Date類是唯一的一個代表時間的類，但是由於Date類不便於實現國際化，所以從JDK1.1版本開始，推薦使用Calendar類進行時間和日期處理。這裡簡單介紹一下Date類的使用。 1、使用Date類代表當前系統時間

Java中對類中的屬性使用set/get方法的意義和用法

經常看到有朋友提到類似：對類中的屬性使用set/get方法的作用？理論的回答當然是封閉性之類的，但是這樣對我們有什麼作用呢？為什麼要這樣設計？我直接使用屬性名來訪問不是更直接，程式碼更簡潔明瞭嗎？下面我們就來介紹下為什麼要使用set/get方法來代替直接訪問屬性

java中Arrays類的一些用法

列舉Arrays的一些用法，方便以後查詢使用。 //1.sort排序String[]陣列：升序:從小到大 String[] names = { "Liz", "John", "Eric", "Alan" }; //只排序前兩個 //[John, Liz, Er

java中String類型轉換為yyyy-MM-dd的Date類型

col code edate birt mat led div get sys String birthday ="2017-02-22"; SimpleDateFormat sdf = new SimpleDateFormat(("yyyy-MM-dd")); jav

java中clob類型的值處理

string類型 reat 測試 () eat string json pri 類型轉換 1、String類轉換Clob類型 private Clob clobStr; private String Str="測試值"; clobStr = Hibernate.create

Java中集合類容器初步了解

equals treemap 輸入 strong 字符串數組 通過 system 結構 shm 　　容器(Collection) 　　　　數組是一種容器,集合也是一種容器 　　　　java編程中, 裝其他各種各樣的對象(引用類型)的一種東西, 叫容器 　　　　(圖書

在java中String類為什麽要設計成final？

tro cli lai 這一 引用 沒有 num 重新 static 大神鏈接：在java中String類為什麽要設計成final？ - 程序員 - 知乎 我進行了重新排版，並且更換了其中的一個例子，讓我們更好理解。 String很多實用的特性，比如說“不可變性”，是工

java中的instanceof用法詳解

定義 xtend print 繼承 interface 參數 保留 如果 ack 　　instanceof是Java的一個二元操作符（運算符）,也是Java的保留關鍵字。它的作用是判斷其左邊對象是否為其右邊類的實例，返回的是boolean類型的數據。用它來判斷某個對象是否是

Java中static關鍵字用法總結

副本 大括號 跟著 rac clas main 靜態成員變量 abstract 全局變量 1. 靜態方法 通常，在一個類中定義一個方法為static，那就是說，無需本類的對象即可調用此方法 聲明為static的方法有以下幾條限制： · 它們僅能調用其他的sta

java中Collections.sort排序詳解

比較器 元素 .net 字符 atp style pri com 實現接口 Comparator是個接口，可重寫compare()及equals()這兩個方法,用於比價功能；如果是null的話，就是使用元素的默認順序，如a,b,c,d,e,f,g，就是a,b,c,d,e,f

Java中抽象類和接口的區別

pre data 區分 信息 展示 關於 面向 得出 lose 在Java語言中， abstract class 和interface 是支持抽象類定義的兩種機制。正是由於這兩種機制的存在，才賦予了Java強大的 面向對象能力。abstract class和interfac

在java中RandomAccessFile類的作用：對指定文件可以進行讀寫的操作

cnblogs 讀寫 acc com ces 作用 分享 進行 .com 在java中RandomAccessFile類的作用：對指定文件可以進行讀寫的操作

java中File類getPath()、getAbsolutePath()、getCanonicalPath()區別？

mil dir block user out div cnblogs test file 簡單看一下描述，例子最重要。 1、getPath()： 　　返回定義時的路徑，（就是你寫什麽路徑，他就返回什麽路徑） 2、getAbsolutePath()： 　　返回絕對路徑，但不會