2. 定製排序

TreeSet的自然排序是根據集合元素的大小，TreeSet將它們以升序排序。如果我們需要實現定製排序，則可以通過Comparator介面的幫助(類似PHP中的array_map回撥處理函式的思想)。該接口裡包含一個int compare(T o1， T o2)方法，該方法用於比較大小

import java.util.*;

class M
{
    int age;
    public M(int age)
    {
        this.age = age;
    }
    public String toString()
    {
        
 
return "M[age:" + age + "]";
    }
}

public class TreeSetTest4
{
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet(new Comparator()
        {
            //根據M物件的age屬性來決定大小
            public int compare(Object o1, Object o2)
            {
                M m1 = (M)o1;
                M m2 
 
= (M)o2;
                return m1.age > m2.age ? -1
                    : m1.age < m2.age ? 1 : 0;
            }
        });    
        ts.add(new M(5));
        ts.add(new M(-3));
        ts.add(new M(9));
        System.out.println(ts);
    }
}

看到這裡，我們需要梳理一下關於排序的概念

1) equals、compareTo決定的是怎麼比的問題，即用什麼field進行大小比較
 
2) 自然排序、定製排序、Comparator決定的是誰大的問題，即按什麼順序(升序、降序)進行排序
它們的關注點是不同的，一定要注意區分

EnumSet

import java.util.*;

enum Season
{
    SPRING,SUMMER,FALL,WINTER
}
public class EnumSetTest
{
    public static void main(String[] args) 
    {
        //建立一個EnumSet集合，集合元素就是Season列舉類的全部列舉值
        EnumSet es1 = EnumSet.allOf(Season.class);
        //輸出[SPRING,SUMMER,FALL,WINTER]
        System.out.println(es1);

        //建立一個EnumSet空集合，指定其集合元素是Season類的列舉值。
        EnumSet es2 = EnumSet.noneOf(Season.class); 
        //輸出[]
        System.out.println(es2); 
        //手動新增兩個元素
        es2.add(Season.WINTER);
        es2.add(Season.SPRING);
        //輸出[SPRING,WINTER]
        System.out.println(es2);

        //以指定列舉值建立EnumSet集合
        EnumSet es3 = EnumSet.of(Season.SUMMER , Season.WINTER); 
        //輸出[SUMMER,WINTER]
        System.out.println(es3);

        EnumSet es4 = EnumSet.range(Season.SUMMER , Season.WINTER); 
        //輸出[SUMMER,FALL,WINTER]
        System.out.println(es4);

        //新建立的EnumSet集合的元素和es4集合的元素有相同型別，
        //es5的集合元素 + es4集合元素 = Season列舉類的全部列舉值
        EnumSet es5 = EnumSet.complementOf(es4); 
        //輸出[SPRING]
        System.out.println(es5);
    }
}

以上就是Set集合類的程式設計應用場景。那麼應該怎樣選擇何時使用這些集合類呢？

1) HashSet的效能總是比TreeSet好(特別是最常用的新增、查詢元素等操作)，因為TreeSet需要額外的紅黑樹演算法來維護集合元素的次序。只有當需要一個保持排序的Set時，才應該使用TreeSet，否則都應該使用HashSet
2) 對於普通的插入、刪除操作，LinkedHashSet比HashSet要略慢一點，這是由維護連結串列所帶來的開銷造成的。不過，因為有了連結串列的存在，遍歷LinkedHashSet會更快
3) EnumSet是所有Set實現類中效能最好的，但它只能儲存同一個列舉類的列舉值作為集合元素
4) HashSet、TreeSet、EnumSet都是"執行緒不安全"的，通常可以通過Collections工具類的synchronizedSortedSet方法來"包裝"該Set集合。
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

0x2: List

ArrayList

如果一開始就知道ArrayList集合需要儲存多少元素，則可以在建立它們時就指定initialCapacity大小，這樣可以減少重新分配的次數，提供效能，ArrayList還提供瞭如下方法來重新分配Object[]陣列

1) ensureCapacity(int minCapacity): 將ArrayList集合的Object[]陣列長度增加minCapacity
2) trimToSize(): 調整ArrayList集合的Object[]陣列長度為當前元素的個數。程式可以通過此方法來減少ArrayList集合物件佔用的記憶體空間

import java.util.*;

