day04_数组

已于 2022-07-19 15:54:46 修改
阅读量171 收藏
点赞数
分类专栏： 1_javaSE 文章标签： java
于 2022-07-18 15:28:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39535978/article/details/125851164
版权

数组

学习目标：

1. jvm内存图入门
2. 一维数组的使用
3. 二维数组的使用
4. 数组的内存结构
5. 数组中常见算法
6. 数组中常见的异常

视频教程：https://www.bilibili.com/video/BV1rB4y1Y769?p=1

一、JVM内存图入门

java程序运行在jvm上，jvm内存主要分为五块，结构如下：

在这里插入图片描述

每块内存负责的职责如下：

  1. Java虚拟机栈（Java Virtual Machine Stacks）：描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame），栈帧中存储着局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，会对应一个栈帧在虚拟机栈中入栈到出栈的过程。与程序计数器一样，Java虚拟机栈也是线程私有的。

    局部变量和引用地址都是在栈内存中。

  2. 堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

  3. 方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法区存放的数据只有一份

  4. 本地方法栈（Native Method Stack）：与Java虚拟机栈作用很相似，它们的区别在于虚拟机栈为虚拟机执行Java方法（即字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。例如调用本地c/c++的方法。

  5. 程序计数器：程序计数器是记录当前线程所执行的指令行数。

二、数组的概述

2.1 为什么需要数组

为什么要有数组？在开发中，我们常常需要存取很多相同类型的数据，用变量的方式需要定义很多变量，不方便管理。所以引入数组的概念，一次存取多个相同类型的数据。数组有两个一定，一个类型一定，一个是大小一定。

2.2 数组的基本概念

数组中存在着一些重要的概念，如下所示：

  • 数组名：数组的名称，数组内存的首地址
  • 下标名（索引）：数组元素的序号索引，从0开始
  • 元素：数组中存放的内容
  • 长度 ：数组的长度

在这里插入图片描述

三、一维数组的使用

3.1 数组的定义

一维数组的定义语法如下：

在这里插入图片描述

示例：

/**
 * 数组定义
 */
public class ArrayDemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr1;
        String [] arr2;
    }
}

3.2 数组的初始化

数组动态初始化语法：

在这里插入图片描述

示例：

/**
 * 数组定义,以及动态初始化
 */
public class ArrayDemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr1;
        //数组动态初始化
        arr1 = new int[4];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        arr1[3] = 40;
        //取值
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[3]);
    }
}

数组静态初始化语法：

在这里插入图片描述

示例：

/*
数组的定义与静态初始化
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        //数组的声明
        // String[] arr = new String[]{"乔峰","段誉","杨过"};
        //简写
        String[] arr = {"乔峰","段誉","杨过"};
        //取值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

3.3 数组元素的引用

引用数组元素内容需要注意以下几点：

  • 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
  • 数组元素的引用方式：数组名[数组元素下标]
  • 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
  • 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
  • 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长 度(元素个数) 。数组一旦初始化，其长度是不可变的

示例1：数组元素的引用

/**
 * 数组元素的引用
 */
public class ArrayDemo3 {
    public static void main(String[] args) {
        //数组的定义
        int[] arr = {1,3,5,7,9};
        //查看数组的长度
        System.out.println(arr.length);
        // 查看数组内容
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        // 数组下标超过最大下标会越界,报异常ArrayIndexOutOfBoundsException
        System.out.println(arr[5]);

    }
}

示例2：数组的循环赋值与取值

/**
 * 数组的循环赋值与取值
 */
public class ArrayDemo4 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = new int[5];
        //循环赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i*5;
        }
        //循环取值
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
        }
    }
}

3.4 数组的注意事项

数组在使用过程中需要注意以下几点：

  • 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
  • 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
  • 数组的长度一旦确定，就不能修改。
  • 数组的分类：
    • 按照维度：一维数组、二维数组、三维数组、…
    • 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

3.5 forEach的应用

forEach可以遍历数组或集合容器中的数据，语法如下：

在这里插入图片描述

示例：

/**
 * forEach遍历
 */
public class ArrayDemo5 {
    public static void main(String[] args) {
        //数组定义
        int[] arr = {1,3,5,7,9};
        //数组遍历
        for(int num : arr){
            System.out.println(num);
        }
    }
}

