Java ConcurrentHashMap的使用示例

构造方法

// 1.无参数构造方法
new concurrenthashmap();

// 2.指定初始容量
new concurrenthashmap(initialcapacity)

// 3.指定初始容量和加载因子
new concurrenthashmap(initialcapacity,loadfactor)

// 4.指定初始容量和加载因子与并发级别(并发更新线程数)
new concurrenthashmap(initialcapacity, loadfactor, concurrencylevel)

// 5.创建与给定映射具有相同映射的新映射
new concurrenthashmap(map<? extends k, ? extends v> m)

方法介绍

新增元素

// 1.添加元素，不允许null
map.put(1,1);

// 2.添加一个map
map.putall(map);
// 3.添加元素, 键不存在映射关系才添加成功
map.putifabsent(2,1);

删除元素

// 1.移除指定的key
map.remove(1);
// 2.移除指定的key,value 
map.remove(2,2);

替换元素

// 1.替换指定key
map.replace(1,3);

// 2.替换指定key,value
map.replace(1,2,4);

// 3.替换所有，这里是把value都乘以2
map.replaceall((key,value)->value << 1);

查找元素

// 1.返回到指定键所映射的值
map.get("精灵王");

// 2. 返回指定键映射到的值，如果此映射不包含该键的映射，则返回给定的默认值。
map.getordefault("精灵王","jinglingwang.cn");

// 指定搜素函数
// 1.通过在每个（键，值）上应用给定的搜索函数返回非空结果，如果没有则返回null。 
//   成功后，进一步的元素处理被抑制，并且搜索功能的任何其他并行调用的结果被忽略。
object a = map.search(5,(key,value)->{
    return (value & 1) == 0 ? value : null; // 查找第一个偶数，如果是奇数返回null
});

// 2. 每个键上应用给定搜索函数的非null结果，如果没有则返回null。
string k = map.searchkeys(5,(key)->{
    return "jinglingwang".equals(key) ? key : null;
});
system.out.println(k);

// 3. 对每个值应用给定的搜索函数，如果没有，返回null。
integer v2 = map.searchvalues(5,(value)->{
    return value == 2 ? 520 : null;
});
system.out.println(v2);

// 4.从每个entry应用给定的搜索函数，如果没有，则返回null。
integer a = map.searchentries(5,(entry)->{
    system.out.println("entry:"+entry.getkey() + "   " + entry.getvalue());
    return "jinglingwang.cn".equals(entry.getkey()) ? 1 : null;
});
system.out.println(a);

包含

// 1. 验证值是否存在, 等同于map.containsvalue()方法
map.contains(4)

// 2. 验证key是否存在
map.containskey("精灵王")

// 3. 验证值是否存在,等同于map.contains()方法
map.containsvalue(4)

遍历

// 1.返回此表中键的枚举
map.keys();

// 2.返回此地图中包含的键的set视图
map.keyset();

// 3.返回此地图中键的set视图，使用给定的映射值
map.keyset(100)

// 4. 返回此表中值的枚举。
map.elements();

// 5.返回此地图中包含的映射的set视图。
map.entryset().foreach((entry)->{
    system.out.println(entry.getkey() + " " + entry.getvalue());
});

// 6.1 同时遍历key，value
map.foreach((key,value)->{
    system.out.println(key+ " " + value);
});
// 6.2 同时遍历key，value,找到满足条件的执行响应函数
map.foreach(5,(key,value)->{
    system.out.println(key+ " " + value);
    return (value & 1) == 0 ? "jinglingwang.cn" : null;
},aa->{
    system.out.println(aa); // 条件中有偶数，每次就输出jinglingwang.cn
});

// 7.1遍历
map.foreachentry(5,(entry)->{
    system.out.println(entry.getkey() + " " + entry.getvalue());
});

// 7.2遍历查找，满足条件执行响应的函数
map.foreachentry(5,(entry)->{
    system.out.println(entry.getkey() + " " + entry.getvalue());
    return (value & 1) == 0 ? "jinglingwang.cn" : null;
},aa->{
    system.out.println(aa); // 条件中有偶数，每次就输出jinglingwang.cn
});

// 8.1遍历key
map.foreachkey(5,key->{
    system.out.println("key: " + key);
});
// 8.2遍历key,满足条件的key执行响应的函数
map.foreachkey(5,key->{
    system.out.println("key: " + key);
    return !key.equals("jinglingwang") ? "jinglingwang.cn" : null;
},kk ->{
    system.out.println(kk);
});

// 9.1 遍历value
map.foreachvalue(5,value->{
    system.out.println("value: " + value);
});
// 9.2 遍历value,满足条件的value执行响应的函数
map.foreachvalue(5,value->{
    system.out.println("value: " + value);
    return (value & 1) == 0 ? "jinglingwang.cn" : null;
},vv ->{
    system.out.println(vv);
});

reduce归约

reduce()

//新增元素
map.put("1",0);
map.put("2",4);
map.put("3",6);
map.put("4",8);
// 1. 返回使用给定的reducer组合值来累积所有（键，值）对的给定转换的结果，如果没有，则返回null
string res =  map.reduce(5,(key,value)->{
    system.out.println("transformer key:"+key+" value:"+value);
    return value+"";
},(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value+"";
});
system.out.println("res:"+res);

以上示例输出如下：

transformer key:1 value:0
transformer key:2 value:4
reducer key:0 value:4
transformer key:3 value:6
reducer key:04 value:6
transformer key:4 value:8
reducer key:046 value:8
res:0468

第一个transformer函数遍历整个map，然后将返回值传递到reduce函数进行计算，之后reduce函数的返回值再次参与到下一次的reduce函数的计算中。

reducetodouble()

