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);
// 先获取原值