Stream 的 findFirst 方法在此流中查找第一个元素作为 Optional 。

如果流中没有元素， findFirst 返回空的 Optional 。

如果流没有顺序，那么 findFirst 可以选择任何元素。

如果 findFirst 选择的元素为 null ，它将抛出 NullPointerException 。

在javadoc中的findFirst声明

Optional<T> findFirst() 
返回：findFirst方法返回Optional包含流中第一个元素的元素。
 异常：如果选择null值，findFirst将抛出NullPointerException。
 
findFirst是短路终端操作(short-circuiting terminal operation)，流操作是一组中间操作和终端操作，如果中间操作可以为无限输入生成有限流，则它是短路(short-circuiting)。
 
下面我们来看一组例子
 
示例1：假设我们有一个整数流，并对其调用findFirst方法。
 
Stream.of(50, 60, 70).findFirst()
    .ifPresent(s -> System.out.println(s)); 
输出是50，这是流的第一个元素。
 
FindFirstDemo1.java
 
package com.concretepage;
import java.util.Arrays;
import java.util.List;
public class FindFirstDemo1 {
  public static void main(String[] args) {
	List<String> list = Arrays.asList("Vijay", "Suresh", "Vinod");
	String output = list.stream()
	  .filter(e -> e.startsWith("V")) // Vijay, Vinod
	  .findFirst() //Vijay
	  .orElse("NA");
	System.out.println(output);
	List<Integer> numList = Arrays.asList(31, 32, 33, 34);
	numList.stream()
	  .filter(n -> n % 2 == 0) // 32, 34
	  .findFirst() //32
	  .ifPresent(e -> System.out.println(e));
Vijay
示例2：下面是使用IntStream、LongStream和DoubleStream的findFirst方法的示例。
 
FindFirstDemo2.java
 
package com.concretepage;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
public class FindFirstDemo2 {
  public static void main(String[] args) {
	IntStream intStream = IntStream.of(10, 20, 30, 40);
	intStream.filter(i -> i > 20).findFirst()
	     .ifPresent(i -> System.out.println(i));
	LongStream longStream = LongStream.of(100, 200, 300);
	longStream.filter(l -> l < 250).findFirst()
	     .ifPresent(l -> System.out.println(l));
	DoubleStream doubleStream = DoubleStream.of(100.52, 200.55, 300.66);
	doubleStream.filter(d -> d > 200).findFirst()
	     .ifPresent(l -> System.out.println(l));
200.55 
示例3：下面是带有并行流的findFirst示例。
 
FindFirstDemo3.java
 
package com.concretepage;
import java.util.ArrayList;
import java.util.List;
public class FindFirstDemo3 {
  public static void main(String[] args) {
	List<Employee> list = new ArrayList<>();
	list.add(new Employee("Emp A", 3000));
	list.add(new Employee("Emp B", 4000));
	list.add(new Employee("Emp C", 5000));
	list.add(new Employee("Emp D", 6000));
	list.parallelStream()
	    .filter(e -> e.getSal() >= 4000 && e.getSal() <= 5000)
	    .mapToInt(e -> e.getSal())
	    .findFirst()
		.ifPresent(s -> System.out.println(s));
class Employee {
  private String name;
  private int sal;
  public Employee(String name, int sal) {
	this.name = name;
	this.sal = sal;
  //Sets and Gets
示例4：下面是具有空值的findFirst示例。
 
FindFirstDemo4.java
 
package com.concretepage;
import java.util.stream.Stream;
public class FindFirstDemo4 {
  public static void main(String[] args) {
	Stream.of(null, "A").
	    findFirst().ifPresent(s -> System.out.println(s));
输出将为NullPointerException。
 
【1】Java doc: Stream
 【2】Java Stream findFirst()
                    Stream的findFirst方法在此流中查找第一个元素作为Optional。如果流中没有元素，findFirst返回空的Optional。如果流没有顺序，那么findFirst可以选择任何元素。如果findFirst选择的元素为null，它将抛出NullPointerException。在javadoc中的findFirst声明Optional&lt;T&gt; findFirst() 返回：findFirst方法返回Optional包含流中第一个元素的元素。异常：如果选择null值，f
				
在开发中，经常要判断集合中是否有指定的值，对于在集合中查询匹配数据，可以用到findFirst、findAny、anyMatch、allMatch和noneMatch这些方法。
先造点数据
pigs.add(new Pig(1, "猪爸爸", 31, "M", false));
pigs.add(new Pig(2, "猪妈妈", 28, "F", true));
pigs.add(new Pig(3, "乔治", 2, "M", false));
pigs.add(new Pig(4, "佩奇", 5, 
				
[值，索引] = 查找优先（A，搜索目录） 返回 A 中第一个非零的值和可选的索引。 A 必须是完整的和双重的如果 SEARCHDIR = 'first'（默认）搜索是从第一个索引如果 SEARCHDIR = 'last'，则从最后一个索引开始向后搜索
这是一个 cmex 文件，比使用 FIND 快一个数量级，比使用 MATLAB 循环快两个数量级。
 在 Windows NT/2000 VC 6.0、Linux (gcc 2.95) 和 Solaris 上测试（由 A Pearson 提供）
				
我这边目前是AB两个集合，需要找出集合A中在B中不存在的数据，就为异常数据，因为需要修改集合A中的数据，所以我这边自己写的方法里面传的类，如果不需要的话，其实直接传判断的字段就可以，这个方法也可以多个参数传递，不限制参数类型，个数。其实还是比较好拓展的。
这里其实我不需要这个返回一致数据集合，只是没有参数接收就没进我写的那个方法，所以写了这个，也更方便拓展一点（程序媛比较懒，没深究了，有兴趣的小伙伴可以看看源码啥的告诉我，哈哈哈）
//A.B--表示集合A.B a--表示集合中的a元素 sameDa
				
前言：java 8在使用流时候会用到findAny() 与findFirst() 方法使用，下面就对这两个方法使用结合源码做下区分。
首先我们来看下源码：
这两个方法都是在接口Stream类中：
1 .findFirst() 方法根据命名可以大致知道是获取Optional流中的第一个元素
2 .findAny() 方法是获取Optional 流中任意一个，存在随机性，其实里面也是获取元素中的第一个
具体实现方法是类似的，看下源码ReferencePipeline
    @Override
List<Long> oIds = attrType.stream().
map(s->Long.parseLong(s.getId())).collect(Collectors.toList());
其中 s有属性为Id 类型为String类型 Long.paresLong将s的id转换为Long类型
............
这样倒是可以不报错
但是想不明白，不让放空值这个findFirst()方法返回Optional的意义何在呢?
归根结底有Optional.ofnullable,为什么有Optional.of这种不能放null值的Optional
转载于:https://www.cnblog...
				
Java 8是一个非常重要的版本，它提供了许多新的特性和功能。这里是一些Java 8的新特性的案例：
1. Lambda表达式：Lambda表达式是一种新的匿名函数，允许您直接在代码中传递函数。例如，可以使用lambda表达式来创建并运行线程：
Thread t = new Thread(() -> System.out.println("Hello from a thread!"));
t.start();
2. Stream API：Stream API是Java 8中的一个新功能，允许您使用函数式编程风格处理数据集合。例如，可以使用Stream API计算列表中所有数字的平均值：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
double average = numbers.stream().mapToInt(i -> i).average().getAsDouble();
System.out.println("Average: " + average);
3. 接口的默认方法：在Java 8中，接口可以有默认方法，即在接口中定义的带有实现的方法。这允许在不修改已实现该接口的类的情况下向接口添加新方法。例如，可以定义一个接口来表示形状，并在接口中定义一个默认方法来计算形状的面积：
public interface Shape {
  double getArea();
  default double getPerimeter() {
    return 0;
public class Circle implements Shape {
  private double radius;
  public Circle(double radius) {
    this.radius = radius;
  @Override
  public double getArea() {
    return Math.PI * radius * radius;
这些只是Java 8的一些新特性的例子。