Java基础系列（4）- 数组

1|0数组的概述

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

• 数组名

• 下标(或索引)

• 元素

• 数组的长度

3. 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
4. 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
5. 数组的长度一旦确定，就不能修改。
6. 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快.
7. 数组的分类：

• 按照维度：一维数组、二维数组、三维数组、…

• 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

2|0一维数组的使用

2|1声明

一维数组的声明方式：type var[] 或 type[] var

例如：

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组

Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

2|2初始化

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

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

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

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

int arr[] = new int[]{ 3, 9, 8};
或
int[] arr = {3,9,8};

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

2|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 的长度(元素个数)

  • 数组一旦初始化，其长度是不可变的

package com.atguigu.helloworld;

public class HelloWorld {
	public static void main(String[] args) {
		String[] names = new String[] {"z中angsan","lizi","sad","er","fhd"};
		for(int i = 0; i<names.length;i++) {
			System.out.println(names[i]);
	}
	}
}

2|4数组元素的默认初始化值

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

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

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

2|5数组的内存解析

内存的简化结构

案例一

升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。

屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静

public class ArrayTest {
	public static void main(String[] args) {
		int[] arr = new int[] { 8, 2, 1, 0, 3 };
		int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
		String tel = "";
		for (int i = 0; i < index.length; i++) {
			tel += arr[index[i]];
		}
		System.out.println("联系方式：" + tel);
	}
}

案例二

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

成绩>=最高分-10 等级为’A’

成绩>=最高分-20 等级为’B’

成绩>=最高分-30 等级为’C

其余 等级为’D’

提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

public class ArrayTest {
	public static void main(String[] args) {
		// 1.使用Scanner，读取学生个数
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入学生人数：");
		int number = scanner.nextInt();

		// 2.创建数组，存储学生成绩：动态初始化
		int[] scores = new int[number];

		// 3.给数组中的元素赋值
		System.out.println("请输入" + number + "个学生成绩：");
		for (int i = 0; i < scores.length; i++) {
			scores[i] = scanner.nextInt();
		}
		// 4.获取数组中的元素的最大值：最高分
		int maxScore = 0;
		for (int i = 0; i < scores.length; i++) {
			if (maxScore < scores[i]) {
				maxScore = scores[i];
			}
		}
		// 5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
		char level;
		for (int i = 0; i < scores.length; i++) {
			if (maxScore - scores[i] <= 10) {
				level = 'A';
			} else if (maxScore - scores[i] <= 20) {
				level = 'B';
			} else if (maxScore - scores[i] <= 30) {
				level = 'C';
			} else {
				level = 'D';
			}
			System.out.println("student" + i + " score is" + scores[i] + ",grade is"+ level);
		}
	}
}

3|0多维数组的使用

3|1动态初始化1：

int[][] arr = new int[3][2];

• 定义了名称为arr的二维数组

• 二维数组中有3个一维数组

• 每一个一维数组中有2个元素

• 一维数组的名称分别为arr[0], arr[1], arr[2]

• 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] =78;

3|2动态初始化2：

int[][] arr = new int[3][]

• 二维数组中有3个一维数组。

• 每个一维数组都是默认初始化值null (注意：区别于格式1）

• 可以对这个三个一维数组分别进行初始化

arr[0] = new int[3]; 
arr[1] = new int[1]; 
arr[2] = new int[2];

注：

int[][]arr = new int[][3]; //非法

3|3静态初始化：

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

• 定义一个名称为arr的二维数组，二维数组中有三个一维数组

• 每一个一维数组中具体元素也都已初始化

• 第一个一维数组 arr[0] = {3,8,2};

• 第二个一维数组 arr[1] = {2,7};

• 第三个一维数组 arr[2] = {9,0,1,6};

• 第三个一维数组的长度表示方式：arr[2].length;

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

Java中多维数组不必都是规则矩阵形式

3|4数组的简写

int[] arr = new int[]{1,2,3,4,5}
简写成
int[] arr = {1,2,3,4,5}

int[][] arr = new int[][]{{1,2,3},{4,5},{6,7,8}}
int[][] arr = {{1,2,3},{4,5},{6,7,8}}

练习

int[][] arr = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}

// 获取数组的长度
System.out.println(arr.length); //3
System.out.println(arr[0].length); //3
System.out.println(arr[1].length); //4

