}

}

default 方法是 Java8 接口中新增的，forEachRemaining 方法接收一个 Consumer，我们可以通过该方法简化我们的遍历操作：

/**

• Java8 为 Iterator 新增了 forEachRemaining(Consumer action) 方法

*/

public st Java 开源项目【ali1024.coding.net/public/P7/Java/git】 atic void main(String[] args) {

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

Iterator<Integer> iterator = list.iterator();

iterator.forEachRemaining(System.out::println);

}

Collection 的 removeIf

=======================

Java8 为 Collection 增加了默认的 removeIf 方法，接收一个 Predicate 判断，test 方法结果为 true，就移除对应的元素。

default boolean removeIf(Predicate<? super E> filter) {

Objects.requireNonNull(filter);

boolean removed = false;

final Iterator<E> each = iterator();

while (each.hasNext()) {

// 判断元素是否需要被移除

if (filter.test(each.next())) {

each.remove();

removed = true;

}

}

return removed;

}

下面这段代码移除列表中的偶数元素。

public void testRemoveIf() {

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

list.removeIf(x -> x % 2 == 0);

list.forEach(System.out::println);

}

Stream 操作

============

具体使用可以参照

public void testStream(){

IntStream stream = IntStream.builder().add(1).add(2).add(3).build();

int max = stream.max().getAsInt();

System.out.println(max);

}

List 的 replaceAll

===================

Java8 为 List 接口增加了默认的 replaceAll 方法，需要 UnaryOperator 来替换所有集合元素，UnaryOperator 是一个函数式接口。

default void replaceAll(UnaryOperator<E> operator) {

Objects.requireNonNull(operator);

final ListIterator<E> li = this.listIterator();

while (li.hasNext()) {

li.set(operator.apply(li.next()));

}

}

下面这个示例为每个元素加上 3。

public void testReplaceAll(){

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

list.replaceAll(x -> x + 3);

list.forEach(System.out::println);

}

List 的 sort

=============

Java8 为 List 接口增加了默认的 sort 方法，需要 Comparator 对象来控制元素排，我们可以传入 Lambda 表达式。

default void sort(Comparator<? super E> c) {

Object[] a = this.toArray();

Arrays.sort(a, (Comparator) c);

ListIterator<E> i = this.listIterator();

for (Object e : a) {

i.next();

i.set((E) e);

}

}

下面这个例子将 list 逆序。

public void testSort() {

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

list.sort((x, y) -> y - x);

System.out.println(list);

}

Map 的 ForEach

===============

Map 接口在 Java8 同样也新增了用于遍历的方法：

default void forEach(BiConsumer<? super K, ? super V> action) {

Objects.requireNonNull(action);

for (Map.Entry<K, V> entry : entrySet()) {

K k;

V v;

try {

k = entry.getKey();

v = entry.getValue();

} catch(IllegalStateException ise) {

// this usually means the entry is no longer in the map.

throw new ConcurrentModificationException(ise);

}

action.accept(k, v);

}

}

该方法接收一个二元的参数，分别对应 key 和 value：

private void print(Map<Integer,String> map){

map.forEach((x , y )-> {

System.out.println("x -> " + x + ", y -> " + y);

});

}

为了接下来测试方便，数据先准备一下：

Map<Integer, String> map = new HashMap<>();

{

map.put(1, "hello");

map.put(2, "summer");

map.put(3, "day");

map.put(4, "tqbx");

}

Map 的 remove

==============

Java8 新增了一个 remove(Object key, Object value)方法。

default boolean remove(Object key, Object value) {

// key 存在且 key 对应的 value 确实是传入的 value 才移除

Object curValue = get(key);

if (!Objects.equals(curValue, value) ||

(curValue == null && !containsKey(key))) {

return false;

}

remove(key);

return true;

}

移除 key 为 3 且 value 为 day 的元素。

@Test

public void testRemove(){

map.remove(3,"day");

print(map);

}

Map 的 compute 相关方法

===================

Object compute(Object key, BiFunction remappingFunction)：该方法使用 remappingFunction 根据 key-value 对计算一个新 value，情况如下：

• 只要新 value 不为 null，就使用新 value 覆盖原 value。

• 如果原 value 不为 null，但新 value 为 null，则删除原 key-value 对。

• 如果原 value、新 value 同时为 null 那么该方法不改变任何 key-value 对，直接返回 null。

Object computeIfAbsent(Object key, Function mappingFunction)：

• 如 《一线大厂 Java 面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》开源 果传给该方法的 key 参数在 Map 中对应的 value 为 null，则使用 mappingFunction 根据 key 计算个新的结果。

• 如果计算结果不为 null，则用计算结果覆盖原有的 value。

• 如果原 Map 原来不包括该 key，那么该方法可能会添加一组 key-value 对。

Object computeIfPresent(Object key, BiFunction remappingFunction)：

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份 Java 并发体系思维导图，希望对你有所帮助。