java8map的簡單介紹

本文目錄一覽：

• 1、Java8 新特性 stream().map 能不能跳過元素 ，相當於continue的作用？
• 2、javamap的用法
• 3、java8的stream().mapToInt()什麼意思？
• 4、java7和java8對hashmap做了哪些優化

Java8 新特性 stream().map 能不能跳過元素 ，相當於continue的作用？

你好，很高興回答你的問題。

stream()可以調用filter方法，可以用來過濾只保留符合條件的數據，相當於是循環到不符合條件的數據時continue。

如果有幫助到你請點擊採納。

javamap的用法

javamap的用法如下；

1、void clear():刪除Map中所有鍵值對。

2、boolean containsKey(Object key):查詢Map中是否包含指定key，如果包含則返回true。

3、boolean containsValue(Object value):查詢Map中是否包含指定value，如果包含則返回true。

4、Set entrySet():返回Map中所包含的鍵值對所組成的Set集合，每個集合元素都是Map.Entry對象(Entry是Map的內部類)。

5、Object get(Object key):返回指定key所對應的value，如Map中不包含key則返回null。

6、boolean isEmpty():查詢Map是否為空，如果空則返回true。

7、Set keySet():返回該Map中所有key所組成的set集合。

8、Object put(Object key,Object value):添加一個鍵值對，如果已有一個相同的key值則新的鍵值對覆蓋舊的鍵值對。

9、void putAll(Map m):將指定Map中的鍵值對複製到Map中。

10、Object remove(Object key):刪除指定key所對應的鍵值對，返回可以所關聯的value，如果key不存在，返回null。

11、int size():返回該Map里的鍵值對的個數。

12、Collection values():返回該Map里所有value組成的Collection。

Map中包含一個內部類：Entry。該類封裝了一個鍵值對，它包含了三個方法：

1、Object getKey():返回該Entry里包含的key值。

2、Object getValeu():返回該Entry里包含的value值。

3、Object setValue(V value):設置該Entry里包含的value值，並返回新設置的value值。

java8的stream().mapToInt()什麼意思？

Stream（流）是一個來自數據源的元素隊列並支持聚合操作

strong元素隊列 strong=””元素是特定類型的對象，形成一個隊列。 Java中的Stream並不會存儲元素，而是按需計算。

數據源 流的來源。 可以是集合，數組，I/O channel， 產生器generator 等。

聚合操作 類似SQL語句一樣的操作， 比如filter, map, reduce, find, match, sorted等。

可以試試這個輸出什麼：

String[] strarr = {“abc”, “defg”, “vwxyz”};

int iSum = Arrays.stream(strarr)

.mapToInt(s – s.length())

.sum();

System.out.println(“長度和: “+iSum);

擴展資料：

Java還包括一個類的擴展集合，分別組成各種程序包（Package），用戶可以在自己的程序中使用。例如，Java提供產生圖形用戶接口部件的類（java.awt包），這裡awt是抽象窗口工具集（abstract windowing toolkit）的縮寫，處理輸入輸出的類（java.io包）和支持網絡功能的類（java.net包）。

參考資料來源：百度百科-Java

java7和java8對hashmap做了哪些優化