public class ListTest
{
    public static void main(String[] args) 
    {
        List books = new ArrayList();
        //向books集合中新增三個元素
        books.add(new String("輕量級Java EE企業應用實戰"));
        books.add(new String("瘋狂Java講義"));
        books.add(new String("瘋狂Android講義"));
        System.out.println(books);

        //將新字串物件插入在第二個位置
        books.add(1 , new String("瘋狂Ajax講義"));
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }

        //刪除第三個元素
        books.remove(2);
        System.out.println(books);

        //判斷指定元素在List集合中位置：輸出1，表明位於第二位
        System.out.println(books.indexOf(new String("瘋狂Ajax講義")));  //①
        //將第二個元素替換成新的字串物件
        books.set(1, new String("LittleHann"));
        System.out.println(books);

        //將books集合的第二個元素（包括）
        //到第三個元素（不包括）擷取成子集合
        System.out.println(books.subList(1 , 2));
    }

Stack

注意Stack的後進先出的特點

import java.util.*;

public class VectorTest
{
    public static void main(String[] args) 
    {
        Stack v = new Stack();
        //依次將三個元素push入"棧"
        v.push("瘋狂Java講義");
        v.push("輕量級Java EE企業應用實戰");
        v.push("瘋狂Android講義");

        //輸出：[瘋狂Java講義, 輕量級Java EE企業應用實戰 , 瘋狂Android講義]
        System.out.println(v);

        //訪問第一個元素，但並不將其pop出"棧"，輸出：瘋狂Android講義
        System.out.println(v.peek());

        //依然輸出：[瘋狂Java講義, 輕量級Java EE企業應用實戰 , 瘋狂Android講義]
        System.out.println(v);

        //pop出第一個元素，輸出：瘋狂Android講義
        System.out.println(v.pop());

        //輸出：[瘋狂Java講義, 輕量級Java EE企業應用實戰]
        System.out.println(v);
    }
}

LinkedList

import java.util.*;

public class LinkedListTest
{
    public static void main(String[] args) 
    {
        LinkedList books = new LinkedList();

        //將字串元素加入佇列的尾部(雙端佇列)
        books.offer("瘋狂Java講義");

        //將一個字串元素加入棧的頂部(雙端佇列)
        books.push("輕量級Java EE企業應用實戰");

        //將字串元素新增到佇列的頭(相當於棧的頂部)
        books.offerFirst("瘋狂Android講義");

        for (int i = 0; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }

        //訪問、並不刪除棧頂的元素
        System.out.println(books.peekFirst());
        //訪問、並不刪除佇列的最後一個元素
        System.out.println(books.peekLast());
        //將棧頂的元素彈出"棧"
        System.out.println(books.pop());
        //下面輸出將看到佇列中第一個元素被刪除
        System.out.println(books);
        //訪問、並刪除佇列的最後一個元素
        System.out.println(books.pollLast());
        //下面輸出將看到佇列中只剩下中間一個元素：
        //輕量級Java EE企業應用實戰
        System.out.println(books);
    }
}

從程式碼中我們可以看到，LinkedList同時表現出了雙端佇列、棧的用法。功能非常強大

0x3: Queue

PriorityQueue

import java.util.*;

public class PriorityQueueTest
{
    public static void main(String[] args) 
    {
        PriorityQueue pq = new PriorityQueue();
        //下面程式碼依次向pq中加入四個元素
        pq.offer(6);
        pq.offer(-3);
        pq.offer(9);
        pq.offer(0);

        //輸出pq佇列，並不是按元素的加入順序排列，
        //而是按元素的大小順序排列，輸出[-3, 0, 9, 6]
        System.out.println(pq);
        //訪問佇列第一個元素，其實就是佇列中最小的元素：-3
        System.out.println(pq.poll());
    }
}

PriorityQueue不允許插入null元素，它還需要對佇列元素進行排序，PriorityQueue的元素有兩種排序方式

1) 自然排序:
採用自然順序的PriorityQueue集合中的元素物件都必須實現了Comparable介面，而且應該是同一個類的多個例項，否則可能導致ClassCastException異常
2) 定製排序
建立PriorityQueue佇列時，傳入一個Comparator物件，該物件負責對佇列中的所有元素進行排序
關於自然排序、定製排序的原理和之前說的TreeSet類似

 ArrayDeque

import java.util.*;

