胖虎的工具箱-编程导航 胖虎的工具箱-编程导航

Java数组解析（详解）

2年前 (2022) 程序员胖胖胖虎阿
242 0 0

数组

  • 前言
    • 一、数组的概述
      • 1.数组的理解
      • 2.数组相关的概念
      • 3.数组的特点
      • 4. 数组的分类
    • 二、一维数组的使用
      • 1. 声明和初始化
      • 2. 数组元素的引用
      • 3. 如何获取数组的长度
      • 4.如何遍历数组
      • 5.数组元素的默认初始化值
      • 6.数组的内存解析
    • 三、二维数组的使用
      • 1. 声明和初始化
      • 2. 数组元素的引用
      • 3.如何获取数组的长度
      • 4.如何遍历数组
      • 5.数组元素的默认初始化值
      • 6.数组的内存解析
    • 四、Arrays工具类的使用
    • 五、数组使用中的常见异常

前言

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！
也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

关注并私信博主，可领JDK1.8中文版！

一、数组的概述

1.数组的理解

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念

● 数组名
● 元素
● 角标、下标、索引
● 数组的长度：元素的个数

3.数组的特点

⭕ 数组是有序排列的。
⭕ 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
⭕ 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
⭕ 数组的长度一旦确定，就不能修改。
⭕ Java语言中声明数组时不能指定其长度(数组中元素的数)。
例如： int a[5]; //非法

4. 数组的分类

（1）按照维度：一维数组、二维数组、三维数组、…
（2）按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

二、一维数组的使用

1. 声明和初始化

⭕ 声明

格式：type var[];或 type[] var；
例如：int a[];int[] a1;double b[];String[] c; //引用类型变量数组

⭕ 初始化

（1）静态初始化（指定内容）：在定义数组的同时就为数组元素分配空间并赋值。

//例1：
int arr[] = new int[]{ 3, 9, 8};或 int[] arr = {3,9,8};

//例2：
String names[] = {“李四光”,“茅以升”,“华罗庚” }

（2）动态初始化（指定长度）：数组声明且为数组元素分配空间与赋值的操作分开进行。

//例1：
int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

//例2：
String names[];
names = new String[3];
names[0] = “钱学森”;
names[1] = “邓稼先”;
names[2] = “袁隆平”;

代码演示：

     //变量的声明和初始化
	  int num;//声明
      num = 10;//初始化
	  int id = 1001;//声明 + 初始化
	  
	 //一维数组的声明和初始化
	  int[] ids;//声明
	//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
	  ids = new int[]{1001,1002,1003,1004};
	//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
	  String[] names = new String[5];
	  		
	//错误的写法：
//		int[] arr1 = new int[];
//		int[5] arr2 = new int[5];
//		int[] arr3 = new int[3]{1,2, 3};
		
	//也是正确的写法：
		int[] arr4 = {1,2,3,4,5};//类型推断
		
	//总结：数组一旦初始化完成，其长度就确定了。

2. 数组元素的引用

⭕ 定义并用运算符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的长度(元素个数) ，且数组一旦初始化，其长度是不可变的。

代码演示：

	//调用数组的指定位置的元素:通过角标的方式调用。
	//数组的角标（或索引）从0开始的，到数组的长度-1结束。
	    String[] names = new String[5];
		names[0] = "王铭";
		names[1] = "王赫";
		names[2] = "张学良";
		names[3] = "孙居龙";
		names[4] = "王宏志";//charAt(0)
	    names[5] = "周扬"; //错误的

3. 如何获取数组的长度

//属性:length
	    String[] names = new String[5];
		System.out.println(names.length);//5

4.如何遍历数组

String[] names = new String[5];

⭕ 方式一（不采取）：

System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);
System.out.println(names[3]);
System.out.println(names[4]);

⭕ 方式二（推荐）：

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

5.数组元素的默认初始化值

⭕ 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

public class Test {
   public static void main(String argv[]){
         int a[]= new int[5];
         System.out.println(a[3]); //a[3]的默认值为0 
   } 
}

⭕ 对于基本数据类型而言，默认初始化值各有不同；对于引用数据类型而言，默认初始化值为null（注意与0不同）。

数组元素类型 元素默认初始值
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0
char 0 或写为:’\u0000’(表现为空)
boolean false
引用类型 null

(1) 数组元素是整型：0


		int[] arr = new int[4];
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+"/t");
		}
		
      //output：0  0  0  0

		short[] arr1 = new short[4];
		for(int i = 0;i < arr1.length;i++){
			System.out.println(arr1[i]+"\t");
		}
	 //output：0  0  0  0

(2) 数组元素是浮点型：0.0


        float[] arr2 = new float[5];
		for(int i = 0;i < arr2.length;i++){
			System.out.println(arr2[i]+"\t");
		}
		//out:0.0  0.0  0.0  0.0

(3) 数组元素是char型：0或’\u0000’，而非’0’

        char[] arr3 = new char[4];
		for(int i = 0;i < arr3.length;i++){
			System.out.println("----" + arr3[i] + "****");
		}
		
		if(arr3[0] == 0){
			System.out.println("你好！");
		}
		/*output:
		---- ****
        ---- ****
        ---- ****
        ---- ****
        你好!
        */

(4) 数组元素是boolean型：false

		boolean[] arr4 = new boolean[5];
		System.out.println(arr4[0]);
		//output:false

(5) 数组元素是引用数据类型：null

	    String[] arr5 = new String[5];
		System.out.println(arr5[0]);
		if(arr5[0] == null){
			System.out.println("北京天气不错！");
		}
		/*output:
		null
        北京天气不错！
        */

6.数组的内存解析

创建基本数据类型数组 (1)

