nico对《Java 8函数式编程》的笔记(33)

  • 第78页
    数组上的并行化操作
    
    1. parallelPrefix 任意给定一个函数,计算数组的和 2. parallelSetAll 使用Lambda表达式更新数组元素 3. parallelSort 并行化对数组元素排序
    例6-8 使用并行化数组操作初始化数组
    @Test
    public void test6_8() {
    	double[] values = parallelInitialize(10);
    	Arrays.stream(values).forEach(System.out::println);
    }
    
    public static double[] parallelInitialize(int size) {
    	double[] values = new double[size];
    	Arrays.parallelSetAll(values, i -> i + 0.1);
    	return values;
    }
    
    2016-07-27 08:28:25 回应
  • 第80页
    2. 例6-11中的代码把列表中的数字相乘,然后再将所得结果乘以5。顺序执行这段程序没有问题,但并行执行时有一个缺陷,使用流并行化执行该段代码,并修复缺陷。
    例6-11 把列表中的数字相乘,然后再将所得结果乘以5,该实现有一个缺陷
    // 串行reduce初始值为任意值并不会有问题
    public static int multiplyThrough(List<Integer> linkedListOfNumbers) {
    	return linkedListOfNumbers.stream().reduce(5, (acc, x) -> x * acc);
    }
    
    @Test
    public void test6_9_2() {
    	List<Integer> linkedListOfNumbers = Arrays.asList(1, 2, 3, 4, 5);
    	System.out.println("multiplyThrough: " + multiplyThrough(linkedListOfNumbers));
    	System.out.println("serialMultiplyThrough: " + serialMultiplyThrough(linkedListOfNumbers));
    }
    
    // 并行reduce初始值必须为特定值,所以为了保持结果不变,把最终结果 * 5
    public static int serialMultiplyThrough(List<Integer> linkedListOfNumbers) {
    	return 5 * linkedListOfNumbers.parallelStream().reduce(1, (acc, x) -> x * acc);
    }	
    
    3.例6-12中的代码计算列表中数字的平方和。尝试改进代码性能,但不得牺牲代码质量。只需要一些简单的改动即可。
    例6-12 求列表元素的平方和,该实现方式性能不高
    public int solwSumOfSquares(List<Integer> linkedListOfNumbers) {
    	return linkedListOfNumbers.parallelStream().map(x -> x * x)
                  .reduce(0, (acc, x) -> acc + x);
    }
    
    @Test
    public void test6_9_3() {
    	List<Integer> linkedListOfNumbers = Arrays.asList(1, 2, 3, 4, 5);
    	System.out.println("solwSumOfSquares: " + solwSumOfSquares(linkedListOfNumbers));
    	System.out.println("fastSumOfSquares: " + fastSumOfSquares(linkedListOfNumbers));
    	System.out.println("serialFastSumOfSquares: " + serialFastSumOfSquares(linkedListOfNumbers));
    }
    	
    // 高效并行计算
    public int fastSumOfSquares(List<Integer> linkedListOfNumbers) {
    	return linkedListOfNumbers.parallelStream().mapToInt(x -> x * x).sum();
    }
    	
    // 高效串行计算
    public int serialFastSumOfSquares(List<Integer> linkedListOfNumbers) {
    	return linkedListOfNumbers.stream().mapToInt(x -> x * x).sum();
    }
    
    2016-07-27 08:59:55 回应
  • 第90页
    1. 重构遗留代码时考虑如何使用Lambda表达式,有一些通用的模式。 2. 如果想要对复杂一点的Lambda表达式编写单元测试,将其抽取成一个常规的方法。 3. peek方法能记录中间值,在调试时非常有用。
    2016-07-27 23:43:16 回应
<前页 1 2 3 4 后页>

nico的其他笔记  · · · · · ·  ( 全部41条 )