1 数组的概述
1.1 数组的概念
数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
常见概念：数组名
角标、下标（或索引）（从0开始）
元素
数组的长度：元素的个数
1.2 数组的特点
- 数组是有序排列的
- 数组本身是
引用数据类型的变量，数组元素既可以是基本数据类型，也可以是引用数据类型。 - 创建数组对象在内存中开辟一整块
连续的空间，而数组名中引用的是这块连续空间的首地址。 - 数组的长度一旦确定就不可以修改
1.3 数组的分类
- 按照维数：一维数组、二维数组、…
- 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
1.4 数据结构
- 数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
- 数据的存储结构：
线性表：顺序表（比如：数组）、链表、栈、队列
树形结构：二叉树
图形结构
算法：
排序算法
搜索算法
2 一维数组的使用
2.1 一维数组的声明和初始化
1.一维数组的声明和初始化
int[] ids;//声明
1.1 静态初始化:数组的初始化和数组元素赋值操作同时进行
int[] ids = new int[]{1001,1002,1003,1004};
1.2 动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
总结：数组一旦初始化完成，其长度就确定了
2.2 如何调用数组的指定位置的元素
方式：通过角标的方式调用
数组的角标（或索引）从0开始，到数组的长度减一结束
names[0] = "王鸣";
names[1] = "王鹤";
names[2] = "张学良";
names[3] = "张汉卿";
names[4] = "杨虎城";
2.3 如何获取数组的长度
属性：length
System.out.println(names.length);
System.out.println(ids.length);
2.4 如何遍历数组
直接遍历
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]);}
2.5 数组元素默认初始化值
数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或’\u0000’,即‘0’的ASCII码
数组元素是boolean型：false
数组元素是引用数据类型时（以String为例）：null（意为空，没赋值）
2.6 数组的内存解析
- main方法中都是局部变量
- 引用类型的变量在堆中存的要么是null 要么是地址值
3 多维数组的使用
多维数组中以二维数组居多
二维数组的理解：可以看成是一维数组array1又作为另一个一维数组array2 的元素而存在。其实从数组的底层运行机制来看，没有多维数组。
3.1 二维数组的声明和初始化
int[] arr = new int[]{1,2,3};
也可以这样写 int[] arr = {1,2,3}; (属于类型推断)
静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{7,8,9}};
动态初始化1
String[][] arr2 = new String[3][2];
动态初始化2
String[][] arr3 = new String[3][];
动态初始化3
String arr4[][] = new String[3][2];
String[] arr5[] = new String[3][2];
错误的情况 String[][] arr4 = new String[][3](外层不确定，就去整内层自然不对);
3.2 如何调用数组的指定位置元素
System.out.println(arr2[1][1]);//null
arr3[1] = new String[4];//因为要调内层的某个元素，故确定下其位置；这里就更加体现二维数组本质是一个一维数组中的元素又是一个一维数组
System.out.println(arr3[1][0]);
3.3 获取数组的长度
System.out.println(arr4.length);//3 外层
System.out.println(arr4[0].length);//2
二维数组的长度看外层的数组长度，与内层无关；
但可以问外层某一个元素的长度（如第二个例子），此时就是问对应的内层的长度
3.4 如何遍历二维数组
for(int i = 0;i <arr1.length;i++){
for(int j = 0;j < arr1[i].length;j++){
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
规定：二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]...
内层元素：arr[0][0],arr[1][2]…
3.5 数组元素的默认初始化值
- 针对于初始化方式一：比如int[][] arr = new int[4][3];
- 外层元素的初始化值为：地址值
- 内层元素的初始化值为：与一维数组初始化值情况相同
- 针对初始化方式二：比如double[][] arr3 = new double[4][];
- 外层元素的初始化值为：null
- 内层元素的初始化值为：不能调用，否则报错
3.6 数组的内存解析
对于给出的代码画出以下的图示，以便更好地理解代码含义
练习
说明：
x：一维int 型数组y：二维int 型数组
a）no 二维的数组不可以赋值给一个数
b）yes， 一维的数组可以赋值给二维数组的一个外层空间
c）no， 一维数组不可以赋值给二维数组的一个元素
d）no， 错的离谱
e）yes， 一维数组的一个元素可以赋值给二维数组的一个元素
f）no， 一维和二维不可直接赋值
public class YangHuiTest {
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 给每行的首末元素赋值
yanghui[i][0] = 1;
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 数组中常见的算法
4.1 数组元素的赋值（杨辉三角、回形数）
此题以及回形数题在第三章章节练习中
4.2 求数值型数字中的元素的最大值、最小值、平均数、总和
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
//赋随机二位数的值 10-99
for(int i = 0;i < arr.length;i++){
arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
}
//遍历一下数组
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
System.out.println();
//求数组元素的最大值
int maxValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
//求数组元素的最小值
int minValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println("最小值为：" + minValue);
//求数组元素的总和
int sum = 0;
for(int i = 0;i < arr.length;i++){
sum += arr[i];
}
System.out.println("总和为：" + sum);
//求数组元素的平均值
int averValue = sum / arr.length;
System.out.println("平均数为：" + averValue);
}
}
4.3 数组的复制、反转、查找（线性查找、二分查找）
-
数组的复制（区别于数组变量的赋值，arr1=arr2）
String[] arr1 = new String[arr.length]; for(int i = 0;i < arr1.length;i++){ arr1[i] = arr[i]; } -
数组的反转
for(int i = 0;i < arr.length / 2;i++){ String temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } //方式二（推荐） for(int i = 0, j = arr.length - 1;i < j;i++,j--){ String temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; }
public class ArrayExer2 {
public static void main(String[] args){
int[] array1,array2;
array1 = new int[]{2,3,5,7,11,13,17,19};
//显示array1的初始内容
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");
}
//赋值array2变量等于array1,准确说是建立array1的“快捷方式”
array2 = array1;
//修改array2中偶索引元素，使其值等于索引值
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}
}
System.out.println();
//打印array1
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");
}
}
}
此题注意：为何进行操作 array2=array1 后，对array2进行元素操作后，array1 也发生了变化
因为：操作array2=array1 只是把地址值赋给了array2 ，我们只new了一次，因此堆中只有一组数（之前赋给array1 的那一组数，所以对array2 的数操作，其实操作之后array1 仍然读取的是同一组数据，故array1 中的数也跟着一起变化）。array1和array2的地址值相同，都指向了堆空间的唯一的一个数组实体
真正实现数组的复制：
//真正实现数组的复制
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
下面给出内存解析：
- 线性查找
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//查找（或搜索）
//线性查找
String dest = "CC";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.println("找到了指定的元素，位置为：" + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("抱歉没有找到");
}
System.out.println();
-
二分查找
//二分法查找：所要查找的数组必须有序 int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333}; int dest1 = 79; int head = 0; int end = arr2.length - 1; boolean isFlag1 = true; while(head <= end){ int middle = (head + end)/2; //这里的处理方式不太好，容易数据溢出 if(dest1 == arr2[middle]){ System.out.println("找到了指定元素，位置为：" + middle); isFlag1 = false; break; }else if(arr2[middle] > dest1){ end = middle - 1; }else{ head = middle; } } if(isFlag1){ System.out.println("很抱歉没有找到哦！"); }
4.4 数组元素的排序算法
冒泡排序和快速排序要熟练掌握
堆排序和归并排序知道原理和思想就行（考试前复习）
算法的特征：输入、 输出、 有穷性 、确定性 、可行性
一、冒泡排序
若序列中有n个元素，通常进行n-1趟。每一趟进行的过程是从第一个元素开始，比较两个相邻元素的大小，若相邻位置元素的相对位置不正确，则进行交换；否则继续进行下面两个相邻的元素。
public class BubbleSort {
public static void main(String[] args){
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr.length - i - 1;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
}
二、快速排序
20世纪十大算法之一（了解思想之后在考试前背过就行）
排序性能： 时间复杂度：堆排序 O(nlog2n) 快速排序O(nlog2n) 冒泡排序O(n2)
5 数组工具类的使用
1.boolean equals(int[] a,int[] b)://判断两个数组是否相等
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1,arr2);
System.out.println(isEquals);//false(数组是有顺序的)
2. String toString(int[] a)://输出数组信息
System.out.println(Arrays.toString(arr1));
3. void sort(int[] a)://对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
4. void fill(int[] a,int val)://将指定的值填充到数组之中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
5. int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3,210);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("没找到！");
更多的工具类在Apl帮助文件中展示
6 数组的常见异常
- 数组角标越界的异常：ArrayIndexOutOfBoundsException
int[] arr = new int[]{1,2,3,4,5};
for(int i =0;i <= arr.length;i++){
System.out.println(arr[i]);
}
System.out.println(arr[-2]);
- 空指针异常：NullPointException
情况一:
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());
小tips
我们生活在三维空间；
再加上时间就是四维空间
五维空间：比如一个人的一生有很多可能性，五维空间的人可以预见这些可能性，即预知未来
六维空间：生活在五维空间虽可以预见未来，但无法改变，还是要一步一步地“走”，但六维空间就可以转换时空，省去中间步骤，一步到达终点
七维空间：六维空间虽可以转换时空，却也要遵循自然科学规律（如光速比声速快等），但更高维度空间的人可以无视这些规律，实现超脱
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
