Программирование функций Java8

задняя часть переводчик функциональное программирование Bootstrap
Программирование функций Java8

Функциональное программирование в Java 8

Функциональное программирование: методология создания приложений. (Идея лямбда-выражения + Stream stream)

Сходства и различия между императивным программированием и функциональным программированием:

  1. Императивное программирование фокусируется на том, что делать, тогда как функциональное программирование фокусируется на том, что делать.

     import java.util.stream.IntStream;

 public class MinDemo {

 	public static void main(String[] args) {
 		int[] nums = {35,65,-55,100,-676,95};
 		
 		//命令式编程（具体怎么做）
 		int min = Integer.MAX_VALUE;
 		for (int i : nums) {
 			if(i < min) {
 				min = i;
 			}
 		}
 		
 		System.out.println(min);
 		
 		//jdk8的函数式编，多线程并行处理（需要做什么）
 		int min2 = IntStream.of(nums).parallel().min().getAsInt();
 		System.out.println(min2);
 	}

 }

  2. Функциональное программирование делает код более читабельным

     public class ThreadDemo {
 	public static void main(String[] args) {
 		//命令式编程中的写法
 		Object target = new Runnable() {
 			@Override
 			public void run() {
 				System.out.println("新建了一个线程");
 			}
 		};
 		new Thread((Runnable) target).start();
 
 		// jdk8 lambda函数式编程中的写法
 		Object target2 = (Runnable)() -> System.out.println("新建了一个线程");
 		Runnable target3 = () -> System.out.println("新建了一个线程");
 		System.out.println(target2 == target3); // false
 		
 		new Thread((Runnable) target2).start();
 	}

 }
Условия, которые необходимо выполнить, чтобы вернуть интерфейс в лямбда-выражении:

  1. Есть способ, который может только интерфейс

  2. Необходимо добавить аннотацию @FunctionalInterface в интерфейс (проверка компилятором)

  3. Методы по умолчанию, добавленные в интерфейсы в JDK8

     package lambda;
 
 import java.text.DecimalFormat;
 import java.util.Arrays;
 import java.util.function.Function;
 
 @FunctionalInterface
 interface Interface1 {
 	int doubleNum(int i);
 
 	default int add(int x, int y) {
 		return x + y;
 	}
 
 	static int sub(int x, int y) {
 		return x - y;
 	}
 }
 
 @FunctionalInterface
 interface Interface2 {
 	int doubleNum(int i);
 
 	default int add(int x, int y) {
 		return x + y;
 	}
 }
 
 @FunctionalInterface
 interface Interface3 extends Interface2, Interface1 {
 
 	@Override
 	default int add(int x, int y) {
 		return Interface1.super.add(x, y);
 	}
 
 }
 
 public strictfp class LambdaDemo1 {
 
 	public static void main(String[] args) {
 		Interface1 i1 = (i) -> i * 2;
 
 		Interface1.sub(10, 3);
 		System.out.println(i1.add(3, 7));
 		System.out.println(i1.doubleNum(20));
 
 		Interface1 i2 = i -> i * 2;
 
 		Interface1 i3 = (int i) -> i * 2;
 
 		Interface1 i4 = (int i) -> {
 			System.out.println("-----");
 			return i * 2;
 		};
 	}
 }
Цепочка операций функционального интерфейса, поставляемого с JDK8:
class Money {
	private final int money;

	public MyMoney(int money) {
		this.money = money;
	}

	public void printMoney(Function<Integer, String> moneyFormat) {
		System.out.println("我的存款" + moneyFormat.apply(this.money));
	}
}

public class MoneyDemo {

	public static void main(String[] args) {
		Money me = new Money(99999999);

		Function<Integer, String> moneyFormat = i -> new DecimalFormat("#,###")
				.format(i);
		
		// 函数接口的链式操作
		me.printMoney(moneyFormat.andThen(s -> "人们币" + s));
	}

}
Другие функции интерфейса, поставляемые с JdK8

import java.util.function.Consumer;
import java.util.function.IntPredicate;

public class FunctionDemo {
	
	public static void main(String[] args) {
		// 断言函数接口
		IntPredicate predicate = i -> i > 0;
		System.out.println(predicate.test(-9));//false
		
		// IntConsumer
		// 消费函数接口
		Consumer<String> consumer = s -> System.out.println(s);
		consumer.accept("输入的数据");//输入的数据
	}

}

Ссылки на методы в лямбде в Java8:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.IntUnaryOperator;

class Dog {
	private String name = "哮天犬";

	/**
	 * 默认10斤狗粮
	 */
	private int food = 10;

	public Dog() {

	}

	/**
	 * 带参数的构造函数
	 * 
	 * @param name
	 */
	public Dog(String name) {
		this.name = name;
	}

