JAVA中的集合與排序

本文轉載自查看原文 2017-12-28 11:12 8788 集合/ java基礎/ java/ 集合排序

一：常見的集合類

　　Collection接口和 Map接口

Collection

　①：collection是最常見的集合的上級接口。

　②：繼承自collection的常用接口有List，Set，都是單列的集合。

　　　　　　----在List下面的集合實現類主要有 Arraylist，LinkedList

　　　　　　----在Set下面的主要實現類有 HashSet，TreeSet

　　List和Set的特性和區別：

　　①：首先list和set都是單列集合；

　　②：list里面的元素是有序的可重復的；

　　③：set集合里面的元素是無序的不可重復的；

　　④：list集合可以根據下標獲取對應的元素，而set則只能遍歷全部集合才能獲取對應的元素；

Set：

boolean add(E o)
如果 set 中尚未存在指定的元素，則添加此元素（可選操作）。

boolean addAll(Collection<? extends E> c)
如果 set 中沒有指定 collection 中的所有元素，則將其添加到此 set 中（可選操作）。

void clear()
移除 set 中的所有元素（可選操作）。

boolean contains(Object o)
如果 set 包含指定的元素，則返回 true。

boolean containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，則返回 true。

boolean equals(Object o)
比較指定對象與此 set 的相等性。

int hashCode()
返回 set 的哈希碼值。

boolean isEmpty()
如果 set 不包含元素，則返回 true。

Iterator<E> iterator()
返回在此 set 中的元素上進行迭代的迭代器。

boolean remove(Object o)
如果 set 中存在指定的元素，則將其移除（可選操作）。

boolean removeAll(Collection<?> c)
移除 set 中那些包含在指定 collection 中的元素（可選操作）。

boolean retainAll(Collection<?> c)
僅保留 set 中那些包含在指定 collection 中的元素（可選操作）。

int size()
返回 set 中的元素數（其容量）。

Object[] toArray()
返回一個包含 set 中所有元素的數組。

<T> T[]

toArray(T[] a)
返回一個包含 set 中所有元素的數組；返回數組的運行時類型是指定數組的類型。

HashSet

HashSet底層用的是哈希表，它把對象根據其哈希值存放到對應的區域里。由於這種特性，兩個在不同區域的對象會被認為不相同的。

所以如果對象要存放到Hash集合里面，則需要重寫對象的hashCode方法，讓相等的對象的hashCode的值也相等。

TreeSet

TreeSet采用的數據結構是紅黑樹，我們可以讓它按指定規則對其中的元素進行排序。它又是如何判斷兩個元素是否相同呢？除了用equals方法檢查兩個元素是否相同外，還要檢查compareTo方法是否返回為0。

所以如果對象要存放到Tree集合里，需要在重寫compareTo時，把相同的對象的比較值定為0，防止相同的元素被重復添加進集合中。

Set的排序：

我們有時候需要的是一個有序的集合，所以排序是很有必要的，在Set中使用treeset排序是很有必要的；如下面的代碼：

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<Integer> s=new TreeSet<Integer>();
11         s.add(1);
12         s.add(5);
13         s.add(6);
14         s.add(8);
15         s.add(2);
16         s.add(4);
17         System.out.println(s.toString());
18     }
19 }

輸出的結果為：

可見，當存儲的數據為int類型的時候，treeset是可以自動進行排序的；

那么char類型的呢？？？？？

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<Character> s=new TreeSet<Character>();
11         s.add('a');
12         s.add('g');
13         s.add('e');
14         s.add('b');
15         s.add('c');
16         s.add('d');
17         System.out.println(s.toString());
18     }
19 }

輸出的結果為：

可見這是按照字母的順序去排列的；

那如果是一個不一樣的String呢？？？？

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<String> s=new TreeSet<String>();
11         s.add("a");
12         s.add("g");
13         s.add("k");
14         s.add("b");
15         s.add("c");
16         s.add("d");
17         System.out.println(s.toString());
18     }
19 }

