JAVA方法递归+数组

方法递归

2.数组：存放一组相同类型的数据集合，在适当时候使用

JAVA中的数组存放于堆中

动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
int[] array=new int[4];//定义一个数组，但没有初始化
int[] array =new int[] {1,2,3};//【】内不能写具体数字
JAVA中默认【】为0

静态初始化：
数据类型[] 数组名称 = { 初始化数据 };

1.【】里不能写东西

1. JAVA中新增打印语句foreach
   for ( int x: array) { //括号左边数据类型，右边数组名字
   System.out.println(x);
   }

2.打印方式：将数组以字符串形式输出 Arrays
String str=Arrays.toString(array);
System.out.println(str);
//或者
System.out.println(Arrays.toString(array));

3.储存方式 栈，堆
堆比栈大一些，数组在堆上开辟一块内存
JAVA中null也属于对象
array=null;
System.out.println(array.length);
错误：空指针异常
排除错误方向：检查哪个引用是null

3.数组作为方法的参数
通过引用修改对象数据

4.初识JVM内存区域划分

5.数组作为方法的返回值

• 通过引用修改对象数据

 public static void print1(int [] array2) {
        array2[0]=9999;
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i] + " ");
        }
    }

   public static void main(String[] args){
        int[] array={1,2,3,4,5};
        print1(array);  //9999 2 3 4 5
       for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
            //上面已经通过按值传递改变数组
            //9999 2 3 4 5
        }
    }

初始JVM内存区域划分

Native 方法:
JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操
作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数.

package NewJavaClass.Test2007;
import java.util.Arrays;
//Arrays的路径  Arrays操作数组的工具类
//在Arrays类中包含很多的方法
import java.util.Scanner;
//java.util:工具包
/**
 * @ Author     ：CYD
 * @ Date       ：Created in 21:23 2020/7/21
 * @ Description：
 * @ Modified By：
 * @Version: $
 */

/**
 *1.方法递归
 *
 * 2.数组：存放一组相同类型的数据集合，在适当时候使用
 *
 * JAVA中的数组存放于堆中
 *
 * 动态初始化
 * 数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
 * int[] array=new int[4];//定义一个数组，但没有初始化
 * int[] array =new int[] {1,2,3};//【】内不能写具体数字
 * JAVA中默认【】为0
 *
 * 静态初始化：
 * 数据类型[] 数组名称 = { 初始化数据 };
 *
 *1.【】里不能写东西
 *
 * 1. //JAVA中新增打印语句foreach
 *         for ( int x: array) {    //括号左边数据类型，右边数组名字
 *             System.out.println(x);
 *         }
 *
 * 2.//打印方式：将数组以字符串形式输出  Arrays
 *         String str=Arrays.toString(array);
 *         System.out.println(str);
 *         //或者
 *         System.out.println(Arrays.toString(array));
 *
 * 3.储存方式  栈，堆
 * 堆比栈大一些，数组在堆上开辟一块内存
 * JAVA中null也属于对象
 *          array=null;
 *          System.out.println(array.length);
 *          错误：空指针异常
 *          排除错误方向：检查哪个引用是null
 *
 * 3.数组作为方法的参数
 *   通过引用修改对象数据
 *
 *
 * 4.初识JVM内存区域划分
 *
 * 5.数组作为方法的返回值
 */

public class Test0722 {

    //1.斐波那契数列第n项
    public static int fib(int n){
        if(n==1||n==2){
            return 1;
        }
        return fib(n-1)+fib(n-2);
    }

    public static void main1(String[] args) {
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入n");
        int n=scan.nextInt();
        System.out.println(fib(n));
    }

    //2.汉诺塔问题
    public static void move(char pos1,char pos2){
        System.out.println(pos1+"->"+pos2);
    }
//pos1 起始位置     pos2中间位置    pos3最终位置
    public static void hannuota(int n,char pos1,char pos2,char pos3){
        if(n==1){
            move(pos1,pos3);
        }else{
            hannuota(n-1,pos1,pos3,pos2);
            move(pos1,pos3);
            hannuota(n-1,pos2,pos1,pos3);
        }
    }


//========================================================================================

//1.遍历数组
    public static void main2(String[] args){
        int[] array={1,2,3,4,5};
        for(int i=0;i<array.length;i++){
            //异常， <=   ,数组越界异常
            System.out.print(array[i]+" ");
        }
        /* array=null;
         System.out.println(array.length);
         错误：空指针异常
         */

        System.out.println();
//1 2 3 4 5

        //JAVA中新增打印语句foreach
        for ( int x: array) {    //括号左边数据类型，右边数组名字
            System.out.print(x+" ");
        }
        System.out.println();
//1 2 3 4 5

        //打印方式：将数组以字符串形式输出
        String str=Arrays.toString(array);
        System.out.println(str);
        //或者
        System.out.println(Arrays.toString(array));
//[1 2 3 4 5]
    }

//2.数组作为方法的参数
    public static void print(int [] array2) {
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i] + " ");
        }
    }

        public static void main4(String[] args){
            int[] array={1,2,3,4,5};
            print(array);  //还是按值传递，不过传的是地址
        }


        /*
        通过引用修改对象数据
        */
    public static void print1(int [] array2) {
        array2[0]=9999;
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i] + " ");
        }
    }

    public static void main5(String[] args){
        int[] array={1,2,3,4,5};
        print1(array);  //9999 2 3 4 5

        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
            //上面已经通过按值传递改变数组
            //9999 2 3 4 5
        }
    }


//5.数组作为方法的返回值
    public static int[] func2(){
        int [] array={1,2,3};
        return array;
    }

    public static void main6(String[] args) {
        System.out.println(Arrays.toString(func2()));

    }

//代码示例: 写一个方法, 将数组中的每个元素都 * 2
    public static int [] fun3(int [] array3){
        int [] temp=new int [array3.length];
        for(int i=0;i<array3.length;i++)
        {
            temp[i]=array3[i]*2;
        }
        return temp;
    }

    public static void main(String[] args) {
        int [] array3={2,4,6};
        fun3(array3);
        System.out.println(Arrays.toString(fun3(array3)));
    }

}