当前位置 > it书童 > java > 正文

java 数组入门详解

java it书童 2020-08-07 14:11:38 0赞 0踩 102阅读 0评论

数组的概念:是一种容器,可以同时存放多个数据值。

数组的特点:

  1. 数组是一种引用数据类型

  2. 数组当中的多个数据,类型必须统一

  3. 数组的长度在程序运行期间不可改变

静态初始化与动态初始化数组

数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。

两种常见的初始化方式:

  1. 动态初始化(指定长度)

  2. 静态初始化(指定内容)

动态初始化数组的格式:

数据类型[] 数组名称 = new 数据类型[数组长度];

// 动态创建数组,指定长度
int[] arrayA = new int[300];
double[] arrayB = new double[10];
String[] arrayC = new String[5];

静态初始化基本格式:

数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

注意事项:

虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自动推算出来长度。

int[] arrayA = new int[] { 5, 15, 25, 40 };
String[] arrayB = new String[] { "Hello", "World", "Java"};

使用静态初始化数组的时候,格式还可以省略一下。

标准格式:数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

省略格式:数据类型[] 数组名称 = { 元素1, 元素2, ... };

注意事项:

  1. 静态初始化没有直接指定长度,但是仍然会自动推算得到长度。

  2. 静态初始化标准格式可以拆分成为两个步骤。

  3. 动态初始化也可以拆分成为两个步骤。

  4. 静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。

使用建议:如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。

// 动态初始化可以拆成两个步骤
int[] arrayC;
arrayC = new int[5];

// 静态初始化可以拆成两个步骤
int[] arrayB;
arrayB = new int[] { 11, 21, 31 };

// 省略格式的静态初始化 创建与赋值不可再拆分
int[] arrayA = { 10, 20, 30 };

打印数组

直接打印数组名称,得到的是数组对应的:内存地址哈希值。

访问数组元素的格式:数组名称[索引值]

索引值:就是一个int数字,代表数组当中元素的编号。

【注意】索引值从0开始,一直到“数组的长度-1”为止

int[] array = { 10, 20, 30 };
System.out.println(array); // [I@47d384ee
// 打印数组元素
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);

默认值

使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:

  • 如果是整数类型,那么默认为0;

  • 如果是浮点类型,那么默认为0.0;

  • 如果是字符类型,那么默认为'\u0000';

  • 如果是布尔类型,那么默认为false;

  • 如果是引用类型,那么默认为null。

注意事项:静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为了大括号当中的具体数值

int[] array = new int[3];
System.out.println(array[0]); // 0
System.out.println(array[1]); // 0
System.out.println(array[2]); // 0
System.out.println("==================");

array[1] = 123;
System.out.println(array[0]); // 0
System.out.println(array[1]); // 123
System.out.println(array[2]); // 0

数组的内存图示

java中的内存划分

  1. 栈 Stack

存放方法中的局部变量。方法的运行一定要在栈当中

局部变量:方法的参数,或者方法{}内部的变量

作用域:一旦超出作用域,立刻从栈内存当中消失

  1. 堆 Heap

凡是 new 出来的东西,都在堆当中

堆内存里面的东西都有一个地址值。堆内存里面的数据,都有默认值

  1. 方法区 Method Area

存储 .class 相关信息,包含方法的信息

  1. 本地方法栈 Native Method Stack

  2. 寄存器 Pc Register 与 cpu 相关

只有一个数组的内存图

有两个独立数组的内存图

两个引用指向同一个数组的内存图

数组异常

数组的索引编号从0开始,一直到“数组的长度-1”为止。

如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常 ArrayIndexOutOfBoundsException

原因:索引编号写错了

解决:修改成为存在的正确索引编号

int[] array = { 15, 25, 35 };
System.out.println(array[3]); // Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

所有的引用类型变量,都可以赋值为一个null值。但是代表其中什么都没有。

数组必须进行 new 初始化才能使用其中的元素。如果只是赋值了一个null,没有进行new创建,那么将会发生:空指针异常 NullPointerException

原因:忘了new

解决:补上new

int[] array = null;
System.out.println(array[0]); // Exception in thread "main" java.lang.NullPointerException

数组扩展

如何获取数组的长度,格式:数组名称.length

这将会得到一个int数字,代表数组的长度。

数组一旦创建,程序运行期间,长度不可改变。

int[] arrayA = new int[3];
int[] arrayB = { 10, 8, 9, 3, 69, 901, 23 };
int len = arrayB.length;
System.out.println("arrayB 数组的长度是:" + len); // arrayB 数组的长度是:7

int[] arrayC = new int[3];
System.out.println(arrayC.length); // 3
// 重新赋值,并不是改变数组的长度
arrayC = new int[5];
System.out.println(arrayC.length); // 5

遍历数组,对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出

int[] array = { 15, 25, 30, 40, 50, 60, 75 };
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

求数组的最大值

int[] array = { 5, 15, 30, 20, 10000, 30, 35 };
int max = array[0];
for (int i = 1; i < array.length; i++) {
    // 如果当前元素比 max 大,就将 max 让给当前元素
    if (array[i] > max) {
        max = array[i];
    }
}
System.out.println(max); // 10000

反转数组元素

本来的样子:[1, 2, 3, 4],之后的样子:[4, 3, 2, 1]

要求不能使用新数组,就用原来的唯一一个数组

思路示图:

int[] array = { 1, 2, 3, 4 };
for (int min = 0, max = array.length - 1; min < max; min++, max--) {
    int temp = array[min];
    array[min] = array[max];
    array[max] = temp;
}
for (int i = 0; i < array.length; i++) {
    System.out.print(array[i]); // 4321
}
转载须注明出处:https://www.itshutong.com/articles/538/introduction-of-java-array
关于我
一个文科出身的程序员,追求做个有趣的人,传播有价值的知识,微信公众号主要分享读书思考心得,不会有代码类文章,非程序员的同学请放心订阅
发表评论
我有句话,不知当讲不当讲?
要讲之前请先 登录