算法-基础（一）数组基本操作 和 静态方法（后面编写算法的时候会用到）

由于后面编写算法涉及一些基础语法，我这边先复习复习有错误望指导。

数组操作

public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}

这边最后一个用了二维数组，二维数组就是一堆数组，二维数组可以长度不一致是参差不齐的，但是二维数组有默认规定i i代表行 j代表列，创建的时候要在类型之后制定行数列数，它的图形结构如下（自己画的大家将就着看）：

静态方法:

/**
 * 静态方法小样类
 * @addPerson ： hzb 2018-3-122
 */
public class StaticDemo {
    public static  void main(String[] args){

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

    /**
     * 计算一个是否素数
     */
    public static boolean abs2(int x){
        if(x < 2){
            return false;
        }
        for(int i =2;i*i<=x;i++){
            if(x % i==0){
                return false;
            }

        }
        return true;
    }

    /**
     * 计算平方根
     * 注意这个地方用的是迭代的方法你们可以搜索一下牛顿迭代法
     */
    public static double abs3(double x){
        if(x < 0){
            return Double.NaN;
        }
        double err = 1e-15;
        double t = x;
        while(Math.abs(t-x/t)>err*t){
            t= (x/t+t)/2.0;

        }
        return t;
    }

  

}

有写错指出望指出 [e-mail]
addPerson ：hzb 2018-3-12 22:29:28