double reducetodouble = map.reducetodouble(5,(key,value)->{
    system.out.println("transformer key:"+key);
    return value;
},100,(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value;
});
system.out.println("reducetodouble:"+reducetodouble);
// 输出结果
transformer key:1 value:0
reducer key:100.0 value:0.0
transformer key:2 value:4
reducer key:100.0 value:4.0
transformer key:3 value:6
reducer key:104.0 value:6.0
transformer key:4 value:8
reducer key:110.0 value:8.0
reducetodouble:118.0

遍历归约所有的键值对，并把结果转换成double类型。

类似的方法还有reducetoint()和reducetolong()。

reduceentries()

// 第一种，返回值为entry
map.entry reduceentries =  map.reduceentries(5,entry->{
    system.out.println("transformer key:"+entry.getkey()+" value:"+entry.getvalue());
    return entry;
},(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return value;
});
system.out.println("reduceentries:"+reduceentries);
// 输出如下
transformer key:1 value:0
transformer key:2 value:4
reducer key:1=0 value:2=4
transformer key:3 value:6
reducer key:2=4 value:3=6
transformer key:4 value:8
reducer key:3=6 value:4=8
reduceentries:4=8

// 第二种
string reduceentries2 =  map.reduceentries(5,(entry)->{
    system.out.println("transformer key:"+entry.getkey()+" value:"+entry.getvalue());
    return entry.getvalue()+"";
},(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value+"";
});
system.out.println("reduceentries2:"+reduceentries2);
transformer key:1 value:0
transformer key:2 value:4
reducer key:0 value:4
transformer key:3 value:6
reducer key:04 value:6
transformer key:4 value:8
reducer key:046 value:8
reduceentries2:0468

transformer 函数每次返回的是一个entry，然后会传入到reduce函数中，reduce的return值会继续传递到下一次的reduce计算。

reduceentriestodouble()

// 返回使用给定的reducer累加给定变换的结果，以组合值，给定基础作为一个标识值
double reduceentriestodouble = map.reduceentriestodouble(5,entry->{
    system.out.println("transformer key:"+entry.getkey()+" value:"+entry.getvalue());
    return double.valueof(entry.getvalue());
},100,(l,r)->{
    system.out.println("reducer key:"+l+" value:"+r);
    return l+r;
});
system.out.println("reduceentriestodouble:"+reduceentriestodouble);
// 输出结果
transformer key:1 value:0
reducer key:100.0 value:0.0
transformer key:2 value:4
reducer key:100.0 value:4.0
transformer key:3 value:6
reducer key:104.0 value:6.0
transformer key:4 value:8
reducer key:110.0 value:8.0
reduceentriestodouble:118.0

其中transformer函数是以entry的形式来进行遍历的，第三个参数是一个归约的标识（初始默认值），功能和reduceentriestoint()和reduceentriestolong()两个方法非常相似。

reducekeys()

// 1.第一种，只有reduce函数，遍历所有的键值对，reduce函数的返回值会作为下一次的key，如果没有则返回null。
string newkey = map.reducekeys(5,(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value;
**}**);
system.out.println("newkey:"+newkey);
// 输出结果
reducer key:1 value:2
reducer key:12 value:3
reducer key:123 value:4
newkey:1234

// 2.第二种，有transformer和reducer 
string newvalue = map.reducekeys(5,(key)->{
    system.out.println("transformer key:"+key);
    return key;
},(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value;
});
system.out.println("newvalue:"+newvalue);
// 输出结果
transformer key:1
transformer key:2
reducer key:1 value:2
transformer key:3
reducer key:12 value:3
transformer key:4
reducer key:123 value:4
newvalue:1234

reducekeystodouble()

double reducekeystodouble = map.reducekeystodouble(5,(key)->{
    system.out.println("transformer key:"+key);
    return double.parsedouble(key);
},100,(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value;
});
system.out.println("reducekeystodouble:"+reducekeystodouble);

遍历归约所有的key，并把结果转换成double类型。

类似的方法还有reducekeystoint()和reducekeystolong()。

reducevalues()

// 第一种：仅reducer函数
double reducevalues = map.reducevalues(5,(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value;
});
system.out.println("reducevalues:"+reducevalues);
//输出结果
reducer key:0 value:4
reducer key:4 value:6
reducer key:10 value:8
reducevalues:18.0

// 第二种，含有transformer
double reducevalues2 = map.reducevalues(5,(value)->{
    system.out.println("transformer value:"+value);
    return double.valueof(value);
},(key,value)->{
    system.out.println("reducer key:"+key+" value:"+value);
    return key+value;
});
system.out.println("reducevalues2:"+reducevalues2);
// 输出结果
transformer value:0
transformer value:4
reducer key:0.0 value:4.0
transformer value:6
reducer key:4.0 value:6.0
transformer value:8
reducer key:10.0 value:8.0
reducevalues2:18.0

reducevaluestodouble()

double reducevaluestodouble = map.reducevaluestodouble(5,(value)->{
    system.out.println("transformer value:"+value);
    return double.valueof(value);
},100,(l,r)->{
    system.out.println("reducer key:"+l+" value:"+r);
    return l+r;
});
system.out.println("reducevaluestodouble:"+reducevaluestodouble);
// 输出结果
transformer value:0
reducer key:100.0 value:0.0
transformer value:4
reducer key:100.0 value:4.0
transformer value:6
reducer key:104.0 value:6.0
transformer value:8
reducer key:110.0 value:8.0
reducevaluestodouble:118.0

遍历归约所有的value，并把结果转换成double类型。

类似的方法还有reducevaluestoint()和reducevaluestolong()。

以上就是java concurrenthashmap的使用示例的详细内容，更多关于java concurrenthashmap的资料请关注其它相关文章！