HashMap的原理介紹\x0d\x0a\x0d\x0a此乃老生常談，不作仔細解說。\x0d\x0a一句話概括之：HashMap是一個散列表，它存儲的內容是鍵值對(key-value)映射。\x0d\x0a\x0d\x0aJava 7 中HashMap的源碼分析\x0d\x0a\x0d\x0a首先是HashMap的構造函數代碼塊1中，根據初始化的Capacity與loadFactor（加載因子）初始化HashMap.\x0d\x0a//代碼塊1\x0d\x0a public HashMap(int initialCapacity, float loadFactor) {\x0d\x0a if (initialCapacity MAXIMUM_CAPACITY)\x0d\x0a initialCapacity = MAXIMUM_CAPACITY;\x0d\x0a if (loadFactor 的put方法實現相對比較簡單，首先根據 key1 的key值計算hash值，再根據該hash值與table的length確定該key所在的index,如果當前位置的Entry不為null，則在該Entry鏈中遍歷，如果找到hash值和key值都相同，則將值value覆蓋，返回oldValue；如果當前位置的Entry為null，則直接addEntry。\x0d\x0a代碼塊2\x0d\x0apublic V put(K key, V value) {\x0d\x0a if (table == EMPTY_TABLE) {\x0d\x0a inflateTable(threshold);\x0d\x0a }\x0d\x0a if (key == null)\x0d\x0a return putForNullKey(value);\x0d\x0a int hash = hash(key);\x0d\x0a int i = indexFor(hash, table.length);\x0d\x0a for (Entry e = table[i]; e != null; e = e.next) {\x0d\x0a Object k;\x0d\x0a if (e.hash == hash ((k = e.key) == key || key.equals(k))) {\x0d\x0a V oldValue = e.value;\x0d\x0a e.value = value;\x0d\x0a e.recordAccess(this);\x0d\x0a return oldValue;\x0d\x0a }\x0d\x0a }\x0d\x0a\x0d\x0a modCount++;\x0d\x0a addEntry(hash, key, value, i);\x0d\x0a return null;\x0d\x0a }\x0d\x0a\x0d\x0a//addEntry方法中會檢查當前table是否需要resize\x0d\x0a void addEntry(int hash, K key, V value, int bucketIndex) {\x0d\x0a if ((size = threshold) (null != table[bucketIndex])) {\x0d\x0a resize(2 * table.length); //當前map中的size 如果大於threshole的閾值，則將resize將table的length擴大2倍。\x0d\x0a hash = (null != key) ? hash(key) : 0;\x0d\x0a bucketIndex = indexFor(hash, table.length);\x0d\x0a }\x0d\x0a\x0d\x0a createEntry(hash, key, value, bucketIndex);\x0d\x0a }\x0d\x0a\x0d\x0aJava7 中resize（）方法的實現比較簡單，將OldTable的長度擴展，並且將oldTable中的Entry根據rehash的標記重新計算hash值和index移動到newTable中去。代碼如代碼塊3中所示，\x0d\x0a//代碼塊3 –JDK7中HashMap.resize()方法\x0d\x0avoid resize(int newCapacity) {\x0d\x0a Entry[] oldTable = table;\x0d\x0a int oldCapacity = oldTable.length;\x0d\x0a if (oldCapacity == MAXIMUM_CAPACITY) {\x0d\x0a threshold = Integer.MAX_VALUE;\x0d\x0a return;\x0d\x0a }\x0d\x0a\x0d\x0a Entry[] newTable = new Entry[newCapacity];\x0d\x0a transfer(newTable, initHashSeedAsNeeded(newCapacity));\x0d\x0a table = newTable;\x0d\x0a threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);\x0d\x0a }\x0d\x0a\x0d\x0a /**\x0d\x0a * 將當前table的Entry轉移到新的table中\x0d\x0a */\x0d\x0a void transfer(Entry[] newTable, boolean rehash) {\x0d\x0a int newCapacity = newTable.length;\x0d\x0a for (Entry e : table) {\x0d\x0a while(null != e) {\x0d\x0a Entry next = e.next;\x0d\x0a if (rehash) {\x0d\x0a e.hash = null == e.key ? 0 : hash(e.key);\x0d\x0a }\x0d\x0a int i = indexFor(e.hash, newCapacity);\x0d\x0a e.next = newTable[i];\x0d\x0a newTable[i] = e;\x0d\x0a e = next;\x0d\x0a }\x0d\x0a }\x0d\x0a }\x0d\x0a\x0d\x0aHashMap性能的有兩個參數：初始容量(initialCapacity) 和加載因子(loadFactor)。容量 是哈希表中桶的數量，初始容量只是哈希表在創建時的容量。加載因子 是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行 rehash 操作（即重建內部數據結構），從而哈希表將具有大約兩倍的桶數。\x0d\x0a根據源碼分析可以看出：在Java7 中 HashMap的entry是按照index索引存儲的，遇到hash衝突的時候採用拉鏈法解決衝突，將衝突的key和value插入到鏈表list中。\x0d\x0a然而這種解決方法會有一個缺點，假如key值都衝突，HashMap會退化成一個鏈表，get的複雜度會變成O(n)。\x0d\x0a在Java8中為了優化該最壞情況下的性能，採用了平衡樹來存放這些hash衝突的鍵值對，性能由此可以提升至O(logn)。\x0d\x0a代碼塊4 — JDK8中HashMap中常量定義\x0d\x0a static final int DEFAULT_INITIAL_CAPACITY = 1 [] tab; Node p; int n, i;\x0d\x0a if ((tab = table) == null || (n = tab.length) == 0)\x0d\x0a n = (tab = resize()).length; //table為空的時候，n為table的長度\x0d\x0a if ((p = tab[i = (n – 1) hash]) == null)\x0d\x0a tab[i] = newNode(hash, key, value, null); // (n – 1) hash 與Java7中indexFor方法的實現相同，若i位置上的值為空，則新建一個Node，table[i]指向該Node。\x0d\x0a else {\x0d\x0a // 若i位置上的值不為空，判斷當前位置上的Node p 是否與要插入的key的hash和key相同\x0d\x0a Node e; K k;\x0d\x0a if (p.hash == hash \x0d\x0a ((k = p.key) == key || (key != null key.equals(k))))\x0d\x0a e = p;//相同則覆蓋之\x0d\x0a else if (p instanceof TreeNode)\x0d\x0a // 不同，且當前位置上的的node p已經是TreeNode的實例，則再該樹上插入新的node。\x0d\x0a e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);\x0d\x0a else {\x0d\x0a // 在i位置上的鏈表中找到p.next為null的位置，binCount計算出當前鏈表的長度，如果繼續將衝突的節點插入到該鏈表中，會使鏈表的長度大於tree化的閾值，則將鏈錶轉換成tree。\x0d\x0a for (int binCount = 0; ; ++binCount) {\x0d\x0a if ((e = p.next) == null) {\x0d\x0a p.next = newNode(hash, key, value, null);\x0d\x0a if (binCount = TREEIFY_THRESHOLD – 1) // -1 for 1st\x0d\x0a treeifyBin(tab, hash);\x0d\x0a break;\x0d\x0a }\x0d\x0a if (e.hash == hash \x0d\x0a ((k = e.key) == key || (key != null key.equals(k))))\x0d\x0a break;\x0d\x0a p = e;\x0d\x0a }\x0d\x0a }\x0d\x0a if (e != null) { // existing mapping for key\x0d\x0a V oldValue = e.value;\x0d\x0a if (!onlyIfAbsent || oldValue == null)\x0d\x0a e.value = value;\x0d\x0a afterNodeAccess(e);\x0d\x0a return oldValue;\x0d\x0a }\x0d\x0a }\x0d\x0a ++modCount;\x0d\x0a if (++size threshold)\x0d\x0a resize();\x0d\x0a afterNodeInsertion(evict);\x0d\x0a return null;\x0d\x0a }\x0d\x0a\x0d\x0a再看下resize方法，由於需要考慮hash衝突解決時採用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中複雜了一些,\x0d\x0a代碼塊6 — JDK8的resize方法\x0d\x0a inal Node[] resize() {\x0d\x0a Node[] oldTab = table;\x0d\x0a int oldCap = (oldTab == null) ? 0 : oldTab.length;\x0d\x0a int oldThr = threshold;\x0d\x0a int newCap, newThr = 0;\x0d\x0a if (oldCap 0) {\x0d\x0a if (oldCap = MAXIMUM_CAPACITY) {\x0d\x0a threshold = Integer.MAX_VALUE;//如果超過最大容量，無法再擴充table\x0d\x0a return oldTab;\x0d\x0a }\x0d\x0a else if ((newCap = oldCap = DEFAULT_INITIAL_CAPACITY)\x0d\x0a newThr = oldThr 0) // initial capacity was placed in threshold\x0d\x0a newCap = oldThr;\x0d\x0a else { // zero initial threshold signifies using defaults\x0d\x0a newCap = DEFAULT_INITIAL_CAPACITY;\x0d\x0a newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);\x0d\x0a }\x0d\x0a if (newThr == 0) {\x0d\x0a float ft = (float)newCap * loadFactor;\x0d\x0a newThr = (newCap [] newTab = (Node[])new Node[newCap];// 創建容量為newCap的newTab，並將oldTab中的Node遷移過來，這裡需要考慮鏈表和tree兩種情況。