public class ArrayDequeTest
{
    public static void main(String[] args) 
    {
        ArrayDeque stack = new ArrayDeque();
        //依次將三個元素push入"棧"
        stack.push("瘋狂Java講義");
        stack.push("輕量級Java EE企業應用實戰");
        stack.push("瘋狂Android講義");

        //輸出：[瘋狂Java講義, 輕量級Java EE企業應用實戰 , 瘋狂Android講義]
        System.out.println(stack);

        //訪問第一個元素，但並不將其pop出"棧"，輸出：瘋狂Android講義
        System.out.println(stack.peek());

        //依然輸出：[瘋狂Java講義, 輕量級Java EE企業應用實戰 , 瘋狂Android講義]
        System.out.println(stack);

        //pop出第一個元素，輸出：瘋狂Android講義
        System.out.println(stack.pop());

        //輸出：[瘋狂Java講義, 輕量級Java EE企業應用實戰]
        System.out.println(stack);
    }
}

以上就是List集合類的程式設計應用場景。我們來梳理一下思路

1. java提供的List就是一個"線性表介面"，ArrayList(基於陣列的線性表)、LinkedList(基於鏈的線性表)是線性表的兩種典型實現
2. Queue代表了佇列，Deque代表了雙端佇列(既可以作為佇列使用、也可以作為棧使用)
3. 因為陣列以一塊連續記憶體來儲存所有的陣列元素，所以陣列在隨機訪問時效能最好。所以的內部以陣列作為底層實現的集合在隨機訪問時效能最好。
4. 內部以連結串列作為底層實現的集合在執行插入、刪除操作時有很好的效能
5. 進行迭代操作時，以連結串列作為底層實現的集合比以陣列作為底層實現的集合效能好

我們之前說過，Collection介面繼承了Iterable介面，也就是說，我們以上學習到的所有的Collection集合類都具有"可遍歷性"

Iterable介面也是java集合框架的成員，它隱藏了各種Collection實現類的底層細節，嚮應用程式提供了遍歷Collection集合元素的統一程式設計介面:

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Map、Set、List、Queue、Stack的特點與用法2
     
 
                

2. 定製排序