3.6 数组元素默认值

当数组元素没有赋值时，是存在默认值的，默认值如下：

在这里插入图片描述

3.7 一维数组内存图

在这里插入图片描述

3.8 小结

  1. 数组的基本使用
  2. 数据类型可以是基本类型或引用类型
  3. 数组类型固定长度不变
  4. 数组默认值
  5. 数组的内存图

四、一维数组练习题

4.1 数组赋值练习

将班级所有同学名字录入到一个一维数组中 。

参考答案：

/**
 * 将班级所有同学名字录入到一个一维数组中
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        //1.创建大小为5的String类型数组
        String[] names = new String[5];
        //2.创建扫描仪对象
        Scanner input = new Scanner(System.in);
        for(int i=0;i<names.length;i++) {
            //3.提示信息
            System.out.println("请输入第"+(i+1)+"个同学名字");
            //4.接收客户的输入信息
            String name = input.nextLine();
            //5.将名字存入数组中
            names[i] = name;
        }
        System.out.println("学生信息如下----------");
        for(int i=0;i<names.length;i++) {
            System.out.println(names[i]);
        }
    }
}

4.2 求数组值练习

已知一个一维数组如下int[] arr = {1,3,11,5,7,9};求出所有元素的最大值，最小值，和值，平均值，并输出出来。

参考答案：

/**
 * 已知一个一维数组如下int[] arr = {1,3,11,5,7,9};求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,3,11,5,7,9};
        //假设0下标是最大值 0下标是最小值
        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        int avg = 0;
        //2.判断最大值和最小值
        for(int i=0;i<arr.length;i++) {
            if(max<arr[i]) {
                max = arr[i];
            }
            if(min>arr[i]) {
                min = arr[i];
            }
            sum+=arr[i];
        }
        avg = sum/arr.length;
        System.out.println("最大值"+max);
        System.out.println("最小值"+min);
        System.out.println("和是"+sum);
        System.out.println("平均值是"+avg);

    }
}

4.3 数组的复制

已知数组int[] arr1 = {1,3,5,7,9} , int[] arr2; 将数组arr1的内容复制到数组arr2中

参考答案：

/**
 * 已知数组int[] arr1 = {1,3,5,7,9} , int[] arr2; 将数组arr1的内容复制到数组arr2中
 */
public class ArrayTest3 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr1,arr2;
        //2.初始化
        arr1 = new int[]{1,3,5,7,9};
        //3.打印数组arr1
        for(int i=0;i<arr1.length;i++) {
            System.out.println(arr1[i]);
        }
        //4.数组复制操作
        arr2 = new int[arr1.length];
        for(int i=0;i<arr1.length;i++) {
            arr2[i] = arr1[i];
        }
    }
}

注意：切不可 arr2 = arr1 这不是复制数组内容，这是复制数组内存地址；arr2和arr1会指向同一块堆内存空间，改变arr2的同时也会改变arr1，改变arr1的同时也会改变arr2

4.4 数组的反转

已知一个数组如下String[] arr = new String[]{“AA”,“BB”,“CC”,“DD”,“EE”};，反转arr数组得到如下结果String[] arr = new String[]{“EE”,“DD”,“CC”,“BB”,“AA”};

参考答案：

/**
 * 已知一个数组如下String[] arr = new String[]{"AA","BB","CC","DD","EE"};，
 * 反转arr数组得到如下结果String[] arr = new String[]{"EE","DD","CC","BB","AA"};
 */
public class ArrayTest4 {
    public static void main(String[] args) {
        String[] arr = new String[]{"AA","BB","CC","DD","EE"};

        for(int i=0;i<arr.length/2;i++) {
            String str = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = str;

        }
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
    }
}

五、二维数组的使用

如果说可以把一维数组当成几何中的线性图形， 那么二维数组就相当于是一个表格。就像下面图一样：

在这里插入图片描述

对于二维数组的理解，我们可以理解为一维数组的数组。既数组0下标是一个一维数组，1下标又是一个一维数组数组…。

5.1 二维数组的动态初始化