可見對於String類型來說，也是按照字母的順序來排列的；

那如果對象里面存放的是一個對象，那該如何進行排序???????????????????????????????????

我么直接存放一個對象，代碼如下：

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<Student> s=new TreeSet<Student>();
11         s.add(new Student(12,"zz"));
12         s.add(new Student(15,"aa"));
13         s.add(new Student(11,"bb"));
14         s.add(new Student(1,"kk"));
15         s.add(new Student(7,"gg"));
16         for (Student student : s) {
17             System.out.println(student.age+"----"+student.name);
18         }
19     }
20 }

你們猜一下運行的結果是什么？？？？？

答案是：

報錯，

因為對於一個對象來說，我們沒有什么直觀的條件去比較，上面報錯也說了不能比較這個student對象，那我們該怎么辦？？？？？？

當然是重寫Comparable的比較方法啦，代碼如下：

 1 package collections;
 2 
 3 public class Student implements Comparable<Student>{
 4     public int age;
 5     public String name;
 6     public Student(int age, String name) {
 7         super();
 8         this.age = age;
 9         this.name = name;
10     }
11     @Override
12     public int compareTo(Student o) {
13         // TODO Auto-generated method stub
14         return this.age-o.age;
15     }
16 }

我們在student對象上實現Comparable接口，重寫里面的比較方法，這寫的是按照年齡age去正序比較運行結果如下

如果想比較里面的名字，或者按照倒序排列，反過來寫就好了，你們可以試一試；

-----------------------------------------------------------------------------------------------------------------------------------挫挫的分割線，，，下面開始說List----------------------------------------------------------------------------------------------------------------------------------------------

List

List 接口繼承了 Collection 接口以定義一個允許重復項的有序集合。該接口不但能夠對列表的一部分進行處理，還添加了面向位置的操作。

有序的 collection（也稱為序列）。此接口的用戶可以對列表中每個元素的插入位置進行精確地控制。用戶可以根據元素的整數索引（在列表中的位置）訪問元素，並搜索列表中的元素。

常用的方法如下：

boolean add(E o)
向列表的尾部追加指定的元素（可選操作）。

void add(int index, E element)
在列表的指定位置插入指定元素（可選操作）。

boolean addAll(Collection<? extends E> c)
追加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序（可選操作）。

boolean addAll(int index, Collection<? extends E> c)
將指定 collection 中的所有元素都插入到列表中的指定位置（可選操作）。

void clear()
從列表中移除所有元素（可選操作）。

boolean contains(Object o)
如果列表包含指定的元素，則返回 true。

boolean containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，則返回 true。

boolean equals(Object o)
比較指定的對象與列表是否相等。

E get(int index)
返回列表中指定位置的元素。

int hashCode()
返回列表的哈希碼值。

int indexOf(Object o)
返回列表中首次出現指定元素的索引，如果列表不包含此元素，則返回 -1。

boolean isEmpty()
如果列表不包含元素，則返回 true。

Iterator<E> iterator()
返回以正確順序在列表的元素上進行迭代的迭代器。

int lastIndexOf(Object o)
返回列表中最后出現指定元素的索引，如果列表不包含此元素，則返回 -1。

ListIterator<E> listIterator()
返回列表中元素的列表迭代器（以正確的順序）。

ListIterator<E> listIterator(int index)
返回列表中元素的列表迭代器（以正確的順序），從列表的指定位置開始。

E remove(int index)
移除列表中指定位置的元素（可選操作）。

boolean remove(Object o)
移除列表中出現的首個指定元素（可選操作）。

boolean removeAll(Collection<?> c)
從列表中移除指定 collection 中包含的所有元素（可選操作）。

boolean retainAll(Collection<?> c)
僅在列表中保留指定 collection 中所包含的元素（可選操作）。

E set(int index, E element)
用指定元素替換列表中指定位置的元素（可選操作）。

int size()
返回列表中的元素數。