//如何遍历二维数组
for(int i = 0; i < arr.length; i++){
    for(int j = 0; j < arr[i].length; j++){
        System.out.print(arr[i][j] + " ");
    }
     System.out.println(); //换行的作用
}

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

int[][] arr = new int[4][3];
System.out.println(arr[0]);  //[I@15db9742  是个地址值
System.out.println(arr[0][0]); //0

System.out.println(arr); //[[I@6d06d69c   两个 [[ ，说明是个二维数组值

float[][] arr1 = new float[4][3];
System.out.println(arr1[0]);  //[F@15db9357  是个地址值 这里是F
System.out.println(arr1[0][0]); //0.0

String[][] arr2 = new String[4][3];
System.out.println(arr2[0]);  //[Ljava.lang.String;@6782e345
System.out.println(arr2[1][1]); //null

double[][] arr3 = new double[4][];
System.out.println(arr3[1]);  //null  不管是double还是其他的类型都是null，因为还没有指定

3|6二维数组的内存解析

杨辉三角

package firstpackage;

import javax.xml.transform.stream.StreamSource;

public class YangHui {
    public static void main(String[] args) {
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];

        //2.给数组的元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i + 1];

            //2.1 给首末元素幅值1
            yangHui[i][0] = yangHui[i][i] = 1;
            //2.2 给每行的非首末元素幅值
            //if(i > 1) {
            for (int j = 1; j < yangHui[i].length - 1; j++) {
                yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
            }
            //}
            //3.遍历二维数组
        }
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + " ");
            }
            System.out.println();
        }
    }
}

4|0Arrays 工具类的使用

在 Java 编程语言中，java.util.Arrays 类是一个包含用于操作数组（例如排序和搜索）的各种方法的工具类。这个类作为 Java 核心库的一部分，提供了一系列静态方法来处理数组，包括原始数据类型数组和对象数组。
Arrays 类的常用方法

Arrays 类提供了多种方法来执行数组操作，这些操作包括但不限于：

排序：Arrays.sort() 方法可以对数组进行排序。它有多个重载版本，可以对不同类型的数组进行排序，包括整数、字符串和自定义对象，只要这些对象实现了 Comparable 接口或者提供了 Comparator。

搜索：Arrays.binarySearch() 方法用于在已排序的数组中搜索特定的元素，并返回其索引位置。如果元素未找到，则返回一个负数。

比较：Arrays.equals() 方法用于比较两个数组的内容是否相等。

复制：Arrays.copyOf() 和 Arrays.copyOfRange() 方法用于复制数组的一部分或全部内容到一个新的数组。

填充：Arrays.fill() 方法用于将指定的值分配给数组的每个元素。

转换：Arrays.toString() 和 Arrays.deepToString() 方法用于将数组转换为字符串表示，便于打印和调试。

import java.util.Arrays;

public class ArraysExample {
public static void main(String[] args) {
// 创建一个整数数组
int[] numbers = {3, 2, 5, 4, 1};

// 对数组进行排序
Arrays.sort(numbers);

// 在数组中搜索元素
int index = Arrays.binarySearch(numbers, 4);

// 检查两个数组是否相等
int[] numbers2 = {1, 2, 3, 4, 5};
boolean areEqual = Arrays.equals(numbers, numbers2);

// 复制数组
int[] copiedNumbers = Arrays.copyOf(numbers, numbers.length);

// 填充数组
Arrays.fill(copiedNumbers, 0);

// 将数组转换为字符串
String arrayString = Arrays.toString(numbers);
}
}

使用 java.util.Arrays 类时，需要注意以下几点：

在使用 binarySearch() 方法之前，必须确保数组已经排序，否则结果是不确定的。

sort() 方法对于原始类型数组使用的是快速排序算法，对于对象数组使用的是归并排序算法。

equals() 方法在比较两个数组时，会考虑数组中元素的顺序。如果两个数组包含相同的元素但顺序不同，equals() 方法将返回 false。

copyOf() 和 copyOfRange() 方法在复制数组时，如果目标数组的长度大于源数组，多出的部分将被填充为默认值（例如，对于整数数组是 0）。

java.util.Arrays 类是 Java 开发者在处理数组时的重要工具，它简化了数组操作的复杂性，并提高了代码的可读性和效率。

__EOF__

本文作者：😎
本文链接：https://www.cnblogs.com/dongye95/p/14829737.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！