Java基础系列11-数组简介

x33g5p2x  于2021-12-18 转载在 其他  
字(7.7k)|赞(0)|评价(0)|浏览(539)

一.数组概述

数组是存储同一种数据类型,多个元素的容器。
数组即可存储基本数据类型,也可以存储引用数据类型。

数组的定义格式:

  1. 格式1:数据类型[] 数组名;
  2. 格式2:数据类型 数组名[];
    1)注意:这两种定义做完了,数组中是没有元素值的。如何对数组的元素进行初始化呢?

二.数组初始化

Java中的数组必须先初始化,然后才能使用。
数组初始化就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。

数组的初始化有以下两种方式:

  1. 动态初始化:初始化时程序员只指定数组长度,由系统为数组元素分配初始值。
  2. int[] arr = new int[3];
  3. arr[0]=2;
  4. arr[1]=5;
  5. arr[2]=7;
  6. 静态初始化:初始化时由程序员显式指定每个数组元素的初始值,由系统决定数组长度。
  7. //完整写法
  8. int[] arr = new int[]{2,5,7};
  9. //其他写法 不推荐
  10. //解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值。结果相同,但推荐用第一种写法。
  11. //一般将实例名(这里指arr)放在等号左侧相邻的位置,否则容易引起歧义(变量名到底是 arr 还是 arr[] ?)。
  12. int arr[] = new int[]{2,5,7};
  13. //简化写法 不推荐
  14. int[] arr = {2,5,7};

2.1 动态初始化

动态初始化是给出数组的长度,初始值由系统为数组分配。

格式:

  1. 标准写法:数据类型[] 数组名 = new 数据类型[数组长度];
  2. 其他写法:数据类型 数组名[] = new 数据类型[数组长度];(不推荐)

实例:

  1. -- 定义了一个int类型的数组,这个数组中可以存放3int类型的值,系统自定分配初始值,int类型初始值为0
  2. int[] arr = new int[3];
  3. int arr[] = new int[3]; //不推荐

数组长度:
上例中数组的长度为3

获取元素的格式:

  1. 数组名[索引] => arr[0] = 0;
  2. 索引编号从0开始,最大的编号是数组的长度 -1 => new int[3] 索引最大编号为 2;

动态初始化的值:

动态初始化数据类型默认值备注
byte,short,int,long0
float double0.0
char‘\u0000’\u表示unicode编码,\u0000 表示Unicode编码中的 null
booleanfalse
引用类型null

代码:

  1. package Java_study;
  2. public class shuzu1 {
  3. public static void main(String[] args) {
  4. //数据类型[] 数组名 = new 数据类型[数组长度];
  5. int[] arr = new int[3];
  6. /* * 左边: * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * arr:是数组的名称 * 右边: * new:为数组分配内存空间 * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * 3:数组的长度,其实就是数组中的元素个数 */
  7. //数据类型[] 数组名 = new 数据类型[数组长度];
  8. int[] arr2 = new int[4];
  9. //遍历arr数组,并给数组总的每个元素赋值(除最后一个)
  10. for (int i = 0; i < arr2.length -1; i++) {
  11. arr2[i] = i * 5 - 1;
  12. }
  13. /* * 左边: * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * arr:是数组的名称 * 右边: * new:为数组分配内存空间 * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * 3:数组的长度,其实就是数组中的元素个数 */
  14. //输出数组名
  15. System.out.println("arr2:" + arr2);
  16. System.out.println("arr2[0]:" + arr2[0]);
  17. System.out.println("arr2[1]:" + arr2[1]);
  18. System.out.println("arr2[2]:" + arr2[2]);
  19. System.out.println("arr2[3]:" + arr2[3]);
  20. }
  21. }

测试记录:

  1. arr2:[I@15db9742
  2. arr2[0]:-1
  3. arr2[1]:4
  4. arr2[2]:9
  5. arr2[3]:0

2.2 数组内存结构

Java 程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

  1. 栈:存储局部变量,对象实例的地址
  2. 堆:存储new出来的东西,对象实例
  3. 方法区:包含类从磁盘到内存的整个生命周期,编译>加载>连接>初始化>使用>卸载
  4. 本地方法区:和系统相关,实现Java应用与Java外面环境的交互,本地方法提供接口,实现体在外面其他语言。在windows中就是使用windows系统语言实现Java代码

数组的内存图:
需要掌握一个数组在内存中的变化,其他的内存图能看懂即可。
数组与对象的处理方式相同,因此通过一个实例:调用方法m1时的过程,来观察数组及其引用的存储位置。

  1. class A {
  2. int x;
  3. int y;
  4. }
  5. ...
  6. public void m1() {
  7. int i = 0;
  8. m2();
  9. }
  10. public void m2() {
  11. A a = new A();
  12. }
  1. 当m1被调用的时候,栈帧Frame-1被创建并push到栈中,同时局部变量i也在栈帧Frame-1内创建。
  2. 然后,m2方法在m1方法内部被调用,栈帧Frame-2被创建并push到栈中,在m2方法中,一个新的对象A在堆中被创建,而它的引用则被put到栈帧Frame-2里;

2.3 静态初始化

数组的静态初始化:给出初始化值,由系统决定长度。

格式:

  1. 标准写法:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,…};
  2. 其他写法:数据类型 数组名[] = new 数据类型[]{元素1,元素2,元素3,…};(不推荐)
  3. 简化写法:数据类型[] 数组名 = {元素1,元素2,元素3,…}; (不推荐)

