Java基础系列（4）- 数组

数组的概述

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

• 数组名

• 下标(或索引)

• 元素

• 数组的长度

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

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

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

一维数组的使用

声明

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

例如：

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

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

初始化

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

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[] = {“李四光”,“茅以升”,“华罗庚” }

数组元素的引用

• 定义并用运算符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]);
	}
	}
}

数组元素的默认初始化值

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

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

数组的内存解析

内存的简化结构

案例一

升景坊单间短期出租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);
		}
	}
}

多维数组的使用

动态初始化1：

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

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

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

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

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

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

动态初始化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]; //非法

静态初始化：

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中多维数组不必都是规则矩阵形式

数组的简写

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(); //换行的作用
}

数组元素的默认初始化值

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，因为还没有指定

二维数组的内存解析

杨辉三角

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();
        }
    }
}