并发编程：并行反应式流：创建流（parallelStream()）

最新推荐文章于 2023-10-07 09:02:19 发布

博风

最新推荐文章于 2023-10-07 09:02:19 发布

阅读量462

点赞数

分类专栏：并发编程 # JavaBase # Stream 文章标签： stream java 并发编程

本文链接：https://blog.csdn.net/Bof_jangle/article/details/108350870

版权

并发编程同时被 3 个专栏收录

68 篇文章 0 订阅

订阅专栏

JavaBase

39 篇文章 0 订阅

订阅专栏

Stream

13 篇文章 0 订阅

订阅专栏

一、主程序

package xyz.jangle.thread.test.n6_2.create;

import java.io.BufferedReader;
import java.io.FileReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.DoubleStream;
import java.util.stream.Stream;

/**
 * 6.2、使用不同的源创建流
 * 
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年9月1日 下午6:03:15
 * 
 */
public class M {

	public static void main(String[] args) {

		// 从一个Collection中创建流
		System.out.println("从一个Collection中创建流");
		List<Person> persons = PersonGenerator.generatePersonList(10000);
		Stream<Person> parallelStream = persons.parallelStream();
		System.out.println("流总数：" + parallelStream.count());

		// 从Supplier中创建流
		System.out.println("从Supplier中创建流");
		MySupplier mySupplier = new MySupplier();
		Stream<String> generate = Stream.generate(mySupplier);
		generate.parallel().limit(10).forEach(p -> System.out.println(p));

		// 从一个定义好的元素集合上创建流
		System.out.println("从一个定义好的元素集合上创建流");
		Stream<String> stream = Stream.of("1", "2", "3", "4A");
		stream.parallel().forEach(p -> System.out.println(p));

		// 从一个文件中创建流
		System.out.println("从一个文件中创建流");
		try (BufferedReader br = new BufferedReader(new FileReader("C:\\logs\\myTestDemo\\log.log"));) {
			Stream<String> lines = br.lines();
			System.out.println("文件总共行数" + lines.count());
			System.out.println("***********************");
			br.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 创建一个目录流
		System.out.println("创建一个目录流");
		try {
			Stream<Path> directoryContent = Files.list(Paths.get(System.getProperty("user.home")));
			System.out
					.println(System.getProperty("user.home") + "目录下的文件和文件夹数量为：" + directoryContent.parallel().count());
//			Files.list(Paths.get(System.getProperty("user.home"))).parallel().forEach(p -> System.out.println(p.getFileName()));
			directoryContent.close();
			System.out.println("***********************");
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 使用一个数组创建流
		System.out.println("使用一个数组创建流");
		String array[] = { "1", "2", "3", "4", "5" };
		Stream<String> streamFromArray = Arrays.stream(array);
		streamFromArray.parallel().forEach(p -> System.out.println(p));

		// 创建一个双精度型数字流
		System.out.println("创建一个双精度型数字流");
		Random random = new Random();
		DoubleStream doubleStream = random.doubles(10);
		double asDouble = doubleStream.parallel().peek(p -> System.out.println(p)).average().getAsDouble();
		System.out.println("平均值" + asDouble);

		// 连接两个流
		System.out.println("连接两个流");
		Stream<String> s1 = Stream.of("1", "2", "3", "4", "5");
		Stream<String> s2 = Stream.of("0", "9", "8", "7", "6");
		Stream<String> concat = Stream.concat(s1, s2);
		concat.parallel().forEach(p -> System.out.println(p));

	}

}

二、雇员类

package xyz.jangle.thread.test.n6_2.create;

import java.util.Date;

/**
 * 	普通类，雇员信息
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年9月1日 下午6:03:57
 * 
 */
public class Person implements Comparable<Person> {

	private int id;
	private String firstName, lastName;
	private Date birthDate;
	private int salary;
	private double coeficient;

	@Override
	public int compareTo(Person o) {
		int compareLastNames = this.getLastName().compareTo(o.getLastName());
		if (compareLastNames != 0) {
			return compareLastNames;
		} else {
			return this.getFirstName().compareTo(o.getFirstName());
		}
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public Date getBirthDate() {
		return birthDate;
	}

	public void setBirthDate(Date birthDate) {
		this.birthDate = birthDate;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public double getCoeficient() {
		return coeficient;
	}

	public void setCoeficient(double coeficient) {
		this.coeficient = coeficient;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Person) {
			return this.compareTo((Person) obj) == 0;
		} else {
			return false;
		}
	}

	@Override
	public int hashCode() {
		String sequence = this.getLastName() + this.getFirstName();
		return sequence.hashCode();
	}

}

三、雇员工厂类

package xyz.jangle.thread.test.n6_2.create;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Random;

/**
 * 雇员工厂类
 * 
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年9月1日 下午6:09:56
 * 
 */
public class PersonGenerator {

	public static List<Person> generatePersonList(int size) {
		List<Person> ret = new ArrayList<>();
		String firstNames[] = { "A", "B", "C", "D", "E", "F", "G" };
		String lastNames[] = { "Z", "Y", "X", "W", "V", "U", "T" };
		Random r = new Random();
		for (int i = 0; i < size; i++) {
			Person person = new Person();
			person.setId(i);
			person.setFirstName(firstNames[r.nextInt(7)]);
			person.setLastName(lastNames[r.nextInt(7)]);
			person.setSalary(r.nextInt(100000));
			person.setCoeficient(r.nextDouble() * 10);
			Calendar calendar = Calendar.getInstance();
			calendar.add(Calendar.YEAR, -r.nextInt(30));
			Date date = calendar.getTime();
			person.setBirthDate(date);
			ret.add(person);
		}
		return ret;
	}

	public static void main(String[] args) {
		Random r = new Random();
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.YEAR, -r.nextInt(30));
		Date date = calendar.getTime();
		System.out.println(date);
	}
}

四、自定义的Supplier类

package xyz.jangle.thread.test.n6_2.create;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;

/**
 * 	Supplier类
 * @author jangle
 * @email jangle@jangle.xyz
 * @time 2020年9月1日 下午6:23:07
 * 
 */
public class MySupplier implements Supplier<String> {

	private final AtomicInteger counter;

	public MySupplier() {
		counter = new AtomicInteger();
	}

	@Override
	public String get() {
		int v = counter.getAndAdd(1);
		return "String " + v;
	}
	
	public static void main(String[] args) {
		MySupplier mySupplier = new MySupplier();
		String string = mySupplier.get();
		System.out.println(string);
	}

}

五、执行结果

从一个Collection中创建流：
流总数：10000
从Supplier中创建流：
String 0
String 1
String 2
String 3
String 4
String 5
String 6
String 7
String 8
String 9
从一个定义好的元素集合上创建流：
3
1
2
4A
从一个文件中创建流：
文件总共行数547
***********************
创建一个目录流：
C:\Users\jangl目录下的文件和文件夹数量为：48
***********************
使用一个数组创建流：
3
4
1
5
2
创建一个双精度型数字流：
0.9286771067836513
0.8593370268418871
0.4878854359545084
0.5024670874334626
0.5431428356626822
0.7909467797726744
0.30035926165462845
0.6771305053536314
0.5613468358268507
0.18463790001057356
平均值0.583593077529455
连接两个流：
9
0
4
5
7
8
2
3
6
1