TreeSet的自然排序是根據集合元素的大小，TreeSet將它們以升序排序。如果我們需要實現定製排序，則可以通過Comparator介面的幫助(類似PHP中的array_map回撥處理函式的思想)。該接口裡包含一個int compare(T o 

  
 

    

    
    
MAP、SET、LIST、QUEUE、STACK的特點與用法
     
  
 
 
 這裡是修真院後端小課堂，每篇分享文從 
 【背景介紹】【知識剖析】【常見問題】【解決方案】【編碼實戰】【擴充套件思考】【更多討論】【參考文獻】 
 八個方面深度解析後端知識/技能，本篇分享的是： 
 【MAP、SET、LIST、QUEUE、STACK的特點與用法】 
 1.背景介紹 
 MAP  

  
 

    

    
    
JAVA Map、Set、List、Queue、Stack的特點與用法
     
 
								
								            
							
							
							https://github.com/helen-x/AndroidInterview/blob/master/java/%5BJava%5D%20Map%E3%80%81Set%E3%80%81Lis 

  
 

    

    
    
Map、Set、List、Queue、Stack的特點與用法1
     
 
                

1. Java集合類基本概念

在程式設計中，常常需要集中存放多個數據。從傳統意義上講，陣列是我們的一個很好的選擇，前提是我們事先已經明確知道我們將要儲存的物件的數量。一旦在陣列初始化時指定了這個陣列長度，這個陣列長度就是不可變的，如果我們需要儲存一個可以動態增長的資料( 

  
 

    

    
    
16. Map、Set、List、Queue、Stack的特點與用法。
     
 
                

首先依舊要清楚這些集合框架的分支


collection


├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set

└Queue


Map
├Hashtable
├HashMap
└WeakHashMap

故此 

  
 

    

    
    
Map、Set、List、Collection、Queue、Stack的特點與用法。
     
 
                

java集合框架的基本介面/類層次結構

java.util.Collection [I]
+--java.util.List [I]
   +--java.util.ArrayList [C]
   +--java.util.LinkedList [C]
   +--j 

  
 

    

    
    
Map、Set、List、Queue、Stack的特點與用法。
     
 
								
								            
						
                
Map主要用於儲存健值對，根據鍵得到值，因此不允許鍵重複(重複了覆蓋了),但允許值重複。Map中可以將Key和Value單獨抽取出來，其中KeySet()方法可以將所有的keys抽取正一個Set。而V 

  
 

    

    
    
map、set和list集合詳解
     
 
							
							
							集合是用來代替陣列完成陣列做不到的工作的，用過陣列的都知道，陣列有著很明顯的短板，資料型別的限制，定長的不靈活性等，因此幾乎被集合完全取代。
通俗的說，集合就是一個放資料的容器，準確的說是放資料物件引用的容器。它比陣列功能要強大的多，靈活性也更高。但我們要注意： 

  
 

    

    
    
python多程序————10、程序間的通訊-Queue、Manager、Pipe
     
  
 
 一、Queue 
 這裡提到的佇列模組大概有三個： 
  1、from queue import Queue  (此模組適用於執行緒間通訊，但不能用於程序間通訊) 
  2、from multiprocessing import Queue （可以用於多程序，但不能用於 

  
 

    

    
    
C++之普通成員函式、虛擬函式以及純虛擬函式的區別與用法要點
     
 

普通成員函式是靜態編譯的，沒有執行時多型，只會根據指標或引用的“字面值”類物件，呼叫自己的普通函式；虛擬函式為了過載和多型的需要，在基類中定義的，即便定義為空；純虛擬函式是在基類中宣告的虛擬函式，它可以再基類中有定義，且派生類必須定義自己的實現方法。

假設我們有三個類Person、Teacher 

  
 

    

    
    
java中三大集合類Map，Set，List的詳細介紹
     
 
                

在講Map,Set,List三大介面之前，我們先來了解下Set和List的父類介面Collection介面


一：Collection介面：是java.util包下的一個介面：

其中有一些主要的方法：

size（）；

isEmpty（）；

clear（）；

c 

  
 

    

    
    
在spring 中如何注入map，set，list，property等引數
     
 
                




package cn.dao;  
publicinterface PersonDao {  
    publicabstractvoid add();  
}  


cn.dao.imp






package cn.d 

  
 

    

    
    
spring xml 檔案的一些寫法，包括map ，set ，list 等
     
 
							
							
							To switch over from the DTD-style to the new XML Schema-style, you need to make the following change.



<?xml version="1.0" enc 

  
 

    

    
    
spring設定構造，name，ref，map，set，list賦值
     
 
                
、先建立一個例項類Person
public class Person {
	private int id;
	private String name;
	private int age;
	
	private Person friend;
	
	private List& 

  
 

    

    
    
Java 之路 (十一) -- 持有物件（Collection、List、Set、Queue、Map、Iterator、foreach）
     
 
							
							
							本章將簡單介紹一下常用的集合類的特點，同時並不會深入原始碼分析原理，本文目的僅僅在於對 Java 集合類有一個整體認識

關於 API，本文不涉及過多，建議直接檢視 Java 官方文件







1. 容器概述



1.1 引入原因

Java 中，陣列用 

  
 

    

    
    
List、Map、Set、Queue的區別與關係
     
 
                List、Set、Queue 都繼承自 Collection 介面，而 Map 則不是（繼承自 Object），所以容器類有兩個根介面，分別是 Collection 和 Map，Collection 表示單個元素的集合，Map 表示鍵值對的集合。

List 的主要特點就是有 

  
 

    

    
    
java基礎鞏固系列（九）：持有物件之間的使用與關係（Iterable、Collection、List、Queue、Set、Map、Stack）
     
 
                
總：Java提供了一套比較完整的容器類，基本型別是：List、Set、Queue、Map，這些物件型別稱為集合類。
一、介面繼承關係：

Iterable介面，在java.lang包中，Collection、List、Queue、Set介面繼承Iterable介面


可以 

  
 

    

    
    
Java基礎面試題3-說說你知道的幾個Java集合類：list、set、queue、map
     
 
                關係這張圖簡單揭示了Set、List與Map之間的相對關係。 需要說明下的是，圖中的實現並不指這麼簡單的實現，這個稍後會說到。Collection介面Collection是Java中最基本的集合介面。它描述了一組有關集合操作的方法。int Size(); //集合大小
boo 

  
 

    

    
    
set(集）、list(列表）、map(對映)和Queue（佇列）
     
 (1) Set 
集（set）是最簡單的一種集合，它的物件不按特定方式排序，只是簡單的把物件加入集合中，就像往口袋裡放東西。對集中成員的訪問和操作是通過集中物件的引用進行的，所以集中不能有重複物件。我們知道數學上的集合也是Set這個，集合裡面一定是沒有重複的元素的。

（2）List 
列表（List）的主要 

  
 

    

    
    
STL 整理（map、set、vector、list、stack、queue、deque、priority_queue）
     
 
                
向量(vector) <vector>
連續儲存的元素<vector>
Vector<int>c;
c.back()    傳回最後一個數據，不檢查這個資料是否存在。
c.clear()     移除容器中所有資料。
c.empty()