递归与 数组操作理解

递归

这个名词怎么解释呢？ 在程序中程序调用自身的编程技巧称为递归，这样也是比较好理解的，首先递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂问题，同时可以让代码变得简洁，举一个栗子

package com.haiyan.test;
/**递归demo*/
public class demo {
    public static void main(String[] args) {
        demo t=new demo();
       int a= t.ss(5);
       System.out.println(a);
    }

    public int ss(int num){
        if(num==0){
            return 1;
        }
        int ss=ss(num-1)*5;
        int s1=ss(num-1)*5;
        return  ss;  //最终得出  3125
  }
}

这个3125是怎么得出的呢？

需要注意事情是，递归中一定要做数据if判断值校验，否则会变成死循环，这里只是举一个简单易懂的例子，当然了还有很多其他情况也是可以使用的，例如阶乘，递减，递增 或者是其它调用操作也是可以用次数控制判断调用处理其他逻辑的，看情况而定，这里只是写的没有复杂情况下的示例

数组

在某些情况下，虽然可以使用单个变量来存储信息，但是如果需要存储的信息较多（例如存储 50 名学生的成绩），这时再依次创建变量声明并赋值显得非常麻烦。

随着处理的信息量越来越大，工作也就越来越烦琐，这时可以使用数组或集合来存储信息。通过使用数组，可以在很大程度上缩短和简化程序代码，从而提高应用程序的效率。
Java 中的数组是引用数据类型，它的长度属性是 length，String 也是引用类型，在操作数组的时候切记要做空的判断啊，不然会空指针异常，数组的下标是从0开始的，创建一个数组

有很多种创建方式

String aaa[] = new String[5]; /*开辟了一个长度为5的数组*/
aaa[0] = "10"; // 第一个元素
aaa[1] = "20"; // 第二个元素
aaa[2] = "30"; // 第三个元素

String [] arr={"10","20","30"};

    public static void main(String[] args) {
        String aaa[] = new String[5]; /*开辟了一个长度为5的数组*/
        aaa[0] = "10"; // 第一个元素
        aaa[1] = "20"; // 第二个元素
        aaa[2] = "30"; // 第三个元素
        for(int i = 0; i < aaa.length; i++) {
            if(aaa[i]!=null){
                System.out.println(aaa[i]); //通过循环控制索引
            }
        }
    }
}

因为数组是引用类型，和我们平时操作的类对象是有点类似的，所以当我把这个aaa[] 赋值给 vvv[] 的时候那么当vvv被修改时，aaa中的数据也将会被修改，赋值的时候是地址拷贝

public static void main(String[] args) {
    String aaa[] = new String[5]; /*开辟了一个长度为5的数组*/
    aaa[0] = "10"; // 第一个元素
    aaa[1] = "20"; // 第二个元素
    aaa[2] = "30"; // 第三个元素
    String vvv[]=aaa;
      vvv[vvv.length-3]="11";

    for(int i = 0; i < aaa.length; i++) {
        if(aaa[i]!=null){
            System.out.println(aaa[i]); //通过循环控制索引
        }
    }
}

这个aaa在输出aaa[2] = “30”; 不在等于30了 而是等于11 说vvv修改后aaa也受到影响，怎么解决这个问题呢？

    public static void main(String[] args) {
        String aaa[] = new String[5]; /*开辟了一个长度为5的数组*/
        aaa[0] = "10"; // 第一个元素
        aaa[1] = "20"; // 第二个元素
        aaa[2] = "30"; // 第三个元素
        String vvv[]=new String[5];;
        for(int i = 0; i < aaa.length; i++) {
            if(aaa[i]!=null){
                vvv[i]=aaa[i];
                if( aaa[aaa.length-3].equals("30")){
                    vvv[i]="22";
                    System.out.println(aaa[i]);
                }
                System.out.println(aaa[i]); //通过循环控制索引
            }
        }
    }
}

如果有需要，但是又不想原来的收到影响，可以创建一个新的数字，以值拷贝的方式赋值给vvv，删除的话就是将下标找到直接赋值为null就行了，如果是int类型的数组找到下标赋值为0，，二维数组的话和一维数组的操作是一样的，只是多了一层维度 名称[0][0] 名称[0][1]，就是原来本来是一个数组值得位置指向了一个新得数组，在内存中也是引用对应的，一对多的感觉 访问和循环方式是不变的
上面代码里用找下标的方式新增显然是不合适的，因为那是在知道还有空间的情况下，那如果是用于需求上面，我多写入一个变会报错了，那么怎么动态扩容呢？

public static void main(String[] args) {
    //要求：实现动态的给数组添加元素效果，实现堆数组的扩容，ArrayAdd.java
    //1,原始数组使用静态分配 int [] arr={10,20,30};
    //动态增加元素，直接放再数组的最后， arr={10,20,30，40}
    //用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？Y/N
    //思路：
    // 定义一个新的数组，int[] arrNew=new int[arr.length+1]
    //遍历arr数组，依次将arr的元素拷贝到arrNew数组，将4赋给arrNew[arr.length-1]
    //让arr 指向arrNew; arr=arrNew;那么原来arr数组就被销毁了
    //创建一个Scanner可以接受用户输入
    Scanner a=new Scanner(System.in);
    //初始化数组
    int [] arr={10,20,30};
    do {
        int[] arrNew = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            arrNew[i] = arr[i];
        }
        System.out.println("请输入要添加的元素");
        arrNew[arr.length - 1] = a.nextInt();
        System.out.println("=========扩容后元素");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "\t");
        }
        System.out.println("是否继续 y/n");
        char key =a.next().charAt(0);
        if(key=='n'){
            break;
        }
    }while (true);
}

数组扩容是非常慢的，每次都要开辟新的数组还要拷贝（数据结构中的链表是可以解决这个问题的，下一章在写吧），还有动态缩减，也可以根据上面的例子来进行复制