实例:

  1. int[] arr = new int[]{2,5,7};
  2. int arr[] = new int[]{2,5,7}; //不推荐
  3. int[] arr = {2,5,7}; //不推荐

数组长度:
数组中元素的个数。3个。

获取元素的格式:
数组名[索引] => arr[0] = 2;
索引编号从0开始,最大的编号是数组的长度 -1 => new int[3] 索引最大编号为 2

代码:

  1. package Java_study;
  2. public class shuzu2 {
  3. public static void main(String[] args) {
  4. //静态初始化一个数组
  5. int[] arr = {1, 2, 3};
  6. //在栈中存储了arr实例名对应在 堆中的(实例对象)内存地址 arr:[I@50134894
  7. System.out.println("arr:" + arr);
  8. //在堆中存储了arr实例对象索引为0的 实际值1
  9. System.out.println("arr[0]:" + arr[0]);
  10. //在堆中存储了arr实例对象索引为1的 实际值2
  11. System.out.println("arr[1]:" + arr[1]);
  12. //在堆中存储了arr实例对象索引为2的 实际值3
  13. System.out.println("arr[2]:" + arr[2]);
  14. }
  15. }

测试记录:

  1. arr:[I@15db9742
  2. arr[0]:1
  3. arr[1]:2
  4. arr[2]:3

2.4 二维数组

二维数组是元素为一维数组的数组。

格式:

  1. 动态初始化: m 表示的是二维数组中一维数组的个数;n 表示的是一维数组中的元素个数
    1)标准写法:数据类型[m][n] 数组名 = new 数据类型[m][n];
    2)其他写法:数据类型[m] 数组名[n] = new 数据类型[m][n]; (不推荐)
    3)其他写法:数据类型 数组名[m][n] = new 数据类型[m][n]; (不推荐)
  2. 静态初始化
    1)标准写法:数据类型[][] 数组名 = new 数据类型[][]{{元素…},{元素…},{元素…},…};
    2)简化格式:数据类型[][] 数组名 = {{元素…},{元素…},{元素…},…};

动态初始化实例:
解释:在Java中我们只能有一个一维数组。2维数组只是1维数组的数组。
动态初始化一个数组长度为3的二维数组,二维数组中的元素为3个长度分别为3,5,4的动态初始化的一维数组。

  1. int[ ][ ] arr = new int[3][ ];
  2. //int[ ] arr[ ] = new int[3][ ];//不推荐
  3. //int arr[ ][ ] = new int[3][ ];//不推荐
  4. arr[0] = new int[3];
  5. arr[1] = new int[5];
  6. arr[2] = new int[4];
  7. arr[0][0] = 1;
  8. arr[0][1] = 2;
  9. arr[0][2] = 3;

图解动态初始化实例:

静态初始化实例:

  1. int[][] arr = new int[][]{{1, 2, 3}, {10, 20, 30}, {100, 200}, {Integer.valueOf('s'), Integer.valueOf('a')}};
  2. //int[][] arr = {{1, 2, 3}, {10, 20, 30}, {100, 200}, {Integer.valueOf('s'), Integer.valueOf('a')}};//不推荐

数组长度:
数组中元素的个数。外层为3个,内层分别为3个,5个,4个。

获取元素的格式:
数组名[索引] => arr[0][0] = 0;
索引编号从0开始,最大的编号是数组的长度 -1 => new int[3] 索引最大编号为 2

