Java学习基础到深入4（数组/二维数组/二维数组依次开空间/值传递和引用传递/数组扩容/冒泡排序/顺序查找/杨辉三角）

数组

• 数组的必要性：如果同类型不同值的数据太多，定义变量和对数据进行操作就会很麻烦，所以引出数组来存储。
• 数组的定义：
  1. 静态初始化：double [] score = { 22.2 , 33.3 , 55.5}
  2. 动态初始化：double[] score = new double[3];
• 一个小例子：利用数组和循环输出’A’-‘Z’,提示char类型运算’A’+2->‘C’.

char[] array1 = new char[26];
 for(int i = 0; i < array1.length; i++){
     array1[i] = (char) ('A' + i);    //'A' + 1是 int类型，而array1[]是char类型，需要强制转换
 }
 for(int j = 0; j < array1.length; j++){
     System.out.print(array1[j] + " ");
 }

• 这里需要注意’A’ + 1是 int类型，而array1[]是char类型，需要强制转换

二维数组

• 二维数组定义：
• 静态初始化:int[][] arr1 = {{1,2,3},{4,5,6}}
• 动态初始化：int[][] arr = new int[3][3];
• 例子：

public class TwoDimensionalArray {
    public static void main(String[] args) {
          //静态初始化
//        int[][] arr = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
//        for (int i = 0; i < arr.length; i++){
//            for (int j = 0; j < arr[i].length; j++){
//                System.out.print(arr[i][j] + " ");
//            }
//        }
        //动态初始化
        Scanner input = new Scanner(System.in);
        System.out.println("请输入数组元素");
        int[][] arr1 = new int[3][3];
        for (int i = 0; i < arr1.length; i++){
            for (int j = 0; j < arr1[i].length; j++){
                arr1[i][j] = input.nextInt();
            }
        }
        for (int i = 0; i < arr1.length; i++){
            for (int j = 0; j < arr1[i].length; j++){
                System.out.print(arr1[i][j] + " ");
            }
        }
    }
}

• 二维数组依次开空间，即先定义行数，再定义列数。可以解决杨辉三角等不是规则的矩阵数组问题。假设要定义int[3][] arr2的数组，而横向为自己定义。比如：arr2[][] = {{1},{2,3},{4,5,6}}
• 代码

// 二维数组依次开空间
        //arr2[][]  = {{1},{2,3},{4,5,6}}
//        Scanner input = new Scanner(System.in);
//        int[][] arr2 = new int[3][];     //先定义有多少组
//        for (int i = 0; i < arr2.length; i++){
//             arr2[i] = new int[i+1];     //再分配横向空间
//             for (int j = 0; j < arr2[i].length; j++){    //再定义每一组的个数
//                 arr2[i][j] = input.nextInt();
//             }
//        }
//        for (int i = 0; i < arr2.length; i++){
//            for (int j = 0; j < arr2[i].length; j++){
//                System.out.print(arr2[i][j] + " ");
//            }
//        }

值传递和引用传递的区别

• 先看例子：

//值拷贝
 int a = 10;
  int b = a;
  b = 30;
  System.out.println(a + " " + b);

  //数组，引用赋值
  int[] arr1 = {10, 20, 30};
  int[] arr2 = arr1;

  arr2[0] = 80;
  for (int i = 0;i < arr1.length; i++){
      System.out.print(arr1[i] + " ");
  }
  for (int j = 0;j < arr2.length; j++) {
      System.out.print(arr2[j] + " ");
  }

输出结果：

• 会发现值传递：在b变化时，不会影响a值的变化。
• 而引用传递：arr1赋值给arr2，将arr2值变化时，arr1数组也会跟着变化。因为arr1和arr2指的是同一个堆空间，所以arr2变化时，实际也是arr1在变化
• 如果想把arr2有arr1的相同元素时，可以创建一个新数组，可以使用遍历赋值的方法。

数组扩容

• 假设原有数组int[] arr1 = {1,2,3,4}，现在用户需要将arr1扩容，输入新的元素.
• 思路：新建一个arr2数组，长度为arr1.length，先将arr1的4个元素利用循环赋值arr2，再将新元素放到数组末尾，最后将arr2引用赋值给arr1,此时arr1的原有堆空间舍弃，而使用arr2的堆空间，使得arr1为此时arr2的元素和长度。
• 代码：

 Scanner input = new Scanner(System.in);    //注意添加包import java.util.Scanner
        int[] arr1 = {1,2,3,4};
        do {
            int[] arr2 = new int[arr1.length + 1];
            for (int i = 0; i < arr1.length; i++) {
                arr2[i] = arr1[i];
            }
            System.out.println("请输入要添加的值");
            int addNum = input.nextInt();
            arr2[arr1.length] = addNum;
            arr1 = arr2;
            for (int j = 0; j < arr1.length; j++) {
                System.out.print(arr1[j] + " ");
            }
            System.out.println("是否继续添加 y/n");     //询问继续添加吗
            char key = input.next().charAt(0);
            if(key == 'n'){
                break;
            }

        }while (true);

冒泡排序

• 思路：冒泡排序顾名思义，就是将最大值排在数组末尾，其他同理，最后得到从小到大的一个数组。而对于第一轮就会每个都相比较，会移动数组.length次，而第二次比较时，就可以忽略最后一个元素，不用比较，因为最后一个元素已经是最大值。所以有i个元素会排序i轮，而每一轮会一次减一。所以循环为

for(int i = 0; i < arr.length-1; i++){
  for(int j = 0; j < arr.length - 1 - i; j++){
  }
}

• 最终代码：

public class bubbleSort {
    public static void main(String[] args) {
        int[] arr = {10,20,30,40,55,2,88,6,-9,56};
        int temp = 0;    //作为中间交换
        for(int i = 0;i < arr.length - 1; i++){
            for (int j = 0; j < arr.length - 1 - i; j++){   //每一轮的次数
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
    }
}

• 输出结果：
  

顺序查找

• 就是遍历整个数组，如果找到相等的则break;并且让你的记录标志变化以便能最后输出是否成功找到；
• 需要注意的是如果是查找字符串，则用方法

String name = input.next();
if(name.equals(arr[i])){
     
}

来查找，其他可以用 == 号来判断。

杨辉三角

• 形如：

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	

• 思路：
  1. 首先应该用二维数组来做，而这明显不是规则的x * x的矩形，发现每一行的列数j == 行数i。所以要使用我上面二维数组的依次开空间的方法。将行数定义为i，列数定义为j。
  2. 发现每一行的第一个数和最后一个数都是1即：

if (j == 0 || j == i){
     arr[i][j] = 1;
  }

3. 除去这两个数后，由

arr[4][1] = arr[3][0] + arr[3][1];
arr[4][2] = arr[3][1] + arr[3][2];

可以总结出规律：

arr[i][j] = arr[i-1][j-1] + arr[i-1][j];

• 所以最后的代码为：

import java.util.Scanner;

public class YangHuiTriangle {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入行数：");
        int hang = input.nextInt();
        int[][] arr = new int[hang][];   // 先定义行数的空间
        for (int i = 0; i < arr.length; i++){
            arr[i] = new int[i+1];    // 再定义列数的空间
            for (int j = 0; j < arr[i].length; j++){
                if (j == 0 || j == i){
                    arr[i][j] = 1;     //两边的都定义为1
                }else {
                    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 < arr[i].length; j++){
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

• 结果如图：