Java8的这些集合骚操作,你掌握了嘛?,linux资料

default void forEach(Consumer<? super T> action) {

Objects.requireNonNull(action);

for (T t : this) {

action.accept(t);

}

}

下面这段代码遍历输出每个元素。

public void testForEach(){

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

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

}

Iterator的forEachRemaining

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

java.util.Iterator是用于遍历集合的迭代器,接口定义如下:

public interface Iterator {

boolean hasNext();

E next();

default void remove() {

throw new UnsupportedOperationException(“remove”);

}

default void forEachRemaining(Consumer<? super E> action) {

Objects.requireNonNull(action);

while (hasNext())

action.accept(next());

}

}

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

/**

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

*/

public static void main(String[] args) {

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

Iterator 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 each = iterator();

while (each.hasNext()) {

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

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

each.remove();

removed = true;

}

}

return removed;

}

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

public void testRemoveIf() {

List 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 operator) {

Objects.requireNonNull(operator);

final ListIterator li = this.listIterator();

while (li.hasNext()) {

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

}

}

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

public void testReplaceAll(){

List 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 i = this.listIterator();

for (Object e : a) {

i.next();

i.set((E) e);

}

}

下面这个例子将list逆序。

public void testSort() {

List 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):

  • 如果传给该方法的key参数在Map中对应的value为null,则使用mappingFunction根据key计算个新的结果。

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

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

Object computeIfPresent(Object key, BiFunction remappingFunction):

  • 如果传给该方法的key参数Map中对应的value不为null,该方法将使用remappingFunction根据原key、value计算一个新的结果。

  • 如果计算结果不为null,则使用该结果覆盖原来的value。

  • 如果计算结果为null,则删除原key-value对。

@Test

public void testCompute() {

//key==2 对应的value存在时,使用计算的结果作为新value

map.computeIfPresent(2, (k, v) -> v.toUpperCase());

print(map);

//key==6 对应的value为null (或不存在)时,使用计算的结果作为新value

map.computeIfAbsent(6, (k) -> k + “haha”);

print(map);

}

Map的getOrDefault

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

default V getOrDefault(Object key, V defaultValue) {

V v;

// key存在或 value存在,则返回对应的value,否则返回defaultValue

return (((v = get(key)) != null) || containsKey(key))

? v
defaultValue;

}

@Test

public void testGetOrDefault(){

// 获取指定key的value,如果该key不存在,则返回default

String value = map.getOrDefault(5, “如果没有key==5的value,就返回这条信息”);

System.out.println(value);

}

Map的merge

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

default V merge(K key, V value,

BiFunction<? super V, ? super V, ? extends V> remappingFunction) {

Objects.requireNonNull(

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开:qq.cn.hn/FTf 免费领取

remappingFunction);

Objects.requireNonNull(value);

// 先获取原值

上一篇:java8中的Collectors.groupingBy用法


下一篇:解读Java8的Thread源码