	/**
	 * 狗叫，静态方法
	 * 
	 * @param dog
	 */
	public static void bark(Dog dog) {
		System.out.println(dog + "叫了");
	}

	/**
	 * 吃狗粮 JDK
	 * 
	 * 默认会把当前实例传入到非静态方法，参数名为this，位置是第一个；
	 * 
	 * @param num
	 * @return 还剩下多少斤
	 */
	public int eat(int num) {
		System.out.println("吃了" + num + "斤狗粮");
		this.food -= num;
		return this.food;
	}

	@Override
	public String toString() {
		return this.name;
	}
}

public class MethodRefrenceDemo {

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.eat(3);

		// 方法引用
		Consumer<String> consumer = System.out::println;
		consumer.accept("接受的数据");

		// 静态方法的方法引用
		Consumer<Dog> consumer2 = Dog::bark;
		consumer2.accept(dog);

		// 非静态方法，使用对象实例的方法引用
		// Function<Integer, Integer> function = dog::eat;
		// UnaryOperator<Integer> function = dog::eat;
		IntUnaryOperator function = dog::eat;
		
		// dog置空，不影响下面的函数执行，因为java 参数是传值
		dog = null;//java中的函数是值传递不是传引用，所以不会出现空指针异常
		System.out.println("还剩下" + function.applyAsInt(2) + "斤");
		
		// 使用类名来方法引用
		// BiFunction<Dog, Integer, Integer> eatFunction = Dog::eat;
		// System.out.println("还剩下" + eatFunction.apply(dog, 2) + "斤");
		
		// 构造函数的方法引用
		// Supplier<Dog> supplier = Dog::new;
		// System.out.println("创建了新对象：" + supplier.get());
		
		// 带参数的构造函数的方法引用
		// Function<String, Dog> function2 = Dog::new;
		// System.out.println("创建了新对象：" + function2.apply("旺财"));

		// 测试java变量是传值还是传引用即值传递
		List<String> list = new ArrayList<>();
		test(list);

		System.err.println(list);
	}

	private static void test(List<String> list) {
		list = null;
	}
}

Каскадные выражения и каррирование функций в лямбда-выражениях

import java.util.function.Function;

/**
 * 级联表达式和柯里化 
 * 柯里化:把多个参数的函数转换为只有一个参数的函数 
 * 柯里化的目的：函数标准化
 * 高阶函数：就是返回函数的函数
 */
public class CurryDemo {

	public static void main(String[] args) {
		// 实现了x+y的级联表达式
		Function<Integer, Function<Integer, Integer>> fun = x -> y -> x
				+ y;
		System.out.println(fun.apply(2).apply(3));

		Function<Integer, Function<Integer, Function<Integer, Integer>>> fun2 = x -> y -> z -> x
				+ y + z;
		//函数的柯里化
		System.out.println(fun2.apply(2).apply(3).apply(4));

		int[] nums = { 2, 3, 4 };
		Function f = fun2;
		
		//柯里化的函数的递归调用
		for (int i = 0; i < nums.length; i++) {
			if (f instanceof Function) {
				Object obj = f.apply(nums[i]);
				if (obj instanceof Function) {
					f = (Function) obj;
				} else {
					System.out.println("调用结束：结果为" + obj);
				}
			}
		}
	}
}

Лямбда-основной принцип реализации

  1. Компилятор генерирует метод для каждого лямбда-выражения. Имя метода — lambda$0,1,2,3, но выражение, на которое ссылается метод, не создает метод.
  2. В месте лямбда будет сгенерирована инструкция invokeDynamic, эта инструкция вызовет bootstrap (бутстрап), метод начальной загрузки будет указывать на автоматически сгенерированную лямбду $0 Метод или метод, на который ссылается метод.
  3. Метод начальной загрузки используется для вызова статического метода LambdaMetafactory.metafactory. Метод возвращает CallSite (сайт вызова), который содержит MethodHandle (дескриптор метода). То есть метод, который вызывается в конце концов.
  4. Метод начальной загрузки будет вызываться только один раз.

Автоматически сгенерированный метод:

1).Ввод и вывод такие же, как лямбда

2). Если это не используется, то это статический метод, в противном случае это метод-член

Создание потокового потока:

Stream流的创建

public static void main(String[] args) {
	List<String> list = new ArrayList<>();

	// 从集合创建
	list.stream();
	list.parallelStream();

	// 从数组创建
	Arrays.stream(new int[] { 2, 3, 5 });

	// 创建数字流
	IntStream.of(1, 2, 3);
	IntStream.rangeClosed(1, 10);

	// 使用random创建一个无限流
	new Random().ints().limit(10);
	Random random = new Random();

	// 自己产生流
	Stream.generate(() -> random.nextInt()).limit(20);

}

