单一原则

Single responsibility

一个类或模块应仅有一个引起其变化的因素（职责)

一个方法只做一件事

首先看一个计算质数的例子:

   /**
     * 计算给定的数范围内有多少个质数
     *
     */
    public long countPrimes(int max){
        long total = 0;
        for (int i = 2; i <= max ; i++) {
            boolean isPrime = true;
            for (int j = 2; j < i ; j++) {
                if (i % j == 0){
                    isPrime = false;
                    break;
                }
            }
            if (isPrime){
                System.out.println(i);
                total++;
            }
        }
        return total;
    }

这个方法中做了两件事,1. 判断是否是质数, 2. 计数

现在把这个方法中判断是否是质数提取出来

   /**
     * 计算给定的数范围内有多少个质数
     *
     */
    public long countPrimes2(int max){
        long total = 0;
        for (int i = 2; i <= max ; i++) {
            boolean isPrime = isPrime(i);
            if (isPrime){
                System.out.println(i);
                total++;
            }
        }
        return total;
    }


   /**
     *  判断是否是质数
     */
    private boolean isPrime(int i) {
        boolean isPrime = true;
        for (int j = 2; j < i; j++) {
            if (i % j == 0) {
                isPrime = false;
                break;
            }
        }
        return isPrime;
    }

这样每个方法只做一件事.但是在java8之后用流代替循环操作.

如果需要对一个很大的数计数，可以并行操作。线程模型也是代码的职责之一！

   /**
     * java8使用流式计算质数个数
     * @param max
     * @return
     */
    public long countPrimes3(int max){
        return IntStream.range(2, max)
                .peek(System.out::println)
                .filter(this::isPrime8)
                .count();
    }

    private boolean isPrime8(int num){
        boolean flag = IntStream.range(2, num)
                .anyMatch(j -> num % j == 0);
        return !flag;
    }

这里注意和上面稍微有点不一样的,IntStream.range(2, max)包含下界不包含上届

例如:

IntStream.range(2,6)
         .forEach(System.out::println);
// 只会输出
2
3
4
5

range()方法不会输出最大的数
参考<<java8函数式编程>>