Java中典型静态方法的实现

在许多语言中，静态方法被称为函数，因为他们和数学函数的性质类似。静态方法是一组在被调用时会被顺序执行的语句。用static将这类方法区别开来。

典型静态方法的实现

---

package com.example.demo.test;

/**
 * @Author: try one
 * @Description:
 * @Date:Create：in 2019/1/16 18:47
 * @Modified By：
 */
public class TestAlgorithms {
    //计算一个整数的绝对值
    public static void main(String[] args) {
//        System.out.println(abs(1212));//使用模板  只需要输入 abs(1212).sout 按回车 这段代码就出现了
//        System.out.println(abs(-1212));
//        System.out.println(isPrime(99));
//        System.out.println(isPrime2(99));
//        System.out.println(sqrt(14));

        System.out.println(sqrt2(5));
    }

    //计算一个整数的绝对值
    public static int abs(int x) {
        if (x > 0) {
            return x;
        } else {
            return -x;
        }
    }

    //计算浮点数的绝对值
    public static double abs(double x) {
        if (x < 0.0) {
            return -x;
        } else {
            return x;
        }
    }

    //判断一个数 是否是素数  （素数：在正整数中  它的约数只有  1 和  它本身）
    public static boolean isPrime(int N) {
        if (N < 2) {
            return false;
        }
        if (N == 2)
            return true;
        for (int i = 3; i <= N; i++) {
            if (N % i == 0) {
                return false;
            }
        }
        return true;
    }

    //判断一个数是否是素数
    public static boolean isPrime2(int N) {
        if (N < 2) {
            return false;
        }
        //为什么这样可行，收敛很快
        for (int i = 2; i * i <= N; i++) {
            if (N % i == 0) {
                return false;
            }
        }
        return true;
    }

    //求一个数的平方根（用二分法）

    /**
     * 二分查找:有三大特性
     * 1.Sorted(单调递增或者递增)
     * 2.Bounded(存在上下界)
     * 3.Accessible by index (能够通过索引访问)
     */
    //二分查找模板如下(利用二分法求一个数的平方根)
    public static int sqrt(int x) {
        if (x == 0 || x == 1) return x;
        int left = 1, right = x, result = 0;
        while (left <= right) {
            int m = (left + right) / 2;
            if (m == x / m) {
                return m;
            } else if (m > x / m) {
                right = m - 1;
            } else {
                left = m + 1;
                result = m;
            }
        }
        return result;
    }

    //求平方根的另一种算法（牛顿迭代法）
    public static double sqrt2(double c) {
        if (c < 0)
            return Double.NaN; //Not a Number
        double err = 1e-15;//1*10^-15
        double t = c;
        while (Math.abs(t - c / t) > err * t)
            t = (c / t + t) / 2.0;
        return t;
    }
    //计算直角三角形的斜边
    public static double hypotenuse(double a,double b)
    {
        return Math.sqrt(a*a+b*b);
    }

    //计算调和级数
    public static double H (int N)
    {
        double sum=0.0;
        for (int i = 0; i < N; i++) {
            System.out.println("取到的值："+sum);
            sum+=1.0/i;
        }
        return sum;
    }

}

牛顿迭代法链接地址：https://zh.wikipedia.org/wiki/%E7%89%9B%E9%A1%BF%E6%B3%95