第三章 数组
3.1 数组的概述
3.1.1 数组的理解
数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
3.1.2 数组的相关概念
数组名，下标（或索引），元素，数组的长度。
3.1.3 数组的特点
数组的特点：数组是有序排列的。
数组本身是引用数据类型，而数组中的元素可以说任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能更改。我们可以直接通过下标（或索引）的方式调用指定位置的元素，速度很快。
3.1.4 数组的分类
①.按照维度：一维数组，二维数组，三维数组......
②.按照元素的数据类型分：基本数据类型元素的数组，引用数据类型元素的数组（即对象数组）
3.2 一维数组的使用
3.2.1 一维数组的声明和初始化 静态初始化和动态初始化
public class DemoArray01 {
public static void main(String[] args) {
//动态初始化数组
int[] array01 = new int[5];
//标准格式
// 静态初始化数组
int[] array02 = new int[]{1,2,3,4,5};
int[] array03 = {1,2,3,4,5}; //省略格式的静态初始化数组
}
}
3.2.2 如何调用数组指定位置的元素 根据数组角标（索引）
public class ArrayTest {
public static void main(String[] args) {
int[] array01 = {1, 2, 3, 4, 5}; //省略格式的静态初始化数组
//通过角标的方式调用，数组的角标（或索引）从0开始的，到数组的长度-1结束
int i0 = array01[0];
int i4 = array01[4];
System.out.println(i0);
System.out.println(i4);
}
}
3.2.3 如何获取数组的长度 调用length方法
public class ArrayTest {
public static void main(String[] args) {
int[] array01 = {1, 2, 3, 4, 5}; //省略格式的静态初始化数组
//length方法得到数组长度
int length = array01.length;
System.out.println(length);
}
}
3.2.4 如何遍历数组 利用for循环机制
public class ArrayTest {
public static void main(String[] args) {
int[] array01 = {1, 2, 3, 4, 5}; //省略格式的静态初始化数组
//利用for循环根据数组下标循环读取数组元素
for (int i = 0; i < array01.length; i++) {
System.out.println(array01[i]);
}
}
}
3.2.5 数组元素的默认初始值
3.2.6 一维数组的使用
3.3 多维数组的使用
3.3.1 多维数组的概述
Java 语言里提供了支持多维数组的语法。
如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个Excel表格。
对于二维数组的理解，我们可以看成是一堆一维数组arry01又作为另一个一维数组arry02的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。
3.3.2 多维数组的操作
//以二维数组为例
public class ArrayTest {
public static void main(String[] args) {
//二维数组的初始化
//静态初始化
int[][] array01 = new int[][]{
{1,2,3},{2,3,4},{7,8}};
//动态初始化
int[][] array02 = new int[2][3];
//二维数组获取元素
System.out.println(array01[0][1]);//2
System.out.println(array01[1][1]);//3
//二维数组获取长度
System.out.println(array01.length);//3
//二维数组遍历
for (int i = 0; i < array01.length; i++) {
for (int j = 0; j < array01[i].length; j++) {
System.out.print(array01[i][j]+" ");
}
System.out.println();
}
}
}
3.3.3 多维数组的使用
public class ArrayTest {
public static void main(String[] args) {
int[] arr = new int[6];
for (int i = 0; i < arr.length; i++) {
while (true) {
int random = (int) (Math.random() * 30 + 1);
int count = 0;
for (int j = 0; j < arr.length; j++) {
if (arr[j] == random) {
count++;
}
}
if (count == 0) {
arr[i] = random;
break;
}
}
}
for (int k : arr) {
System.out.print(k + " ");
}
}
}
3.4 数组中涉及到的常见算法
3.4.1 数组元素的赋值（杨辉三角，回形数等）
//杨辉三角
public class ArrayTest {
public static void main(String[] args) {
int[][] arr = new int[10][];
for (int i = 0; i < arr.length; i++) {
arr[i] = new int[i + 1];
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
if (j == 0 || i == j) {
arr[i][j] = 1;
} else {
arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
}
}
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}
3.4.2 求数值型数组中元素的最大值，最小值，平均数，总和等
public class ArrayTest {
public static void main(String[] args) {
//定义一个长度为10,int类型的一维数组
int[] array01 = new int[10];
//为其分配十个随机两位数的整数
for (int i = 0; i < array01.length; i++) {
int v = (int) (Math.random() * 90 + 10);
array01[i] = v;
}
for (Object O:array01) {
System.out.print(O+" ");
}
//求出数组内元素的最大值，最小值，和值，平均数，并输出
int maxValue = array01[0];
int minValue = array01[0];
int HeValue = array01[0];
for (int i = 1; i < array01.length; i++) {
if (array01[i]>maxValue){
maxValue = array01[i];
}
if (array01[i]<minValue){
minValue = array01[i];
}
HeValue+=array01[i];
}
System.out.println("\n数组最大值为："+maxValue
+"\n数组最小值为："+minValue
+"\n数组和值为："+HeValue
+"\n数组平均数为："+(HeValue/10));
}
}
3.4.3 数组的复制，反转，查找（线性查找，二分查找）
public class ArrayTest {
public static void main(String[] args) {
//数组的复制
int[] array01 = {1, 2, 3, 4, 5};
int[] array02 = new int[array01.length];
for (int i = 0; i < array01.length; i++) {
array02[i] = array01[i];
}
System.out.print("复制后的数组：");
for (int i = 0; i < array01.length; i++) {
System.out.print(array02[i] + " ");
}
//数组的反转
for (int i = 0; i < array01.length; i++) {
array02[array01.length - i - 1] = array01[i];
}
System.out.print("\n反转后的数组：");
for (int i = 0; i < array01.length; i++) {
System.out.print(array02[i] + " ");
}
//数组的线性查找
boolean a = true;
for (int i = 0; i < array01.length; i++) {
if (array01[i] == 7) {
System.out.println("\n找到了指定元素，数组下标为：" + i);
a = false;
break;
}
}
if (a) {
System.out.println("\n没有找到指定元素");
}
//数组的二分查找
int c = 1;
int head = 0;
int end = array01.length - 1;
boolean b = true;
while (head < end) {
int middle = (head + end) / 2;
if (array01[middle] == c) {
System.out.println("\n找到了指定元素，数组下标为：" + middle);
b = false;
break;
}else if (array01[middle] > c) {
end = middle - 1;
}else if (array01[middle] < c) {
head = middle + 1;
}
}
if (b) {
System.out.println("\n没有找到指定元素");
}
}
}