Промежуточная операция Stream stream:

Stream流的中间操作

public static void main(String[] args) {
	String str = "my name is 007";

	// 把每个单词的长度调用出来
	Stream.of(str.split(" ")).filter(s -> s.length() > 2)
			.map(s -> s.length()).forEach(System.out::println);

	// flatMap A->B属性(是个集合), 最终得到所有的A元素里面的所有B属性集合
	// intStream/longStream 并不是Stream的子类, 所以要进行装箱 boxed
	Stream.of(str.split(" ")).flatMap(s -> s.chars().boxed())
			.forEach(i -> System.out.println((char) i.intValue()));

	// peek 用于debug. 是个中间操作,和 forEach 是终止操作
	System.out.println("--------------peek------------");
	Stream.of(str.split(" ")).peek(System.out::println)
			.forEach(System.out::println);

	// limit 使用, 主要用于无限流
	new Random().ints().filter(i -> i > 100 && i < 1000).limit(10)
			.forEach(System.out::println);

}

Операция завершения потока Stream:

Stream流的中间操作

public static void main(String[] args) {
	String str = "my name is 007";

	// 使用并行流
	str.chars().parallel().forEach(i -> System.out.print((char) i));
	System.out.println();
	// 使用 forEachOrdered 保证顺序
	str.chars().parallel().forEachOrdered(i -> System.out.print((char) i));

	// 收集到list
	List<String> list = Stream.of(str.split(" "))
			.collect(Collectors.toList());
	System.out.println(list);

	// 使用 reduce 拼接字符串
	Optional<String> letters = Stream.of(str.split(" "))
			.reduce((s1, s2) -> s1 + "|" + s2);
	System.out.println(letters.orElse(""));

	// 带初始化值的reduce
	String reduce = Stream.of(str.split(" ")).reduce("",
			(s1, s2) -> s1 + "|" + s2);
	System.out.println(reduce);

	// 计算所有单词总长度
	Integer length = Stream.of(str.split(" ")).map(s -> s.length())
			.reduce(0, (s1, s2) -> s1 + s2);
	System.out.println(length);

	// max 的使用
	Optional<String> max = Stream.of(str.split(" "))
			.max((s1, s2) -> s1.length() - s2.length());
	System.out.println(max.get());

	// 使用 findFirst 短路操作
	OptionalInt findFirst = new Random().ints().findFirst();
	System.out.println(findFirst.getAsInt());
}
Параллельные потоки в Stream:
public static void main(String[] args) {
	// 调用parallel 产生一个并行流
	// IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

	// 现在要实现一个这样的效果: 先并行,再串行
	// 多次调用 parallel / sequential, 以最后一次调用为准.
	// IntStream.range(1, 100)
	// // 调用parallel产生并行流
	// .parallel().peek(StreamDemo5::debug)
	// // 调用sequential 产生串行流
	// .sequential().peek(StreamDemo5::debug2)
	// .count();

	// 并行流使用的线程池: ForkJoinPool.commonPool
	// 默认的线程数是 当前机器的cpu个数
	// 使用这个属性可以修改默认的线程数
	// System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism",
	// "20");
	// IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

	// 使用自己的线程池, 不使用默认线程池, 防止任务被阻塞
	// 线程名字 : ForkJoinPool-1
	ForkJoinPool pool = new ForkJoinPool(20);
	pool.submit(() -> IntStream.range(1, 100).parallel()
			.peek(StreamDemo5::debug).count());
	pool.shutdown();
	
	synchronized (pool) {
		try {
			pool.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

public static void debug(int i) {
	System.out.println(Thread.currentThread().getName() + " debug " + i);
	try {
		TimeUnit.SECONDS.sleep(3);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

public static void debug2(int i) {
	System.err.println("debug2 " + i);
	try {
		TimeUnit.SECONDS.sleep(3);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

Механизм ленивой загрузки в лямбде: если операция завершения не вызывается в лямбде, все процессы в середине не будут выполняться.

import org.apache.commons.collections4.MapUtils;

/**
 * 学生 对象
 */
class Student {
	/**
	 * 姓名
	 */
	private String name;

	/**
	 * 年龄
	 */
	private int age;

	/**
	 * 性别
	 */
	private Gender gender;

	/**
	 * 班级
	 */
	private Grade grade;

	public Student(String name, int age, Gender gender, Grade grade) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.grade = grade;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Grade getGrade() {
		return grade;
	}

	public void setGrade(Grade grade) {
		this.grade = grade;
	}

	public Gender getGender() {
		return gender;
	}

	public void setGender(Gender gender) {
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "[name=" + name + ", age=" + age + ", gender=" + gender
				+ ", grade=" + grade + "]";
	}

}

/**
 * 性别
 */
enum Gender {
	MALE, FEMALE
}

/**
 * 班级
 */
enum Grade {
	ONE, TWO, THREE, FOUR;
}

public class CollectDemo {

	public static void main(String[] args) {
		// 测试数据
		List<Student> students = Arrays.asList(
				new Student("小明", 10, Gender.MALE, Grade.ONE),
				new Student("大明", 9, Gender.MALE, Grade.THREE),
				new Student("小白", 8, Gender.FEMALE, Grade.TWO),
				new Student("小黑", 13, Gender.FEMALE, Grade.FOUR),
				new Student("小红", 7, Gender.FEMALE, Grade.THREE),
				new Student("小黄", 13, Gender.MALE, Grade.ONE),
				new Student("小青", 13, Gender.FEMALE, Grade.THREE),
				new Student("小紫", 9, Gender.FEMALE, Grade.TWO),
				new Student("小王", 6, Gender.MALE, Grade.ONE),
				new Student("小李", 6, Gender.MALE, Grade.ONE),
				new Student("小马", 14, Gender.FEMALE, Grade.FOUR),
				new Student("小刘", 13, Gender.MALE, Grade.FOUR));

		// 得到所有学生的年龄列表
		// s -> s.getAge() --> Student::getAge , 不会多生成一个类似 lambda$0这样的函数
		Set<Integer> ages = students.stream().map(Student::getAge)
				.collect(Collectors.toCollection(TreeSet::new));
		System.out.println("所有学生的年龄:" + ages);

		// 统计汇总信息
		IntSummaryStatistics agesSummaryStatistics = students.stream()
				.collect(Collectors.summarizingInt(Student::getAge));
		System.out.println("年龄汇总信息:" + agesSummaryStatistics);

		// 分块
		Map<Boolean, List<Student>> genders = students.stream().collect(
				Collectors.partitioningBy(s -> s.getGender() == Gender.MALE));
		// System.out.println("男女学生列表:" + genders);
		MapUtils.verbosePrint(System.out, "男女学生列表", genders);

		// 分组
		Map<Grade, List<Student>> grades = students.stream()
				.collect(Collectors.groupingBy(Student::getGrade));
		MapUtils.verbosePrint(System.out, "学生班级列表", grades);

		// 得到所有班级学生的个数
		Map<Grade, Long> gradesCount = students.stream().collect(Collectors
				.groupingBy(Student::getGrade, Collectors.counting()));
		MapUtils.verbosePrint(System.out, "班级学生个数列表", gradesCount);

	}

}

Механизм запуска лямбда-выражения:

Проверить операционный механизм потока

  1. Все операции связаны, элемент повторяется только один раз

  2. Каждая промежуточная операция возвращает новый поток, который имеет свойство sourceStage. Укажите на то же место, что и Голова

  3. Head->nextStage->nextStage->... -> null (нижний уровень поддерживает структуру данных связанного списка)

  4. Операции с отслеживанием состояния будут обрабатывать фазу операции без сохранения состояния отдельно.

  5. В параллельной среде промежуточные операции с отслеживанием состояния не обязательно могут выполняться параллельно.

  6. параллельные/последовательные эти две операции также являются промежуточными операциями (также обратным потоком) Но они не создают поток, они лишь модифицируют головку параллельной метки.

    public class RunStream {

       public static void main(String[] args) {
   	Random random = new Random();
   	// 随机产生数据
   	Stream<Integer> stream = Stream.generate(() -> random.nextInt())
   			// 产生500个 ( 无限流需要短路操作. )
   			.limit(500)
   			// 第1个无状态操作
   			.peek(s -> print("peek: " + s))
   			// 第2个无状态操作
   			.filter(s -> {
   				print("filter: " + s);
   				return s > 1000000;
   			})
   			// 有状态操作
   			.sorted((i1, i2) -> {
   				print("排序: " + i1 + ", " + i2);
   				return i1.compareTo(i2);
   			})
   			// 又一个无状态操作
   			.peek(s -> {
   				print("peek2: " + s);
   			}).parallel();

   	// 终止操作
   	stream.count();
   }

   /**
    * 打印日志并sleep 5 毫秒
    * 
    * @param s
    */
   public static void print(String s) {
   	// System.out.println(s);
   	// 带线程名(测试并行情况)
   	System.out.println(Thread.currentThread().getName() + " > " + s);
   	try {
   		TimeUnit.MILLISECONDS.sleep(5);
   	} catch (InterruptedException e) {
   	}
   }

    }

Категории