⑴ java語言中,LinkedHashSet的優缺點
講下LinkedHashSet，他的優點是按照插入順序排列，速度略慢
詳細描述：
LinkedHashMap和LinkedHashSet是JDK 1.4中引入的兩個新的集合類。雖然已經過去5年了，但我敢打賭並不是很多人都用過（因為我就沒有用過）。但這兩個類在某些情況下還是非常有用的，過去沒有用，現在沒有用，都沒有關系。但還是應該對這兩個Collection框架的新成員有所了解，因為也許以後你會到，或者其實你現在就應該要用到。
LinkedHashMap/LinkedHashSet 顧名思義，就是在Hash的實現上添加了Linked的支持。對於HashMap/HashSet的每個節點上通過一個鏈表串聯起來，這樣就可以保證確定的順序。對於希望有常量復雜度的高效存取性能要求，同時有要求排序的情況下，現在可以直接使用LinkedHashMap/Set了。
對於LinkedHashMap還有一點特別注意，LinkedHashMap支持兩種排序：插入順序、訪問順序。前者是指按照插入時的順序排序，後者是指按照最舊使用到最近使用的順序。即如果在一個LinkedHashMap中有5個節點，現在的順序是e1, e2, e3, e4, e5. 如果是使用順序的話，現在訪問了一次e2, 那麼e2節點將移至鏈表的尾部。現在順序變為：e1, e3, e4, e5, e2.
這會造成嚴重的性能問題嗎？答案當然是否定的。因為在這兒的鏈表操作是常量級的。這也是LinkedHashMap/Set在這兒比TreeMap/Set性能更高的原因。
同樣，LinkedHashMap/Set也不是thread-safe的。如果在多線程下訪問，是需要進行外部同步，或者使用Collections.synchronizedMap()的方法包裝成一個thread-safe的Map/Set。
特別需要注意的是，在使用「訪問順序」時，讀取節點操作也是「結構變化」的操作。因為，這會改變元素遍歷的順序。所以，在使用LinkedHashMap的iterator()方法，遍歷元素時，如果其它線程有讀取操作，也要進行同步。否則，也會拋出同其它fail-fast一樣的由於刪除或增加操作而引起的CurrentModificationException的例外。
LinkedHashMap,HashMap等
⑵ HashMap和LinkedHashMap的區別是什麼
一般情況下，我們用的最多的是HashMap,在Map 中插入、刪除和定位元素，HashMap 是最好的選擇。但如果您要按自然順序或自定義順序遍歷鍵，那麼TreeMap會更好。如果需要輸出的順序和輸入的相同,那麼用LinkedHashMap 可以實現,它還可以按讀取順序來排列.
HashMap是一個最常用的Map，它根據鍵的hashCode值存儲數據，根據鍵可以直接獲取它的值，具有很快的訪問速度。HashMap最多隻允許一條記錄的鍵為NULL，允許多條記錄的值為NULL。
HashMap不支持線程同步，即任一時刻可以有多個線程同時寫HashMap，可能會導致數據的不一致性。如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力。
Hashtable與HashMap類似，不同的是：它不允許記錄的鍵或者值為空；它支持線程的同步，即任一時刻只有一個線程能寫Hashtable，因此也導致了Hashtable在寫入時會比較慢。
LinkedHashMap保存了記錄的插入順序，在用Iterator遍歷LinkedHashMap時，先得到的記錄肯定是先插入的。
在遍歷的時候會比HashMap慢TreeMap能夠把它保存的記錄根據鍵排序，默認是按升序排序，也可以指定排序的比較器。當用Iterator遍歷TreeMap時，得到的記錄是排過序的。
⑶ 如何用LinkedHashMap實現LRU緩存演算法
緩存這個東西就是為了提高運行速度的，由於緩存是在寸土寸金的內存裡面，不是在硬碟
裡面，所以容量是很有限的。LRU這個演算法就是把最近一次使用時間離現在時間最遠的數據刪除掉。先說說List：每次訪問一個元素後把這個元素放在
List一端，這樣一來最遠使用的元素自然就被放到List的另一端。緩存滿了t的時候就把那最遠使用的元素remove掉。但更實用的是
HashMap。因為List太慢，要刪掉的數據總是位於List底層數組的第一個位置，刪掉之後，後面的數據要向前補位。。所以復雜度是O(n)，那就
用鏈表結構的LinkedHashMap唄~，LinkedHashMap默認的元素順序是put的順序，但是如果使用帶參數的構造函數，那麼
LinkedHashMap會根據訪問順序來調整內部 順序。
LinkedHashMap的get()方法除了返回元素之外還可以把被訪問的元素放到鏈表的底端，這樣一來每次頂端的元素就是remove的元素。
構造函數如下：
public LinkedHashMap (int initialCapacity, float loadFactor, boolean accessOrder)；
initialCapacity 初始容量
loadFactor 載入因子，一般是 0.75f
accessOrder false 基於插入順序 true 基於訪問順序（get一個元素後，這個元素被加到最後，使用了LRU 最近最少被使用的調度演算法）
來個例子吧：
import java.util.*;
class Test
{
public static void main(String[] args) throws Exception{
Map<Integer,Integer> map=new LinkedHashMap<>(10,0.75f,true);
map.put(9,3);
map.put(7,4);
map.put(5,9);
map.put(3,4);
//現在遍歷的話順序肯定是9,7,5,3
//下面訪問了一下9,3這個鍵值對，輸出順序就變嘍~
map.get(9);
for(Iterator<Map.Entry<Integer,Integer>> it=map.entrySet().iterator();it.hasNext();){
System.out.println(it.next().getKey());
}
}
}
輸出
7
5
3
9
好玩吧~
下面開始實現LRU緩存嘍~
import java.util.*;
//擴展一下LinkedHashMap這個類，讓他實現LRU演算法
class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{
//定義緩存的容量
private int capacity;
private static final long serialVersionUID = 1L;
//帶參數的構造器
LRULinkedHashMap(int capacity){
//調用LinkedHashMap的構造器，傳入以下參數
super(16,0.75f,true);
//傳入指定的緩存最大容量
this.capacity=capacity;
}
//實現LRU的關鍵方法，如果map裡面的元素個數大於了緩存最大容量，則刪除鏈表的頂端元素
@Override
public boolean removeEldestEntry(Map.Entry<K, V> eldest){
System.out.println(eldest.getKey() + "=" + eldest.getValue());
return size()>capacity;
}
}
//測試類
class Test{
public static void main(String[] args) throws Exception{
//指定緩存最大容量為4
Map<Integer,Integer> map=new LRULinkedHashMap<>(4);
map.put(9,3);
map.put(7,4);
map.put(5,9);
map.put(3,4);
map.put(6,6);
//總共put了5個元素，超過了指定的緩存最大容量
//遍歷結果
for(Iterator<Map.Entry<Integer,Integer>> it=map.entrySet().iterator();it.hasNext();){
System.out.println(it.next().getKey());
}
}
}
輸出結果如下
9=3
9=3
9=3
9=3
9=3
7
5
3
6
分析一下：使用帶參數構造器，且啟用LRU模式的LinkedHashMap會在每次有新元素加入的時候，判斷當前儲存元素是否超過了緩存上限，也就是執行
一次removeEldestEntry方法，看最後的遍歷結果，發現果然把9刪除了，LRU發揮作用了~
⑷ linkedhashmap和hashmap的區別
HashMap
是一個最常用的Map,它根據鍵的HashCode
值存儲數據,根據鍵可以直接獲取它的值，具有很快的訪問速度。HashMap最多隻允許一條記錄的鍵為Null;允許多條記錄的值為Null;HashMap不支持線程的同步，即任一時刻可以有多個線程同時寫HashMap;可能會導致數據的不一致。如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力。
LinkedHashMap
LinkedHashMap也是一個HashMap,但是內部維持了一個雙向鏈表,可以保持順序
⑸ Java中HashMap和LinkedHashMap以及TreeMap的區別
共同點：
HashMap,LinkedHashMap,TreeMap都屬於Map；Map 主要用於存儲鍵(key)值(value)對，根據鍵得到值，因此鍵不允許鍵重復,但允許值重復。
不同點：
1.HashMap裡面存入的鍵值對在取出的時候是隨機的,也是我們最常用的一個Map.它根據鍵的HashCode值存儲數據,根據鍵可以直接獲取它的值，具有很快的訪問速度。在Map 中插入、刪除和定位元素，HashMap 是最好的選擇。
2.TreeMap取出來的是排序後的鍵值對。但如果您要按自然順序或自定義順序遍歷鍵，那麼TreeMap會更好。
3. LinkedHashMap 是HashMap的一個子類，如果需要輸出的順序和輸入的相同,那麼用LinkedHashMap可以實現. (應用場景：購物車等需要順序的)
⑹ 如何訪問中 LinkedHashMap 的嵌套對象的數據
在linux或者unix環境中，errno是一個十分重要的部分。在調用的函數出現問題的時候，我們可以通過errno的值來確定出錯的原因，這就會 涉及到一個問題，那就是如何保證errno在多線程或者進程中安全？我們希望在多線程或者進程中，每個線程或者進程都擁有自己獨立和唯一的一個 errno，這樣就能夠保證不會有競爭條件的出現。一般而言，編譯器會自動保證errno的安全性，但是為了妥善期間，我們希望在寫makefile的時 候把_LIBC_REENTRANT宏定義，比如我們在檢查<bits/errno.h>文件中發現如下的定義：
# ifndef __ASSEMBLER__
/* Function to get address of global `errno' variable. */
extern int *__errno_location (void) __THROW __attribute__ ((__const__));
⑺ LinkedHashMap和HashMap的區別以及使用方法
顧名思義LinkedHashMap是比HashMap多了一個鏈表的結構。與HashMap相比LinkedHashMap維護的是一個具有雙重
鏈表的HashMap，LinkedHashMap支持2中排序一種是插入排序，一種是使用排序，最近使用的會移至尾部例如 M1 M2 M3
M4，使用M3後為 M1 M2 M4
M3了，LinkedHashMap輸出時其元素是有順序的，而HashMap輸出時是隨機的，如果Map映射比較復雜而又要求高效率的話，最好使用
LinkedHashMap，但是多線程訪問的話可能會造成不同步，所以要用Collections.synchronizedMap來包裝一下，從而實
現同步。其實現一般為：
Map<String String> map = Collections.synchronizedMap(new LinkedHashMap(<String String));
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class TestLinkedHashMap {
public static void main(String args[])
{
System.out.println("*************************LinkedHashMap*************");
Map<Integer,String> map = new LinkedHashMap<Integer,String>();
map.put(6, "apple");
map.put(3, "banana");
map.put(2,"pear");
for (Iterator it = map.keySet().iterator();it.hasNext();)
{
Object key = it.next();
System.out.println( key+"="+ map.get(key));
}
System.out.println("*************************HashMap*************");
Map<Integer,String> map1 = new HashMap<Integer,String>();
map1.put(6, "apple");
map1.put(3, "banana");
map1.put(2,"pear");
for (Iterator it = map1.keySet().iterator();it.hasNext();)
{
Object key = it.next();
System.out.println( key+"="+ map1.get(key));
}
}
}
運行結果如下:
*************************LinkedHashMap*************
6=apple
3=banana
2=pear
*************************HashMap**************************
2=pear
6=apple
3=banana
分析:LinkedHashmap 的特點是put進去的對象位置未發生變化,而HashMap會發生變化.
⑻ 如何遍歷linkedhashmap
第一種:
Map map = new HashMap();
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Object key = entry.getKey();
Object val = entry.getValue();
}
效率高,以後一定要使用此種方式！
第二種:
Map map = new HashMap();
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
Object key = iter.next();
Object val = map.get(key);
}
效率低,以後盡量少使用！
HashMap的遍歷有兩種常用的方法，那就是使用keyset及entryset來進行遍歷，但兩者的遍歷速度是有差別的，下面請看實例：
public class HashMapTest {
public static void main(String[] args) {
HashMap hashmap = new HashMap();
for (int i = 0; i < 1000; i ) {
hashmap.put("" i, "thanks");
}
long bs = Calendar.getInstance().getTimeInMillis();
Iterator iterator = hashmap.keySet().iterator();
while (iterator.hasNext()) {
System.out.print(hashmap.get(iterator.next()));
}
System.out.println();
System.out.println(Calendar.getInstance().getTimeInMillis() - bs);
listHashMap();
}
public static void listHashMap() {
java.util.HashMap hashmap = new java.util.HashMap();
for (int i = 0; i < 1000; i ) {
hashmap.put("" i, "thanks");
}
long bs = Calendar.getInstance().getTimeInMillis();
java.util.Iterator it = hashmap.entrySet().iterator();
while (it.hasNext()) {
java.util.Map.Entry entry = (java.util.Map.Entry) it.next();
// entry.getKey() 返回與此項對應的鍵
// entry.getValue() 返回與此項對應的值
System.out.print(entry.getValue());
}
System.out.println();
System.out.println(Calendar.getInstance().getTimeInMillis() - bs);
}
}
對於keySet其實是遍歷了2次，一次是轉為iterator，一次就從hashmap中取出key所對於的value。而entryset只是遍歷了第一次，他把key和value都放到了entry中，所以就快了。
注:Hashtable的遍歷方法和以上的差不多！
進行實例分析一下下：
以下通過程序來簡單實踐一下HashMap的的遍歷
如果要保持HashMap的遍歷順序和原插入順序一致，可以使用LinkedHashMap，使用方法和HashMap一樣，改一下聲明即可：LinkedHashMap myMap = new LinkedHashMap(); 當然需要導入：java.util.LinkedHashMap
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class MapList {
public static void main(String[] args) {
// TODO Auto-generated method stub
HashMap myMap = new HashMap();
myMap.put("hello", "");
myMap.put("bye", "再見");
myMap.put("thanks", "");
myMap.put("ok", "好的");
System.out.println("--------------------遍歷key和value----------------------");
for(Iterator iter = myMap.entrySet().iterator();iter.hasNext();){
Map.Entry element = (Map.Entry)iter.next();
Object strKey = element.getKey();
Object strObj = element.getValue();
System.out.println("myMap.get(\""+strKey+"\")="+strObj);
}
System.out.println();
System.out.println("--------------------遍歷整個HashMap----------------------");
Collection objs = myMap.entrySet();
for (Iterator iterator=objs.iterator(); iterator.hasNext();){
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println();
System.out.println("--------------------遍歷HashMap的key----------------------");
Collection keys = myMap.keySet();
for (Iterator iterator=keys.iterator(); iterator.hasNext();){
Object key = iterator.next();
System.out.println(key);
}
System.out.println();
System.out.println("--------------------遍歷HashMap的value----------------------");
Collection values = myMap.values();
for (Iterator iterator=values.iterator(); iterator.hasNext();){
Object value = iterator.next();
System.out.println(value);
}
}
}
運行結果：
--------------------遍歷key和value----------------------
myMap.get("hello")=
myMap.get("thanks")=
myMap.get("ok")=好的
myMap.get("bye")=再見
--------------------遍歷整個HashMap----------------------
hello=
thanks=
ok=好的
bye=再見
--------------------遍歷HashMap的key----------------------
hello
thanks
ok
bye
--------------------遍歷HashMap的value----------------------
好的
再見
⑼ java的LinkedHashSet是怎樣實現存取有序的, 底層原理是什麼
LinkedHashSet 的實現
對於 LinkedHashSet 而言，它繼承與 HashSet、又基於 LinkedHashMap 來實現的。
LinkedHashSet 底層使用 LinkedHashMap 來保存所有元素，它繼承與 HashSet，其所有的方法操作上又與 HashSet 相同，因此 LinkedHashSet 的實現上非常簡單，只提供了四個構造方法，並通過傳遞一個標識參數，調用父類的構造器，底層構造一個 LinkedHashMap 來實現，在相關操作上與父類 HashSet 的操作相同，直接調用父類 HashSet 的方法即可。
需要注意理解的點是：
LinkedHashSet 是 Set 的一個具體實現，其維護著一個運行於所有條目的雙重鏈接列表。此鏈接列表定義了迭代順序，該迭代順序可為插入順序或是訪問順序。
LinkedHashSet 繼承與 HashSet，並且其內部是通過 LinkedHashMap 來實現的。有點類似於我們之前說的LinkedHashMap 其內部是基於 Hashmap 實現一樣，不過還是有一點點區別的（具體的區別大家可以自己去思考一下）。
如果我們需要迭代的順序為插入順序或者訪問順序，那麼 LinkedHashSet 是需要你首先考慮的。