Java基础教程

文章36 |   阅读 18634 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

Java基础系列11-数组简介

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

一.数组概述

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

数组的定义格式:

  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. 		//完整写法
  9. 		int[] arr = new int[]{2,5,7};
  10. 		//其他写法 不推荐
  11. 		//解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。结果相同，但推荐用第一种写法。
  12.       	//一般将实例名（这里指arr）放在等号左侧相邻的位置，否则容易引起歧义（变量名到底是 arr 还是 arr[] ?）。 
  13. 		int arr[] = new int[]{2,5,7};
  14. 		//简化写法 不推荐
  15. 		int[] arr = {2,5,7};

2.1 动态初始化

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

格式:

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

实例：

  1. -- 定义了一个int类型的数组，这个数组中可以存放3个int类型的值，系统自定分配初始值，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;
  3. public class shuzu1 {
  4. 	public static void main(String[] args) {
  5. 		//数据类型[] 数组名 = new 数据类型[数组长度];
  6. 		int[] arr = new int[3];
  7. 		
  8. 		/* * 左边： * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * arr:是数组的名称 * 右边： * new:为数组分配内存空间 * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * 3:数组的长度，其实就是数组中的元素个数 */
  9.          
  10. 		
  11. 		//数据类型[] 数组名 = new 数据类型[数组长度];
  12. 		int[] arr2 = new int[4];
  13. 		//遍历arr数组,并给数组总的每个元素赋值(除最后一个)
  14. 		for (int i = 0; i < arr2.length -1; i++) {
  15. 			arr2[i] = i * 5 - 1;
  16. 		}
  17. 		/* * 左边： * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * arr:是数组的名称 * 右边： * new:为数组分配内存空间 * int:说明数组中的元素的数据类型是int类型 * []:说明这是一个数组 * 3:数组的长度，其实就是数组中的元素个数 */
  18.          
  19. 		//输出数组名
  20. 		System.out.println("arr2:" + arr2);
  21. 		
  22. 		System.out.println("arr2[0]:" + arr2[0]);
  23. 		System.out.println("arr2[1]:" + arr2[1]);
  24. 		System.out.println("arr2[2]:" + arr2[2]);
  25. 		System.out.println("arr2[3]:" + arr2[3]);
  26. 	}
  28. }

测试记录:

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

测试记录:

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

测试记录:

  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

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/119674607

内容来源于网络，如有侵权，请联系作者删除！

上一篇：Random随机数
下一篇：方法
Javajava数组

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com