● Java中使用关键字new来创 建数组
● 如下是创建基本数据类型元素的一维数组

public class Test{
  public static void main(String args[]){
    int[] s;
    s = new int[10];
    for ( int i=0; i<10; i++ ) {
      s[i] =2*i+1;
      System.out.println(s[i]);
    } 
  } 
}

int[] s;所处的内存状态：
Java数组解析（详解）
创建基本数据类型数组 (2)

public class Test{
  public static void main(String args[]){
    int[] s;
    s = new int[10];
//int[] s=new int[10];
//基本数据类型数组在显式赋值之前，
//Java会自动给他们赋默认值。
    for ( int i=0; i<10; i++ ) {
      s[i] =2*i+1;
      System.out.println(s[i]);
    } 
  } 
}

s = new int[10];所处的内存状态：

Java数组解析（详解）

创建基本数据类型数组 (3)

public class Test{
  public static void main(String args[]){
    int[] s;
    s = new int[10];
    for ( int i=0; i<10; i++ ) {
      s[i] =2*i+1;
      System.out.println(s[i]);
    } 
  } 
}

s[i] =2*i+1;所处的内存状态：
Java数组解析（详解）

内存解析：
Java数组解析（详解）

三、二维数组的使用

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。从数组底层的运行机制来看，其实没有多维数组。

1. 声明和初始化

⭕ 初始化
● 静态初始化（指定内容）

格式1：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
解析：

  1. 定义一个名称为arr的二维数组，二维数组中有三个一维数组。
  2. 每一个一维数组中具体元素也都已初始化 。
  3. 第一个一维数组 arr[0] = {3,8,2};
  4. 第二个一维数组 arr[1] = {2,7};
  5. 第三个一维数组 arr[2] = {9,0,1,6};
  6. 第三个一维数组的长度表示方式：arr[2].length;
  7. 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
  8. Java中多维数组不必都是规则矩阵形式

● 动态初始化（指定长度）

格式2：int[ ][ ] arr = new int[3][2];
解析：

  1. 定义了名称为arr的二维数组。
  2. 二维数组中有3个一维数组。
  3. 每一个一维数组中有2个元素。
  4. 一维数组的名称分别为arr[0], arr[1]
  5. arr[2] 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式3：int[][] arr = new int[3][];
解析

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

代码演示：

		int[] arr = new int[]{1,2,3};//一维数组
		
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		
		//错误的情况 
//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
		
		//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

2. 数组元素的引用

代码演示：

        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        String[][] arr2 = new String[3][2];
		System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		String[][] arr3 = new String[3][];
		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);//null

3.如何获取数组的长度

代码演示：

		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4

4.如何遍历数组

代码演示：

		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		for(int i = 0;i < arr4.length;i++){			
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
		}

5.数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素
例：int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等

（1）针对于初始化格式2：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同。

（2）针对于初始化格式3：比如：int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。

代码演示：

		int[][] arr = new int[4][3];
		System.out.println(arr);//[[I@6d06d69c
		System.out.println(arr[0]);//[I@15db9742 
		System.out.println(arr[0][0]);//0

		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);//[F@4554617c
		System.out.println(arr1[0][0]);//0.0

		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);//[Ljava.lang.String;@74a14482
		System.out.println(arr2[1][1]);//null

		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);//null
//		System.out.println(arr3[1][0]);//报错

6.数组的内存解析

Java数组解析（详解）

四、Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

number method function
1 boolean equals(int[] a,int[] b) 判断两个数组是否相等
2 String toString(int[] a) 输出数组信息
3 void fill(int[] a,int val) 将指定值填充到数组之中
4 void sort(int[] a) 对数组进行排序
5 int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值

例：数组排序：

java.util.Arrays类的sort()方法提供了数组元素排序功能

import java.util.Arrays;
public class SortTest {
  public static void main(String[] args) {
    int [] numbers = {5,900,1,5,77,30,64,700};
    Arrays.sort(numbers);
    for(int i = 0; i < numbers.length; i++){
    System.out.println(numbers[i]); 
    } 
  } 
}

五、数组使用中的常见异常

1.数组脚标越界异常(ArrayIndexOutOfBoundsException)

访问到了数组中的不存在的脚标时发生。

      int[] arr = new int[2];
//    System.out.println(arr[2]);
//    System.out.println(arr[-1]);

2.空指针异常(NullPointerException)

引用没有指向实体，却在操作实体中的元素时。

        //情况一：
		int[] arr1 = new int[]{1,2,3};
		arr1 = null;
//		System.out.println(arr1[0]);
		
		//情况二：
		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
//		System.out.println(arr3[0].toString());

以上两种异常，在编译时均不报错！

版权声明：程序员胖胖胖虎阿 发表于 2022年9月8日 下午10:40。
转载请注明：Java数组解析（详解） | 胖虎的工具箱-编程导航

相关文章

IDEA2019破解码(IDEA2020破解方法最新有效IDEA激活码)
程序员胖胖胖虎阿
144
Intellij IDEA最新版破解方法(idea的2019激活破解教程,成功激活)
程序员胖胖胖虎阿
316
IDEA最新版激活码(idea的2021免费激活码,每日更新)
程序员胖胖胖虎阿
323
IDEA正版永久激活码(IntelliJ IDEA2022.2激活码激活教程,绝对有效)
程序员胖胖胖虎阿
96
IntelliJ IDEA永久破解插件(IDEA最新永久破解码每日更新)
程序员胖胖胖虎阿
152
2022Java面试题大全，附答案，最新整理
程序员胖胖胖虎阿
288

暂无评论

暂无评论...
致力于称为最好的程序员导航网站

友链申请 免责声明 关于我们

Copyright © 2022  胖虎的工具箱-编程导航   陇ICP备2022001249号