jdk8集合的使用以及lambda表达式
2019-03-07 本文已影响0人
柴崎越
1,代码实例一
List<Integer> list= Arrays.asList(1,2,3,3,4,5,6);
list.forEach(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
});
forEach源码
/**
* Performs the given action for each element of the {@code Iterable}
* until all elements have been processed or the action throws an
* exception. Unless otherwise specified by the implementing class,
* actions are performed in the order of iteration (if an iteration order
* is specified). Exceptions thrown by the action are relayed to the
* caller.
*
对iterable的每个元素执行给定的操作
直到处理完所有元素或操作引发
异常。除非实现类另有指定,否则将按迭代顺序执行操作(如果迭代顺序
已指定)。操作引发的异常将中继到调用方。
* @implSpec
* <p>The default implementation behaves as if:
* <pre>{@code
* for (T t : this)
* action.accept(t);
* }</pre>
*
* @param action The action to be performed for each element
* @throws NullPointerException if the specified action is null
* @since 1.8
*/
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
图片.png
consumer
/**
* Represents an operation that accepts a single input argument and returns no
* result. Unlike most other functional interfaces, {@code Consumer} is expected
* to operate via side-effects.
表示一种操作,传入单个值,且没有返回,不想其他大多数函数式接口,Consumer被认为是有副作用的操作
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #accept(Object)}.
*
* @param <T> the type of the input to the operation
*
* @since 1.8
*/
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
2,代码实例二
list.forEach(i->{
System.out.println(i);
});
list.forEach(System.out::println);
当你ctrl+鼠标点击->和::时,跳
图片.png
3,代码实例三
Conceptually, a functional interface has exactly one abstract
* method. Since {@linkplain java.lang.reflect.Method#isDefault()
* default methods} have an implementation, they are not abstract. If
* an interface declares an abstract method overriding one of the
* public methods of {@code java.lang.Object}, that also does
* <em>not</em> count toward the interface's abstract method count
* since any implementation of the interface will have an
* implementation from {@code java.lang.Object} or elsewhere.
简单来说,函数式接口中只能有一个抽象方法,但是如果和object类中的方法重名,也可以有(可以重写)
@FunctionalInterface
public interface Test03 {
void test();
//会报错
//只能有一个抽象方法
// void test2();
//不会报错,因为他是继承java.lang.Object对象的方法,并不会算大抽象方法里面去
String toString();
}
* <p>Note that instances of functional interfaces can be created with
* lambda expressions, method references, or constructor references.
函数式接口可以通过lambda表达式,函数引用或者构造器引用
4,代码实例4
Test04MyInterface test04MyInterface=()->{
System.out.println("test");
};
System.out.println(test04MyInterface.getClass());
System.out.println(test04MyInterface.getClass().getSuperclass());
System.out.println(test04MyInterface.getClass().getInterfaces()[0]);
lambda表达式创建的相当于是一个对象
5,代码实例6
需求:将list中的字符串内容大写然后输出
List<String> list= Arrays.asList("hello","String","hello world");
//jdk8的写法
list.forEach(i->System.out.println(i));
//需求二:构造新的集合,存放变成大写的数据
List<String> list2=new ArrayList<>();
//写法1
list.forEach(i->{
list.add(i.toUpperCase());
});
list.forEach(i->{
System.out.println(i);
});
//写法2
list.stream().map(item->item.toUpperCase()).forEach(item->System.out.println(item));
//写法3
list.stream().map(String::toUpperCase).forEach(System.out::println);
stream()方法解析
/**
* Returns a sequential {@code Stream} with this collection as its source.
* 返回此集合的序列流
* <p>This method should be overridden when the {@link #spliterator()}
* method cannot return a spliterator that is {@code IMMUTABLE},
* {@code CONCURRENT}, or <em>late-binding</em>. (See {@link #spliterator()}
* for details.)
*
* @implSpec
* The default implementation creates a sequential {@code Stream} from the
* collection's {@code Spliterator}.
*
* @return a sequential {@code Stream} over the elements in this collection
* @since 1.8
*/
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
/**
* Returns a stream consisting of the results of applying the given
* function to the elements of this stream.
* 返回一个流,由以下组成
给定的函数操作此流的元素的结果,返回
* <p>This is an <a href="package-summary.html#StreamOps">intermediate
* operation</a>.
*
* @param <R> The element type of the new stream
* @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
* <a href="package-summary.html#Statelessness">stateless</a>
* function to apply to each element
* @return the new stream
*/
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
图片.png