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两种情况。