Stream.of()用法示例

Posted 2021-09-20 爆米花9958

Stream.of用于为给定元素创建顺序流。我们可以传递单个元素或多个元素。

查看java文档中的Stream.of方法声明。

static Stream of(T t)

参数：传递单个元素。

返回值：该方法返回一个包含一个元素的流。

static <T> Stream<T> of(T... values)

参数：传递多个元素。

返回值：该方法返回包含给定元素的流。

Stream.of创建有限元素流。

为了创建一个无限元素流，我们可以使用Stream.generate方法。

示例1：

让我们创建整数流。

Stream<Integer> mystream = Stream.of(10, 12, 14, 16);

mystream.forEach(e -> System.out.println(e));

输出为10 12 14 16。

示例2：

让我们创建字符串流。

Stream<String> mystream = Stream.of("AA", "BB", "CC", "DD");

mystream.forEach(e -> System.out.println(e));

示例3：

查看创建对象流的示例。

StreamOfObjDemo.java

public class StreamOfObjDemo {
  public static void main(String[] args) {
	Stream<User> userStream = Stream.of(
		new User("Mahesh", 22),
		new User("Krishn", 20),
		new User("Suresh", 25)
	);
	userStream.forEach(u -> System.out.println(u.getUserName()));
  }
}
class User {
  private String userName;
  private int age;
  public User(String userName, int age) {
	this.userName = userName;
	this.age = age;
  }
  //Sets and Gets
} 

输出

Mahesh

Krishn

Suresh

IntStream, LongStream and DoubleStream

IntStream、LongStream和DoubleStream分别是原始int流、原始long流、原始double流的特化。这些接口有许多有用的方法。它们通过使用类中提供的静态方法初始化。

要创建IntStream，我们使用IntStream.of方法。

要创建LongStream，我们使用LongStream.of方法。

为了创建DoubleStream，我们使用DoubleStream.of方法。

查看例子。

StreamOfDemo.java

public class StreamOfDemo {
  public static void main(String[] args) {
	System.out.println("--- IntStream ---");
	IntStream intStream = IntStream.of(12, 14, 16);
	intStream.forEach(e -> System.out.println(e));
	
	System.out.println("--- LongStream ---");	
	LongStream longStream = LongStream.of(154L, 236L, 306L);
	longStream.forEach(e -> System.out.println(e));
	
	System.out.println("--- DoubleStream ---");	
	DoubleStream doubleStream = DoubleStream.of(123.56, 456.87, 784.65);
	doubleStream.forEach(e -> System.out.println(e));	
  }
} 

输出

--- IntStream ---

12

14

16

--- LongStream ---

154

236

306

--- DoubleStream ---

123.56

456.87

784.65

IntStream

java.util.stream.IntStream是一个原始整数值序列。诸如max和average之类的聚合操作可以使用顺序和并行操作来执行。

• rangeClosed(a,b): 对a类加1止到b
• range(a,b) : 考虑从a到b-1的值。
• sum: 计算值的总和。
• sorted: 对值进行排序。

public class IntStreamDemo {
	public static void main(String[] args) {
		System.out.println("--Using IntStream.rangeClosed--");
		IntStream.rangeClosed(13, 15).map(n->n*n).forEach(s->System.out.print(s +" "));
		System.out.println("\\n--Using IntStream.range--");
		IntStream.range(13,15).map(n->n*n).forEach(s->System.out.print(s +" "));
		System.out.println("\\n--Sum of range 1 to 10--");
		System.out.print(IntStream.rangeClosed(1,10).sum());
		System.out.println("\\n--Sorted number--");
		IntStream.of(13,4,15,2,8).sorted().forEach(s->System.out.print(s +" "));
	}
}

输出

--Using IntStream.rangeClosed--
169 196 225 
--Using IntStream.range--
169 196 
--Sum of range 1 to 10--
55
--Sorted number--
2 4 8 13 15  

LongStream

java.util.stream.LongStream是一个原始长整值序列，聚合操作使用顺序和并行操作执行。方法与IntStream相同。

public class LongStreamDemo {
	public static void main(String[] args) {
		System.out.println("--Using LongStream.rangeClosed--");
		LongStream.rangeClosed(13, 15).map(n->n*n).forEach(s->System.out.print(s +" "));
		System.out.println("\\n--Using LongStream.range--");
		LongStream.range(13,15).map(n->n*n).forEach(s->System.out.print(s +" "));
		System.out.println("\\n--Sum of range 1 to 10--");
		System.out.print(LongStream.rangeClosed(1,10).sum());
		System.out.println("\\n--Sorted number--");
		LongStream.of(13,4,15,2,8).sorted().forEach(s->System.out.print(s +" "));
	}
} 

输出

--Using LongStream.rangeClosed--
169 196 225 
--Using LongStream.range--
169 196 
--Sum of range 1 to 10--
55
--Sorted number--
2 4 8 13 15  

DoubleStream

java.util.stream.DoubleStream 是原始 double 值的序列，聚合操作使用顺序和并行操作执行。

• average: 计算平均值。
• max:找到最大值

public class DoubleStreamDemo {
	public static void main(String[] args) {
		System.out.println("--Using DoubleStream.of--");
		DoubleStream.of(5.33,2.34,5.32,2.31,3.51).map(d->d*1.5).forEach(s->System.out.print(s +" "));
		System.out.println("\\n--Using DoubleStream.average--");
		double val = DoubleStream.of(12.1,11.2,13.3).average().getAsDouble();
		System.out.println(val);
		System.out.println("--Using DoubleStream.max--");
		val = DoubleStream.of(12.1,11.2,13.3).max().getAsDouble();
		System.out.println(val);
		System.out.println("--Using DoubleStream.filter--");
		DoublePredicate range = d -> d > 12.11 && d < 12.99;		
		DoubleStream.of(12.1,11.2,12.3).filter(range).forEach(d->System.out.print(d));
	}
} 

输出

--Using DoubleStream.of--
7.995 3.51 7.98 3.465 5.265 
--Using DoubleStream.average--
12.200000000000001
--Using DoubleStream.max--
13.3
--Using DoubleStream.filter--
12.3 

 Stream.of()和Arrays.stream()的区别用法

Java中Arrays类的stream(T [] array)方法用于从作为参数数组中获取顺序流，它返回一个Stream。

Stream of(T…values)返回一个有序的流，其元素为指定值。 Stream.of()方法仅对非基本类型调用Arrays.stream()方法。

下面通过例子说明一下：

String[] arr = { "Geeks", "for", "Geeks" }; 
Stream<String> stream = Arrays.stream(arr); 

Stream stream = Stream.of("Geeks", "for", "Geeks"); 

两者的不同

1. 不同的返回类型：

对于基本数组(如int []，long []等)，Arrays.stream()和Stream.of()具有不同的返回类型。

例：传递一个整数数组，Stream.of()方法返回Stream，而Arrays.stream()返回IntStream。

1. Stream.of()需要展平，而Arrays.stream()不需要展平：

作为处理原始类型的Stream的理想类，是它们的原始Stream类型(例如IntStream，LongStream等)。因此，Stream.of()需要在使用之前显式地展平为其原始Stream。

参考：

https://blog.csdn.net/qq_31635851/article/details/111151900

https://vimsky.com/examples/usage/stream-of-method-in-java.html

https://www.concretepage.com/java/jdk-8/java-8-intstream-longstream-doublestream-example

https://www.concretepage.com/java/java-8/java-stream-of

https://vimsky.com/examples/usage/difference-between-stream-of-and-arrays-stream-method-in-java.html