5-java学习- 一维数组、二维数组、递归-案例代码

5-java学习- 一维数组、二维数组、递归

一、一维数组

1.定义数组的语法

数组：一种容器，可以一次存储多个相同数据类型的元素,数组编有索引，从0开始数

public class MyTest {
    public static void main(String[] args）

{
        //动态初始化
        int[] arr = new int[5];  
        //5代表数组的长度，也就说能存5个int类型的元素
        //往数组中存储取出元素可以通过索引来存储或取出
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        arr[3] = 40;
        arr[4] = 50;

        System.out.println("==========================");
        //通过索引（角标） 取出数组中的元素
        int num=arr[4];
        System.out.println(num);
    }
}

2. 动态初始化:只指定长度，由系统给出初始化值

public class MyTest2 {
    public static void main(String[] args) {
        //	所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
        //动态初始化
        double[] arr=new double[3];
        System.out.println(arr[0]);
        int[] arr2=new int[2];
        System.out.println(arr2[1]);
    }
}

3.定义一个数组，输出数组地址值，给数组赋值，输出数组中的元素值,动态获取数组的长度

public class MyTest3 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //输出数组的地址值
        System.out.println(arr);
        //给元素赋值
        arr[0] = 20;
        //取元素的值
        int num1 = arr[0];
        int num2 = arr[1];
        int num3 = arr[2];
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);

        //数组中有一个属性length 可以动态获取数组的长度
        int len=arr.length;
        System.out.println("数组的长度:"+len);

        //比如要获取数组中最后一个元素的值
        //数组中最后一个元素的索引=数组的长度-1
        int index=arr.length - 1;
        System.out.println(arr[index]);
        System.out.println(arr[arr.length - 1]);
    }
}

4.定义两个数组

public class MyDemo2 {
    public static void main(String[] args) {
        int[] arr1=new int[3];
        System.out.println(arr1);
        arr1[0]=20;
        arr1[1]=30;
        arr1[2]=50;

        int[] arr2=new int[2];
        System.out.println(arr2);
        arr2[0]=100;
        arr2[1]=400;

        System.out.println(arr1[0]);
        System.out.println(arr2[1]);
    }
}
运行结果：
[I@68c26c
[I@1bde4
20
400

5.定义三个数组

public class MyDemo3 {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        System.out.println(arr1);
        arr1[0] = 20;
        arr1[1] = 30;
        arr1[2] = 50;

        int[] arr2 = new int[2];
        System.out.println(arr2);
        arr2[0] = 100;
        arr2[1] = 400;

        int[] arr3 = arr1;
        System.out.println(arr3);
        arr3[0] = 60;
        arr3[1] = 75;

        System.out.println(arr1[0]); 
        System.out.println(arr1[1]); 
        System.out.println(arr1[2]); 

        System.out.println(arr2[0]); 
        System.out.println(arr2[1]); 

        System.out.println(arr3[0]);
        System.out.println(arr3[1]); 
        System.out.println(arr3[2]); 
    }
}


运行结果：
[I@fdb00d
[I@131303f
[I@fdb00d
60
75
50
100
400
60
75
50

6.数组的静态初始化：由我们为数组元素赋值，由系统计算长度

public class MyDemo {
    public static void main(String[] args) {
        //数组的静态初始化
        int[] arr = new int[]{20, 30, 40, 50};
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        //静态初始化的简写形式
        int[] arr2={60,80,30,400};
        System.out.println(arr2.length);
    }
}

7.遍历数组、反向遍历数组

public class MyDemo2 {
    public static void main(String[] args) {
        int[] arr = new int[]{20, 30, 40, 50,67,90,100};
        //System.out.println(arr[0]);
        //遍历数组
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
        System.out.println("==========================");
        //反向遍历数组
        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
    }
}

8.获取数组中的最大值或最小值

public class MyDemo3 {
    public static void main(String[] args) {
        int[] arr = new int[]{500,20, 30, 40, 50, 67, 90, 100};
        //数组名.length.fori 快速遍历数组
        //定义一个参照的数
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("最大值是"+max);
    }
}

9.数组元素反转(就是把元素对调)

public class MyDemo4 {
    public static void main(String[] args) {
       int[] arr={10,20,30,40,50,60,70,80,90,100}; 
       int max = getMax(arr);
       reverse(arr);
       showArr(arr);
       int[] arr2 = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100,600};

    }
    //获取数组中最大值
    public static int getMax(int[] arr){
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
               max=arr[i];
            }
        }
        return max;
    }
    //反转数组中的元素
    public static void reverse(int[] arr){
        //首尾元素交换，遍历一半
       for (int i = 0; i < arr.length/2; i++) {
            int t=arr[i];
            arr[i]= arr[arr.length-1-i];
            arr[arr.length - 1 - i]=t;
        }
    }
    //遍历数组
    public static void showArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

10.交换a,b的值

public class MyDemo5 {
    public static void main(String[] args) {
        //值交换  a=20  b=10;
        int a=10;
        int b=20;
       //方式1.采用中间变量 开发中常用
        int t=a; 
        a=b; 
        b=t;
        
         //方式2 采用^  一个数被另一个数位异或两次该数不变
        a=a^b;
        b=a^b;
        a=a^b;
        
        //方式3 a=(a+b)-(b=a);
        a=a+b;
        b=a-b;
        a=a-b;
        
        System.out.println("a:"+a);
        System.out.println("b:"+b);
    }
}

11. 数组查表法(根据键盘录入索引, 查找对应星期)

public class MyTest {
    public static void main(String[] args) {
       String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字 1----7");
        int num = scanner.nextInt();

        //根据索引查元素
        String week = getEleByIndex(arr, num);
        System.out.println(week);
    }
    
    
    public static String getEleByIndex(String[] arr,int index){
        if(index>=1&&index<=7){
            return arr[index-1];
        }else{
            return "你输入的索引超出范围";
        }
    }
}

12.根据键盘录入星期, 查找对应序列

public class MyTest2 {
    public static void main(String[] args) {
        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入星期");
        //nextLine()获取用户输入的字符串
        String xingqi = scanner.nextLine();
        //根据元素查索引
        int index = getIndex(arr, xingqi);
        System.out.println(index);
    }

    
    public static int getIndex(String[] arr,String xq){
        int index=-1;
        for (int i = 0; i < arr.length; i++) {
            if(xq.equals(arr[i])){
                index=i;
                break;
            }
        }
        return index; //-1 代表没有找到
    }
}

二、二维数组

1.二维数组：就是元素为一维数组的数组

public class MyDemo {
    public static void main(String[] args) {
        //定义一个int类型的二维数组，二维数组里面放了三个一维数组，每个一维数组的长度为2
        int[][] arr=new int[3][2];

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);

        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);

        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
        //引用数据类型： new出的东西 属于引用数据类型 比如 数组 类 接口
    }
}