代码:

  1. package Java_study;
  2. public class shuzu3 {
  3. public static void main(String[] args) {
  4. //今天初始化一个二维数组,其中包含4个以为数组
  5. int[][] arr = new int[][] {
  6. {1, 2, 3},
  7. {10, 20 ,30},
  8. {100, 200},
  9. {Integer.valueOf('s'), Integer.valueOf('a')}
  10. };
  11. System.out.println("arr[0]:" + arr[0]);
  12. System.out.println("arr[1]:" + arr[1]);
  13. System.out.println("arr[2]:" + arr[2]);
  14. System.out.println("==========");
  15. System.out.println("arr[0][0]: " + arr[0][0]);
  16. System.out.println("arr[0][1]: " + arr[0][1]);
  17. System.out.println("arr[0][2]: " + arr[0][2]);
  18. System.out.println("arr[2][0]: " + arr[2][0]);
  19. System.out.println("arr[2][1]: " + arr[2][1]);
  20. System.out.println("arr[3][0]: " + arr[3][0]);
  21. System.out.println("arr[3][1]: " + arr[3][1]);
  22. //如数组索引不存在会报错
  23. try {
  24. System.out.println("arr[2][2]: " + arr[2][2]);
  25. } catch (ArrayIndexOutOfBoundsException e) {
  26. System.out.println("数组越界异常: 访问不存在的索引.");
  27. // e.printStackTrace();
  28. }
  29. //遍历数组: 首先遍历外层,获取二维数组中的每一个元素
  30. for (int i = 0; i < arr.length; i++) {
  31. //arrInner为外层数组的元素,这个元素为一维数组
  32. int[] arrInner = arr[i];
  33. //继续遍历这个以为数组arrInner
  34. for (int j = 0; j < arrInner.length; j++) {
  35. //取出一维数组中的每一个int类型元素,并赋值给变量a,并打印这个元素值
  36. int a = arrInner[j];
  37. System.out.println(a);
  38. /* 1 2 3 ----- 10 20 30 ----- 100 200 ----- 115 ('s')对应码表值为115 97 ('a')对应码表值为97 ----- */
  39. }
  40. System.out.println("-----");
  41. }
  42. }
  43. }

测试记录:

  1. arr[0]:[I@15db9742
  2. arr[1]:[I@6d06d69c
  3. arr[2]:[I@7852e922
  4. ==========
  5. arr[0][0]: 1
  6. arr[0][1]: 2
  7. arr[0][2]: 3
  8. arr[2][0]: 100
  9. arr[2][1]: 200
  10. arr[3][0]: 115
  11. arr[3][1]: 97
  12. 数组越界异常: 访问不存在的索引.
  13. 1
  14. 2
  15. 3
  16. -----
  17. 10
  18. 20
  19. 30
  20. -----
  21. 100
  22. 200
  23. -----
  24. 115
  25. 97
  26. -----

三.数组的方法

  1. 声明一个数组
  1. String[] aArray = new String[5];
  2. String[] bArray = {"a","b","c", "d", "e"};
  3. String[] cArray = new String[]{"a","b","c","d","e"};
  1. 打印一个数组
  1. int[] intArray = { 1, 2, 3, 4, 5 };
  2. String intArrayString = Arrays.toString(intArray);
  3. // print directly will print reference value
  4. System.out.println(intArray);
  5. // [I@7150bd4d
  6. System.out.println(intArrayString);
  7. // [1, 2, 3, 4, 5]
  1. 根据数组创建ArrayList
  1. String[] stringArray = { "a", "b", "c", "d", "e" };
  2. ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
  3. System.out.println(arrayList);
  4. // [a, b, c, d, e]
  1. 判断数组内部是否包含某个值
  1. String[] stringArray = { "a", "b", "c", "d", "e" };
  2. boolean b = Arrays.asList(stringArray).contains("a");
  3. System.out.println(b);
  4. // true
  1. 连接两个数组
  1. int[] intArray = { 1, 2, 3, 4, 5 };
  2. int[] intArray2 = { 6, 7, 8, 9, 10 };
  3. // Apache Commons Lang library
  4. int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);
  1. 声明一个内联数组(array inline)
  1. method(new String[]{"a", "b", "c", "d", "e"});
  1. 根据分隔符拼接数组元素(去掉最后一个分隔符)
  1. // containing the provided list of elements
  2. // Apache common lang
  3. String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
  4. System.out.println(j);
  5. // a, b, c
  1. ArrayList转数组
  1. String[] stringArray = { "a", "b", "c", "d", "e" };
  2. ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
  3. String[] stringArr = new String[arrayList.size()];
  4. arrayList.toArray(stringArr);
  5. for (String s : stringArr)
  6. System.out.println(s);
  1. Array转Set
  1. Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
  2. System.out.println(set);
  3. //[d, e, b, c, a]
  1. 反转数组
  1. int[] intArray = { 1, 2, 3, 4, 5 };
  2. ArrayUtils.reverse(intArray);
  3. System.out.println(Arrays.toString(intArray));
  4. //[5, 4, 3, 2, 1]
  1. 删除数组元素
  1. int[] intArray = { 1, 2, 3, 4, 5 };
  2. int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
  3. System.out.println(Arrays.toString(removed));
  1. 整形转字节数组
  1. byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();
  2. for (byte t : bytes) {
  3. System.out.format("0x%x ", t);
  4. }

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/113333437
  2. https://www.cnblogs.com/chenpi/p/5507806.html
上一篇:Random随机数
下一篇:方法

相关文章