二维数组存在两种定义方式，第一种定义方式如下：

  • int[][]arr = new int[4][3]; 定义了名为arr的二维数组,二维数组中有4个一维数组 每一个一维数组中有3个元素
  • 一维数组分别为arr[0], arr[1], arr[2] ,arr[3]
  • 给第一个一维数组0脚标位赋值为1写法是：arr[0][0] = 1;
  • arr 数组的长度 arr.length;
  • arr[0].length 代表arr数组的0下标一维数组的长度。

示例：

/**
 * 二维数组动态初始化1
 */
public class ArrayDemo7 {
    public static void main(String[] args) {
        //1.动态定义二维数组方式1
        /*两种理解方式										        y  x
         * 	方式1 图形化理解  4 行 3 列 二维数组  int[][] arr = new int[4][3];
         *  方式2 有 4 个 一维数组  每个一维数组可以存放3个数
         */
        int[][] arr = new int[4][3];
        //2.获得 4 个一维数组 arr[0] arr[1] arr[2] arr[3]
        //打印 第0个数组
        System.out.print(arr[0][0]);
        System.out.print(arr[0][1]);
        System.out.println(arr[0][2]);
        //打印 第1个数组
        System.out.print(arr[1][0]);
        System.out.print(arr[1][1]);
        System.out.println(arr[1][2]);
        //打印 第2个数组
        System.out.print(arr[2][0]);
        System.out.print(arr[2][1]);
        System.out.println(arr[2][2]);
        //打印 第3个数组
        System.out.print(arr[3][0]);
        System.out.print(arr[3][1]);
        System.out.println(arr[3][2]);
        //3.查看二维数组长度
        System.out.println(arr.length);
        //4. 查看二维数组0下标长度
        System.out.println(arr[0].length);
        //5. 查看二维数组1标长度
        System.out.println(arr[1].length);
        //6. 查看二维数组2下标长度
        System.out.println(arr[2].length);
        //6. 查看二维数组3下标长度
        System.out.println(arr[3].length);
    }
}