2.定义一个二维数组长度为3

public class MyDemo2 {
    public static void main(String[] args) {
        //第二个中括号，不填，那就是不会帮你初始化3个一维数组
        int[][] arr = new int[3][];
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

运行结果：
null
null
null

3.定义一个二维数组

public class MyDemo3 {
    public static void main(String[] args) {
        //定义一个二维数组长度为3
        //第二个中括号，不填，那就是不会帮你初始化3个一维数组
        int[][] arr = new int[3][];

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);


        //定义了三个一维数组
        int[] minArr1 = new int[3];
        int[] minArr2 = new int[2];
        int[] minArr3 = new int[4];
        System.out.println(minArr1);
        System.out.println(minArr2);
        System.out.println(minArr3);

        //把 这个三个一维数组放到二维数组中

        arr[0]=minArr1;
        arr[1]=minArr2;
        arr[2]=minArr3;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //给二维数组中的元素赋值
        arr[0][0]=20;
        arr[0][1] = 200;
        arr[0][2] = 20222;

        arr[1][0] = 120;
        arr[1][1] = 11200;

        arr[2][0] = 120;
        arr[2][1] = 11200;
        arr[2][2] = 120222;
        arr[2][3] = 1202242;

        System.out.println(arr[2][3]);
        System.out.println(arr[arr.length-1][arr[arr.length - 1].length-1]);
        System.out.println(arr[arr.length - 1][minArr3.length-1]);

    }
}

运行结果：
null
null
null
[I@15d17d7
[I@c8376b
[I@ae533a
[I@15d17d7
[I@c8376b
[I@ae533a
1202242
1202242
1202242

public class MyDemo4 {
    public static void main(String[] args) {
        //二维数组的静态初始化：由我们给元素赋值，有系统计算长度
        int[][] arr=new int[][]{{20,30,1},{5,6},{9,10,20}};

        //二维数组的静态初始化简写
        int[][] arr2 = {{20, 30, 1}, {5, 6}, {9, 10, 20}};

        arr2[2][2]=200;
        System.out.println(arr2[2][2]);
        
        int[] ints = new int[7];
    
        System.out.println(arr2[0]);
        arr2[0]=ints;
        
        System.out.println(arr2[0][0]);
    }
}

5.二维数组的遍历

public class MyDemo5 {
    public static void main(String[] args) {
        int[][] arr = {{20, 30, 1}, {5, 6}, {9, 10, 20}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

6.遍历数组求和

public class MyDemo6 {
    public static void main(String[] args) {
       /*
        案例演示
        需求：公司年销售额求和
        某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度：22, 66, 44
        第二季度：77, 33, 88
        第三季度：25, 45, 65
        第四季度：11, 66, 99*/

       int[][] arr={{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
        //遍历数组求和
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum=sum+arr[i][j];
            }
        }
        System.out.println("总额："+sum);
    }
}

7.打印杨辉三角形(行数可以键盘录入)

public class MyDemo7 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int n = sc.nextInt();
        int[][] arr = new int[n][n];

        //每一行的第一个数和最后一个数是1

        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;

        }
        
        //中间元素
        // 从第三行开始，从第二列开始这个数字等于他上一行的上一列和上一行的本列之和
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j <=i-1; j++) {
               arr[i][j]=arr[i-1][j-1]+ arr[i - 1][j];
            }

        }
        
        //输出三角形
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <=i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

8.局部变量：定义在方法中或方法声明上的变量(形参)

public class MyTest {
    public static void main(String[] args) {
        //局部变量存储在栈内存
        //局部变量随着方法的调用产生，随着方法的调用完毕而消失
        int num=20; 
    }
    public static void show(int a,int b){
        int num=20;
    }
}

9.基本类型的数据作为参数传递（值传递，传递值过去的），形参的改变不影响实参,

引用类型作为参数传递（引用传递，传递的是地址值），形参的改变会影响实参

public class MyTest2 {
    public static void main(String[] args) {
        
        //定义两个变量
        int a = 10;
        int b = 20;
        System.out.println("a: " + a + ",b: " + b);
        //调用方法
        change(a, b);
        //输出 a b 的值
        System.out.println("a: " + a + ",b: " + b);
        //定义了一个数组
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(arr);
        //调用方法 把数组传过去
        change(arr);
        //输出数组的第二个元素的值
        System.out.println(arr[1]); 
    }

    public static void change(int a, int b) {

        System.out.println("a: " + a + ",b: " + b);
        a = b;
        b = a + b;
        System.out.println("a: " + a + ",b: " + b);
    }

    public static void change(int[] arr) {
        System.out.println(arr);
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] % 2 == 0) {
                arr[x] *= 2;
            }
        }
    }
}

运行结果：
a: 10,b: 20
a: 10,b: 20
a: 20,b: 40
a: 10,b: 20
[I@22ab57
[I@22ab57
4

三、递归

1. 递归：Java中的递归:在方法中调用方法本身的这种现象。

  注意的事项：1.递归要有出口（不然就是死递归）2.递归次数不宜过多
  体现的思想：是一种拆分合并的思想。

public class MyTest {
    public static void main(String[] args) {
      
        show(5);
    }

    public static void show(int n){
        //StackOverflowError 栈溢出
        System.out.println("这是一个show方法");
        --n;
        if(n>1){
            show(n);
        }
    }
}

2.求10的阶乘

public class MyTest2 {
    public static void main(String[] args) {

        long num=1;
        for (int i = 1; i <= 10; i++) {
            num*=i;
        }
        System.out.println(num);
    }
}

3.求5的阶乘，使用递归的思想来做

public class MyTest3 {
    public static void main(String[] args) {
        
        int result=jieCheng(5);
        System.out.println(result);
    }

    public static int jieCheng(int n) {
        if(n==1){
           return 1;
        }else{
            return n * jieCheng(n - 1);
        }
    }
}

4.兔子问题(斐波那契数列)

​ 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

public class MyTest4 {
    public static void main(String[] args) {

        int[] arr = new int[20];
        arr[0]=1;
        arr[1]=1;
        for (int i = 2; i < arr.length; i++) {
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println(arr[19]);
    }
}

public class MyTest5 {
    public static void main(String[] args) {
        int sum=兔子(20);
        System.out.println(sum);
    }
    private static int 兔子(int n) {
        if(n==1||n==2){
           return 1;
        }else{
            return 兔子(n-1)+兔子(n-2);
        }
    }
}