java二维数组及数组练习案例

二维数组：

定义二维数组：

int[][] arr1 = {{1},{1,2},{1,2,3}};
int[][] arr2 = new int[3][4];
int[][] arr3;
arr3 = new int[2][3];

二维数组的内存分布

二维数组的元素是一维数组，也就是二维数组存储一堆一维数据所指向的地址，而一维数组的地址里面又开辟储存元素的空间

二维数组元素访问：

arr[0][0] = 1;

数组练习案例：

体验二维数组“行定列不定”：

/**
 * 体验二维数组中一维数组的不同空间大小
 *
 * @author small_shrimp_
 */
public class TwoDimensionalArray {
    public static void main(String[] args){
        //声明二维数组，行定列不定
        int[][] arr = new int[3][];
        for(int i = 0;i < arr.length; i++){
            arr[i] = new int[i+1];
            for(int j = 0; j < arr[i].length; j++){
                arr[i][j] = j + 1;
            }
        }
        System.out.println("====arr的元素如下====");
        //普通for循环输出
//        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();
//        }
        //增强型for循环输出
        for(int[] row : arr){
            for(int num : row){
                System.out.print(num + "\t");
            }
            System.out.println();
        }
    }
}

为什么说二维数组“行定列不定”呢，运行这段代码，就得到了下图

通过结果可以看到，第一个一维数组里面的空间只有1，第二个一位数组有2…。

杨辉三角：

/**
 * 利用二维数组输出杨辉三角
 *     1
 *    1 1
 *   1 2 1
 *  1 3 3 1
 * 1 4 6 4 1
 * ...
 * @author small_shrimp_
 */
public class YangHui {
    public static void main(String[] args){
        //利用二维数组“行定列不定”声明数组，此时只是确定了有10个一维数组的元素，但是并没有分配内存
        int[][] yangHui = new int[10][];
        for(int i = 0; i < yangHui.length; i++){
            //分配内存空间，观察杨辉三角可以得到，每一行的元素个数等于行数
            yangHui[i] = new int[i + 1];
            for(int j = 0; j < yangHui[i].length; j++){
                //杨辉三角两端的值为1
                if(j == 0 || j == yangHui[i].length - 1){
                    yangHui[i][j] = 1;
                }else{//杨辉三角中间的值（除两端） = 上一行同一列的值 + 上一行上一列的值
                    yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                }
            }
        }
        //增强型for循环输出杨辉三角
        for(int[] row : yangHui){
            for(int value : row){
                System.out.print(value + "\t");
            }
            System.out.println();
        }
    }
}

扩容数组：

/**
 * 已知有个什序的数组，要去插入一个元素，该数组顺序依然是什序，比如：[10,12,45,90],添加23后，数组为[10,12,23,45,90]
 * @author small_shrimp_
 */
import java.util.Scanner;
public class InsertElement {
    public static void main(String[] args){
        int[] arr = {10,12,45,90};
        int index = -1;
        Scanner myScanner = new Scanner(System.in);
        System.out.println("输入你将要添加的整型元素：");
        int newElement = myScanner.nextInt();
        for(int i = 0; i < arr.length; i++){
            //找出新元素所在的索引
            if(newElement <= arr[i]){
                index = i;
                break;
            }else{//如果新元素比已知数组所有数都大，那么它的索引为最末
                //因为数组索引从0开始，所以扩容数组末的索引为arr.length
                index = arr.length;
            }
        }
        //定义一个新的数组进行扩容
        int[] arrNew = new int[arr.length + 1];
        //为新数组赋值
        for(int i = 0,j = 0; i < arrNew.length; i++){
            //为了跳过新元素的索引，将原本的元素赋值给新数组，使用j
            if(i != index){
                arrNew[i] = arr[j];
                j++;
            }else{
                arrNew[i] = newElement;
            }
        }
        arr = arrNew;
        System.out.println("=====扩容后的数组元素为=====");
        //用增强型for循环输出扩容后的数组元素
        for(int value : arr){
            System.out.print(value + "\t");
        }
    }
}