第二种定义方式如下：

  • int[][] arr = new int[3][]; 二维数组中有3个一维数组。 每个一维数组都是默认初始化值null (注意：区别于格式1）
  • 可以对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[2]; arr[2] = new int[1];

注： int[][]arr = new int[][3]; 这种写法是错误的

示例：

public class ArrayDemo8 {
	public static void main(String[] args) {
		//1.动态初始化2   
		/**
		 *   图形化理解  定义 4行 图形 几列待定
		 *  定义 4 个 一维数组  一维数组内容 没有初始化 
		 */
		int[][] arr = new int[4][];
		//2.定义arr[0] 一维数
		arr[0] = new int[1];
		//3.定义arr[1] 一维数
		arr[1] = new int[2];
		//4.定义arr[2] 一维数
		arr[2] = new int[3];
		//5.定义arr[3] 一维数
		arr[3] = new int[4];
		//6.查看 数组长度
		System.out.println(arr.length);
		//7.查看0下标数组长度
		System.out.println(arr[0].length);
		//8.查看1下标数组长度
		System.out.println(arr[1].length);
		//9.查看2下标数组长度
		System.out.println(arr[2].length);
		//10.查看3下标数组长度
		System.out.println(arr[3].length);
	}
}

5.2 二维数组的静态初始化

int[][] arr = new int[][]{{1},{1,2},{1,2,3}}; 定义一个名称为arr的二维数组，二维数组中有三个一维数组

每一个一维数组中具体元素也都已初始化 第一个一维数组 arr[0] = {1}; 第二个一维数组 arr[1] = {1,2}; 第三个一维数组 arr[2] = {1,2,3};

以上代码也可以简写为：int[][] arr = {{1},{1,2},{1,2,3}};

示例：

public class ArrayDemo9 {
    public static void main(String[] args) {
        //1.二维数组静态初始化
        int[][] arr = new int[][] {
                {1,1,1},
                {2,2,2},
                {3,3,3}
        };
        //2.简化
        int[][] arr2 = {
                {1},
                {2,2},
                {3,3,3}
        };
    }
}

5.3 二维数组的遍历

二维数组循环赋值与遍历过程如下

public class ArrayDemo10 {
    public static void main(String[] args) {
        //1.矩形
        int[][] arr1 = new int[4][3];
        //2.循环赋值
        for(int y=0;y<arr1.length;y++) {
            for(int x=0;x<arr1[y].length;x++) {
                arr1[y][x] = 1;
            }
        }
        //3.循环遍历
        for(int y=0;y<arr1.length;y++) {
            for(int x=0;x<arr1[y].length;x++) {
                System.out.print(arr1[y][x]+"\t");
            }
            System.out.println();
        }
        //2.直角三角形练习
        String[][] arr2 = new String[4][];
        //3.循环赋值
        for(int y=0;y<arr2.length;y++) {
            //4.定义一维数组
            arr2[y] = new String[y+1];
            for(int x=0;x<arr2[y].length;x++) {
                arr2[y][x] = "*";
            }
        }
        //4.打印二维数组
        for(int y=0;y<arr2.length;y++) {
            for(int x=0;x<arr2[y].length;x++) {
                System.out.print(arr2[y][x]);
            }
            System.out.println();
        }
    }
}

5.4 小结

  1. 二维数组的动态初始化

  2. 二维数组的静态初始化

  3. 二维数组的遍历

六、二维数组练习题

6.1 杨辉三角

使用二维数组打印一个10行的杨辉三角

在这里插入图片描述

参考答案：

public class ArrayDemo11 {
    public static void main(String[] args) {
        //1.定义杨辉三角二维数组
        int[][] arr = new int[10][];
        //2.循环初始化 二维数组
        for(int y=0;y<arr.length;y++) {
            arr[y] = new int[y+1];
            //3.给每一行的第一个值和最后一个值赋值为 1
            arr[y][0] = arr[y][y] = 1;
            //4.给其他位置赋值
            //if(y>1) {
            for(int x=1;x<arr[y].length-1;x++) {
                arr[y][x] = arr[y-1][x-1]+arr[y-1][x];
            }
            //}

        }
        //3.遍历
        for(int y=0;y<arr.length;y++) {
            for(int x=0;x<arr[y].length;x++) {
                System.out.print(arr[y][x]+"\t");
            }
            System.out.println();
        }
    }
}

七、数组中常见算法

7.1 二分查找算法

已知数组int[] arr = {1,3,5,7,9,11,13};通过二分查找法查找数组中是否包含元素3，如果包含，元素3的下标是多少？注意（只有排好序的数组才能使用二分查找法）

分析过程如下：

在这里插入图片描述

另一种情况，当查找元素大于中间元素middle过程如下，这里以查找13为例

在这里插入图片描述

参考代码：

/**
 * 数组元素二分查找法，前提：已排序的数组
 */
public class BinarySearchArray {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,3,5,7,9,11,13};
        // 定义查找目标数
        int target = 3;
        //开始下标
        int head = 0;
        //结束下标
        int end = arr.length-1;
        //标记是否找到目标元素
        boolean tag = true;
        //二分查找
        while(head<=end){
            int middle = (head+end)/2;
            if(arr[middle]==target){
                System.out.println("查找到元素："+target+",下标："+middle);
                tag = false;
                break;
            }else if(arr[middle]>target){
                end=middle-1;
            } else {
                head=middle+1;
            }
        }
        if(tag){
            System.out.println("没有找到目标元素"+target);
        }
    }
}

7.2 数组的排序介绍（其余排序，由于算法过于复杂，后期统一讲）

排序：是计算机程序设计中的一项重要操作，是指对数组或集合中的元素进行按照大小或字母排序。

排序的算法有很多很多种，这里以冒泡排序、选择排序、插入排序为例进行讲解。

7.3 冒泡排序

冒泡排序的设计思想：从0下标开始比较相邻元素，通过交换下标元素位置，把大的元素放后面，小的元素放前面， 比较完一轮完成最后一个元素是最大的，以此类推，经过n轮比较完成排序的过程。

在这里插入图片描述

代码实现分析

  1. 一共比较几轮？
  2. 每轮比较几次？

参考答案

/**
 * 冒泡排序
 */
