public class PythagorasTheorem {
    void show() {// limit可以改变生成数的范围
        IntStream.iterate(2, v -> v + 1).limit(10).forEach(v -> {
            IntStream.range(1, v).filter(getIntPredicate(v)).forEach(v1 -> {
                int vDouble = v * v;
                int v1Double = v1 * v1;
                int x = vDouble - v1Double;
                int y = 2 * v * v1;
                int z = vDouble + v1Double;
                System.out.printf("m: %d, n: %d || X: %d, Y: %d, Z: %d\n", v, v1, x, y, z)
            });
        });
    // 把m与n要满足的条件写在这个代码中
    IntPredicate getIntPredicate(int m) {
        return n -> {
            if (m % 2 == 0) {// 这个if语句，用于判断m与n不能同时为奇或同时为偶
                if (n % 2 == 0)
                    return false;
            } else if (n % 2 == 1)
                return false;
            int dividend = m;
            int divisor = n;
            int remainder = dividend % divisor;
            while (remainder != 0) {// 使用辗转相除法，求解m与n的最大公约数
                dividend = divisor;
                divisor = remainder;
                remainder = dividend % divisor;
            if (divisor == 1)// 这个是判断m与n是不是互质
                return true;
            return false;
@Test
void test() {
    PythagorasTheorem pythagorasTheorem = new PythagorasTheorem();
    pythagorasTheorem.show();
// 显示结果
m: 2, n: 1 || X: 3, Y: 4, Z: 5
m: 3, n: 2 || X: 5, Y: 12, Z: 13
m: 4, n: 1 || X: 15, Y: 8, Z: 17
m: 4, n: 3 || X: 7, Y: 24, Z: 25
m: 5, n: 2 || X: 21, Y: 20, Z: 29
m: 5, n: 4 || X: 9, Y: 40, Z: 41
m: 6, n: 1 || X: 35, Y: 12, Z: 37
m: 6, n: 5 || X: 11, Y: 60, Z: 61
m: 7, n: 2 || X: 45, Y: 28, Z: 53
m: 7, n: 4 || X: 33, Y: 56, Z: 65
m: 7, n: 6 || X: 13, Y: 84, Z: 85
m: 8, n: 1 || X: 63, Y: 16, Z: 65
m: 8, n: 3 || X: 55, Y: 48, Z: 73
m: 8, n: 5 || X: 39, Y: 80, Z: 89
m: 8, n: 7 || X: 15, Y: 112, Z: 113
m: 9, n: 2 || X: 77, Y: 36, Z: 85
m: 9, n: 4 || X: 65, Y: 72, Z: 97
m: 9, n: 8 || X: 17, Y: 144, Z: 145
m: 10, n: 1 || X: 99, Y: 20, Z: 101
m: 10, n: 3 || X: 91, Y: 60, Z: 109
m: 10, n: 7 || X: 51, Y: 140, Z: 149
m: 10, n: 9 || X: 19, Y: 180, Z: 181
m: 11, n: 2 || X: 117, Y: 44, Z: 125
m: 11, n: 4 || X: 105, Y: 88, Z: 137
m: 11, n: 6 || X: 85, Y: 132, Z: 157
m: 11, n: 8 || X: 57, Y: 176, Z: 185
m: 11, n: 10 || X: 21, Y: 220, Z: 221
对计算机语言越熟悉越是感觉到基础部分的重要性，数理逻辑，数据结构，算法设计与分析，都是越嚼越有味道，这几天一直在看关于递归以及尽量使用递归做东西，发现越是熟悉，越是觉得递归程式的美妙，我们且跨过递归的薄弱部分不谈，就它的优点足以让我兴奋！下面是我用递归实现的两幅图片，一副是毕达哥拉斯树，就是满足毕达哥拉斯定理（勾股定理）的一个分形树，还有一颗自定义树：
毕达哥拉斯树：
以上...
                                    输入两个正整数 n 和 m (1<m<n<=10)，再输入 n 个整数，将这些数排成一行，向右循环移动 m 个位置（从右边移出的数再从左边移入），最后输出移动后的n个整数。
要求定义并调用函数 mov(x,n,m) 实现上述循环移动的功能，函数形参x的类型是整型指针，形参n和m的类型是int，函数的类型是void。
输出格式：数据之间以空格分隔，最后一个数据集后面没有空格
输入输...
使用函数输出指定范围内的函数：输入两个正整数 m 和 n(1<=m,n<=1000)，
输出 m～n 之 间 的 所 有 完 数 ， 完 数 就 是 因 子 和 与 它 本 身 相 等 的 数 。 要 求 定 义 并 调 用 函 数 factorsum(number)，它的功能是返回 number 的因子和。例如，factorsum(12)的返回值是 16 （1+2+3+4+6）
factorsum(number)返回 number 的因子和，但是我认
                                    public class RangeTest {
	public static void main(String[] args) {
		Stream<int[]> pythagoreanTriples = IntStream.rangeClosed(1, 100)
                .boxed()
				.flatMap(
				        a -> IntStream.rangeClosed(a, 100)
                                    最近在学习java 8 在书中有这样一个例子  给一个数在 100以内求他的勾股数:也就是 sqrt(3*3+4*4)%1=0 那么这样就满足这样的条件 :上代码 :int a = 9;
//1..1000 里面有哪一个值可以满足 勾股
//返回一个数组 int  [a,b,c]
IntStream stream1 = IntStream.rangeClosed(1, 100)  //相当于切片...
约公元前六世纪，相当于古代中国的先秦时期，希腊早期哲学家泰勒斯在希腊创立爱奥尼亚学派。后来，在这个学派基础上产生一个宗教、政治、学术于一体的团体，这个团体，就是我们今天要讨论的古代数学团体：一个以毕达哥拉斯为领袖的毕达哥拉斯学派（约公元前560年-前480年）。
照片1毕达哥拉斯