List<E> subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之間的部分視圖。

Object[] toArray()
返回以正確順序包含列表中的所有元素的數組。

<T> T[]

toArray(T[] a)
返回以正確順序包含列表中所有元素的數組；返回數組的運行時類型是指定數組的運行時類型。

實現list的兩個常用的集合有 ayyarlist linkedlist

arraylist 與linkedlist的區別

1.ArrayList是實現了基於動態數組的數據結構，LinkedList基於鏈表的數據結構。

2.對於隨機訪問get和set，ArrayList覺得優於LinkedList，因為LinkedList遍歷全部再確定。

3.對於新增和刪除操作add和remove，LinedList比較占優勢，因為ArrayList要移動數據。

總結：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：

Collection是集合接口
|————Set子接口:無序，不允許重復。
|————List子接口:有序，可以有重復元素。

區別：Collections是集合類

    Set和List對比：
    Set：檢索元素效率低下，刪除和插入效率高，插入和刪除不會引起元素位置改變。
    List：和數組類似，List可以動態增長，查找元素效率高，插入刪除元素效率低，因為會引起其他元素位置改變。

    Set和List具體子類：
    Set
     |————HashSet：以哈希表的形式存放元素，插入刪除速度很快。

    List
     |————ArrayList：動態數組
     |————LinkedList：鏈表、隊列、堆棧。

------------------------------------------------------------------------------------------------挫挫的分割線，，，下面開始說Map---------------------------------------------------------------------------------------------------------

map：

實現Map集合的常用的主要有 HashMap 類和 TreeMap 類

Map 有以下特點：

沒有重復的 key
每個 key 只能對應一個 value, 多個 key 可以對應一個 value
key,value 都可以是任何引用類型的數據，包括 null
Map 取代了古老的 Dictionary 抽象類

里面的主要方法：

hashmap我們基本天天用就不說了-------->>>>>>>>可看博客為：http://blog.csdn.net/zhangqj_/article/details/53486115

主要說一下treemap的排序：

如果只是實現Comparator的隱藏類進行排序，只能按照key去排序，但是這樣的話遠遠不能滿足我們的需求，還是按照value去排序的比較多，那么我們可以讓其先轉化為list集合再利用sort方法進行排序；

代碼如下：

 1 package collections;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6 import java.util.List;
 7 import java.util.Map;
 8 import java.util.Map.Entry;
 9 import java.util.TreeMap;
10 public class Sets {
11 
12     public static void main(String[] args) {
13         Map<String , Integer> map=new TreeMap<String, Integer>();//傳建一個treemap
14         map.put("aa", 1);
15         map.put("ee", 4);
16         map.put("kk", 3);
17         map.put("pp", 8);
18         map.put("qq", 2);
19         //把treemap轉換為list集合利用sort排序
20         List<Map.Entry<String, Integer>> list=new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
21         Collections.sort(list,new Comparator<Map.Entry<String, Integer>>() {
22             @Override
23             public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
24                 // TODO Auto-generated method stub
25                 /*if(o1.getValue()==o2.getValue()){
26                     return 0;
27                 }else if(o1.getValue()==o2.getValue()){
28                     return -1;
29                 }else{
30                     return 1;
31                 }*/
32                 return o2.getValue()-o1.getValue();//倒序
33             }
34         });
35         for (Entry<String, Integer> entry : list) {
36             System.out.println(entry.getKey()+"---"+entry.getValue());
37         }
38     }
39 }

運行結果：

很明顯，集合已經按照倒序排列了，如果要正序可以該表寫法，當然也能利用key進行排序，使用key去compare就好了；

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 java中對List對象集合進行排序 Java集合如何實現排序？ java集合去重和排序 Java 中List集合中自定義排序 java中Collections.sort()方法實現集合排序 Java對Map集合進行排序將集合中的內容按時間排序 Android集合中對象排序 List集合中對象的排序集合（一）-Java中Arrays.sort()自定義數組的升序和降序排序