public class SortDemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,11,9,3,7,5};
        //排序
        for(int i=0;i<arr.length-1;i++){ //如果有6个数，比较5轮就可以了，剩下一个一定是最小的
            // 因为是j和j+1比较所以j<arr.length-1,又因为每比较一次，就少比较一个数，
            // 所以j<arr.length-1-i;
            for(int j=0;j<arr.length-1-i;j++){
                // 比较相邻元素，交换相邻下标位置
                if(arr[j]>arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        //打印数组
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

7.4 选择排序

选择排序的思路是：

  1. 将0下标和后面所有元素比，如果0下标不是最小元素，就交换位置，比较完一轮0下标就是最小的元素
  2. 以此类推将1下标元素和后面所有元素比较，如果1下标不是最小元素，就交换位置，比较完一轮1下标就第二小的元素
  3. 依此类推，完成整个数组的排序

在这里插入图片描述

代码实现分析

  1. 一共比较几轮？
  2. 每轮比较几次？

参考答案：


/**
 * 选择排序
 */
public class SortDemo2 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,11,9,3,7,5};
        //选择排序
        for(int i=0;i<arr.length-1;i++){ //如果6个数，比较5轮即可，剩下最后一个一定是最大的
            //让0下标i和后面所有下标比较；所以开始是i+1 结束到最大下标
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int t = arr[i];
                    arr[i] = arr[j];
                    arr[j] = t;
                }
            }
        }
        //打印数组
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

7.5 插入排序

插入排序的设计思路是：

  1. 从第一个元素开始，该元素可以认为已经被排序
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
  5. 将新元素插入到该位置后
  6. 重复步骤2~5

在这里插入图片描述

参考答案：

/**
 * 插入排序
 */
public class SortDemo3 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,11,9,3,7,5};
        //插入排序
        for(int index = 1;index<arr.length;index++){
            int t = arr[index];
            int leftIndex = index-1;
            while(leftIndex>=0 && arr[leftIndex]>t){
                arr[leftIndex+1] = arr[leftIndex];
                leftIndex--;
            }
            arr[leftIndex+1] = t;
        }
        //打印数组
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

7.6 小结

  1. 二分查找

  2. 冒泡排序

  3. 选择排序

  4. 插入排序

八、数组中常见的异常

数组中的常见异常：

  • 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
  • 空指针异常：NullPointerException

九、总结

  1. 一维数组的使用

  2. 二维数组的使用

  3. 一维数组的常见算法：查找和排序。

胖叔讲Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组方法（ES5/ES6）
L289121的博客
09-08 674
concat() 连接两个或更多的数组，并返回结果。 copyWithin() 从数组的指定位置拷贝元素到数组的另一个指定位置中。 entries() 返回数组的可迭代对象。 every() 检测数值元素的每个元素是否都符合条件。 fill() 使用一个固定值来填充数组。 filter() 检测数值元素，并返回符合条件所有元素的数组。 find() 返回符合传入测试（函数）条件的数组元素。 findIndex() 返回符合传入测试（函数）条件的数组元素索引。 forEach() 数组每个元素都执行一次回调函
DAY01_数组.md
05-22
DAY01_数组.md
数组(Array)
XYZ1110i的博客
03-19 1655
1：一维数组 数组(array)： 是一种用于存储多个相同数据类型的存储模型(可以理解为容器)。 1.2 数组定义和静态初始化 数组有两种定义格式： 格式1：数据类型[] 变量名; 范例： int[] arr; 定义了一个int类型的数组，数组名是arr 格式2：数据类型 变量名[]; 范例： int arr[]; 定义了一个int类型的变量，变量名是arr数组 推荐用格式1 数据的初始化 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度 格式：数据类型[] 变量名
数组
weixin_49033047的博客
03-08 671
数组的定义格式 1.数据类型[] 变量名 int[] arr 2.数据类型 变量名[] int arr[] 数组元素的访问 数组变量的访问方式：数组名 数组中的数据访问：数组名[索引] 动态初始化 数据类型[] 变量名= new 数据类型[元素个数] int[] arr=new int[3]; package _1; public class _61 { public static void main(String[] args) { int[] ar...
Java中数组的基本用法
m0_47442882的博客
07-06 1285
JAVA中关于数组的基本知识
DAY01_数组(1).md
03-29
DAY01_数组(1).md
VB.rar_vb 数组
09-24
在VB（Visual Basic）编程中，数组是一种非常重要的数据结构，它允许我们存储一组相同类型的数据。在这个"VB.rar_vb 数组"的例子中，我们将探讨如何创建数组，并且输出数组元素对应的一周中的星期。如果数组元素的值...
day04_接口和多态.zip
09-12
在这里，尽管数组声明为`Animal`类型，但我们可以放入`Dog`和`Cat`（假设`Cat`也实现了`Animal`接口）实例，这就是运行时多态。当我们调用数组元素的方法时，会根据实际的对象类型执行相应的方法，这就是多态的体现...
【详解】二维数组的长度问题。int[][] arr = new arr[3][4]；arr.length；arr[0].length；
CodingLJ
10-27 4696
二维数组可以看成一个一维数组。二维数组的行可以看成一维数组的元素，列可以看成具体其中的元素。 1、arr.length代表的是二维数组的行 2、arr[0].length是二维数组的列。 具体看下面测试代码： ...
java基础之数组
何小白的博客
05-24 217
一维数组 数组定义格式： 1.数据类型[] 数组名 示例：int[] arr 2.数据类型 数组名[] 示例：int arr[] 动态初始化 数组动态初始化就是只给定数组的长度，由系统给出默认初始化值 格式：数据类型[] 数组名 = new 数据类型[数组长度]; int[] arr = new arr[3]; //长度为3的数组 静态初始化 在创建数组时，直接将元素确定 格式：数据类型[] 数组名 =new 数据类型[]{元素1，元素2，元素3…}; 简化版:数据类型[] 数组名={元素1，元素2，元素
java中int[] arr和int arr[]有什么区别
Mr_zhang66的博客
03-01 4161
答：是一样的 []跟在变量名后面或者跟在类型后面都可以； int [ ]arr 这么写不对的 推荐 int[ ] arr 写法
学习笔记：数组
qq_44909275的博客
03-12 345
数组 一维数组 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行 int[] arr = new int[3]; arr[0] = 3; arr[1] = 9; arr[2] = 8; 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。 int a[] = new int[]{ 3, 9, 8}; int[] a = {3,9,8}; 一维数组的声明方式： type var...
用int[] arr=new int[]创建数组
热门推荐
aiaidebaba的博客
08-21 1万+
Java SE 数组的建立 package javaDemo.java; import java.util.Scanner; public class Zuoye4 { public static void main(String[] args) { int chengji; double sum=0; int[] arr=new int[6];//创建数组 int i ,b...
Java int [] arr数组以“引用”方式被传递
liujun2son
07-22 3624
最近遇到了一个有趣的问题？java方法参数的传递是不是总是按值传递（pass-by-value）？ 1.看案例 class TestDemo { public static void main(String[] args) { int [] arr1=new int[]{1,3,6,2,9}; printArrays(arr1);//输出的结
形参里是int arr[] 传参时要传arr
qq_54154945的博客
01-15 1470
形参中的int arr[] 实际上是整个函数声明的一部分，这是将这个参数声明为int型的数组，所以要加上[]来表示数组(其实是当作指针来用的)。 public static int getMax(int[] arr) { } 而函数调用传参数时，需要传递的是参数名，也就是数组名，当然就不需要[]了。其实传入的是这个数组第一个元素的地址，也就是指向第一个元素的指针。 getMax(arr); ...
Java中数组常见的几种排序方法！
06-01 1150
数组的定义：int[] arr = new int[5];        int[] arr1 = {1,2,3,4,5};                long[] arr2 = new long[6];                String[] strs = new String[5];                Person[] ps = new Person[5];　　　　　i...
可变参数 int...arr = int[] arr
weixin_43018910的博客
09-13 2396
public class Demo03 { public static void main(String[] args) { /* 可变参数 public static void method(int...arr) 等价于 public static void method(int[] ar...
c语言数组书写day语句
最新发布
11-24
以下是C语言数组的声明和初始化语句示例： ```c int arr1[5]; // 声明一个包含5个整数的数组 char arr2[5] = {'a', 'b', 'c', 'd', 'e'}; // 声明并初始化一个包含5个字符的数组 double arr3[] = {3.14, 4.2, 4.5, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值