Java数组
数组的定义
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据,按照一定的先后顺序排列组合而成
- 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们
数组声明创建
-
首先必须声明数组变量,才能再程序中使用数组.下面是声明数组变量的语法:
dataType[] arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同,但不是首选方法 -
Java语言使用new操作符来创建数组,语法如下:
dataType[] arrayRefVar = new dataType[arraySize]; -
数组的元素是通过索引访问的,数组索引从0开始
-
获取数组长度
arrays.length
【演示】
public class Demo01 {
public static void main(String[] args) {
int sum = 0;
/* 声明数组 */
int[] array1;// 首选方法
int array2[];
/* 创建数组 */
array1 = new int[5];
/* 赋值数组 */
array1[0] = 1;
array1[1] = 2;
array1[2] = 3;
array1[3] = 4;
array1[4] = 5;
/* 计算数组中所有元素的和 */
for (int i = 0; i < array1.length; i++) {
sum += array1[i];
}
System.out.println("sum="+sum);
}
}
输出结果：
sum=15
内存分析
-
栈空间（stack）：连续的存储空间，遵循后进先出的原则，用于存放局部变量。
-
堆空间（heap）：不连续的空间，用于存放new出的对象，或者说是类的实例。
-
方法区（method）：方法区在堆空间内，用于存放①类的代码信息；②静态变量和方法；③常量池（字符串常量等，具有共享机制）。
三种初始化
静态初始化
public class Demo02 {
public static void main(String[] args) {
/* 静态初始化：创建+赋值 */
int[] a = {1,2,3,4,5};
System.out.println("a[0]="+a[0]);
System.out.println("a[1]="+a[1]);
System.out.println("a[2]="+a[2]);
System.out.println("a[3]="+a[3]);
System.out.println("a[4]="+a[4]);
}
}
输出结果：
a[0]=1
a[1]=2
a[2]=3
a[3]=4
a[4]=5
动态初始化
public class Demo02 {
public static void main(String[] args) {
/* 动态初始化 */
int[] b;
b = new int[5];
// 可等效为 int[] b = new int[5];
b[0] = 1;
b[2] = 2;
b[4] = 4;
System.out.println("b[0]="+b[0]);
System.out.println("b[1]="+b[1]);// 没有赋值就会初始化为默认值
System.out.println("b[2]="+b[2]);
System.out.println("b[3]="+b[3]);// 没有赋值就会初始化为默认值
System.out.println("b[4]="+b[4]);
}
}
输出结果：
b[0]=1
b[1]=0
b[2]=2
b[3]=0
b[4]=4
数组默认初始化
- 数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
Java中除了基本数据类型，其他的均是引用类型，包括类、数组等等。
数据类型的默认值
数值型：0
浮点型：0.0
布尔型：false
字符型：\u0000
引用类型：null
变量初始化
成员变量可不初始化，系统会自动初始化；
局部变量必须由程序员显式初始化，系统不会自动初始化
数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可改变的
- 其元素必须是相同类型，不允许出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中,因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中
数组边界问题
下标的合法区间:[0,length-1]，如果越界就会报错
public static void main(String[] args){
int[] a = new int[2];
System.out.println(a[2]);
}
java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常
小结:
- 数组是相同的数据类型(数据类型可以为任意类型)的有序集合
- 数据也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果越界，则报ArrayIndexOutOfBoundsException
数组的使用
普通for循环
【演示】
public class Demo03 {
public static void main(String[] args) {
int[] a = {1,4,7,2,5,8};
/* 打印数组内所有元素 */
for (int i = 0; i < a.length; i++) {
System.out.println("a["+i+"]="+a[i]);
}
}
}
输出结果：
a[0]=1
a[1]=4
a[2]=7
a[3]=2
a[4]=5
a[5]=8
For-Each
【演示】
public class Demo03 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
// JDK1.5没有下标
for (int j:array){
System.out.println(j);
}
}
}
输出结果：
1
2
3
4
5
数组作方法入参
【演示】
public class Demo04 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
printArray(a);
}
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.println("array["+i+"]="+array[i]);
}
}
}
输出结果：
array[0]=1
array[1]=2
array[2]=3
array[3]=4
array[4]=5
数组作返回值
【演示】
public class Demo05 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
for (int i = 0; i < a.length; i++) {
System.out.println("a["+i+"]="+a[i]);
}
int[] b = reverseArray(a);
for (int j = 0; j < a.length; j++) {
System.out.println("b["+j+"]="+b[j]);
}
}
/* 数组反转 */
public static int[] reverseArray(int[] array){
int[] result = new int[array.length];
for (int i = 0, j = result.length - 1; i < array.length; i++, j--) {
result[j] = array[i];
}
return result;
}
}
输出结果：
a[0]=1
a[1]=2
a[2]=3
a[3]=4
a[4]=5
b[0]=5
b[1]=4
b[2]=3
b[3]=2
b[4]=1
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的数组，其每一个元素都是一个一维数组
二维数组
int[][] a = new int[2][5];
解析:以上二维数组a可以看成一个两行五列的数组
【演示】
public class Demo06 {
public static void main(String[] args) {
int[][] a = {{1,2,3,4},{4,5,6,7},{8,9,10,11}};
/*
a[0] = {1,2,3,4}
a[1] = {4,5,6,7}
a[2] = {8,9,10,11}
*/
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++){
System.out.print("a["+i+"]["+j+"]="+a[i][j]+"\t");
}
System.out.println();
}
}
}
输出结果：
a[0][0]=1 a[0][1]=2 a[0][2]=3 a[0][3]=4
a[1][0]=4 a[1][1]=5 a[1][2]=6 a[1][3]=7
a[2][0]=8 a[2][1]=9 a[2][2]=10 a[2][3]=11
Arrays类
数组的工具类java.util.Arrays,Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（是不用而不是不能）
具有以下常用功能:
- 给数组赋值:通过fill方法
- 对数组排序:通过sort方法，按升序
- 比较数组:通过equals方法比较数组中元素值是否相等
- 查找数组元素:通过binarySearch方法能对排好序的数组进行二分查找法操作
【演示】
package com.array;
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
System.out.println(Arrays.toString(a));
Arrays.fill(a, 1, 3,8);// 将8分配给数组a的指定范围a[1]~a[3]之间的每个元素
System.out.println(Arrays.toString(a));
Arrays.fill(a, 8);// 将8分配给数组a的每个元素
System.out.println(Arrays.toString(a));
}
}
输出结果：
[1, 2, 3, 4, 5]
[1, 8, 8, 4, 5]
[8, 8, 8, 8, 8]
package com.array;
import java.util.Arrays;
public class Demo08 {
public static void main(String[] args) {
int[] a = {1,4,3,2,5};
System.out.println(Arrays.toString(a));// 返回数组a内容的字符串表示形式
Arrays.sort(a,1,3);// 按升序排列数组的指定范围a[1]~a[3]之间的数
System.out.println(Arrays.toString(a));
Arrays.sort(a);// 按照数字顺序排列数组a
System.out.println(Arrays.toString(a));
}
}
输出结果：
[1, 4, 3, 2, 5]
[1, 3, 4, 2, 5]
[1, 2, 3, 4, 5]
package com.array;
import java.util.Arrays;
public class Demo09 {
public static void main(String[] args) {
int[] a = {1,2,3,4};
int[] b = {0,2,5,8};
int[] c = {0,2,5,8};
boolean flag1 = Arrays.equals(a, b);// 如果两个指定的int数组彼此不相等 则返回false
boolean flag2 = Arrays.equals(b, c);// 如果两个指定的int数组彼此相等 则返回true
System.out.println("flag1="+flag1);
System.out.println("flag2="+flag2);
}
}
输出结果：
flag1=false
flag2=true
package com.array;
import java.util.Arrays;
public class Demo10 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8};
int x = Arrays.binarySearch(a, 5);// 使用二叉搜索算法搜索数组a的指定值5
int y =Arrays.binarySearch(a,1,4,2);// 使用二叉搜索算法搜索指定值2的数组a的范围a[1]~a[4]
System.out.println(x);
System.out.println(y);
}
}
输出结果：
4
1
冒泡排序
1.原理：比较两个相邻的元素，将值大的元素交换到右边
2.思路：依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。
(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
(2)比较第2和第3个数，将小数 放在前面，大数放在后面。
......
(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至 全部排序完成
(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时 候，最后一个数是不参加比较的。
(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较 中，最后两个数是不参与比较的。
(6)依次类推，每一趟比较次数减少依次
【演示】
public class Demo11 {
public static void main(String[] args) {
int[] a = {1,4,7,8,5,2,3,9,6};
int[] b = sort(a);
System.out.println(Arrays.toString(b));
}
public static int[] sort(int[] array){
int temp = 0;
/* 外层循环，判断需要走多少趟 */
for (int i = 0; i < array.length - 1; i++) {
/* 内层循环，比较相邻两个数，如果前一个比后一个大就交换位置 */
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]){
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}
}
输出结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
稀疏数组
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
稀疏数组的处理方式：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
【演示】
public class Demo12 {
public static void main(String[] args) {
int[][] a = new int[11][11];// 定义一个二维数组
a[3][4] = 1;
a[4][4] = 2;
a[4][5] = 1;
a[5][5] = 2;
printArray(a);
int[][] sparseArray = sparseArray(a);// 调用函数将原始数组转换为稀疏数组
printArray(sparseArray);
int[][] restoreArray = restoreArray(sparseArray);// 调用函数将稀疏数组转换为原始数组
printArray(restoreArray);
}
/* 打印数组 */
public static void printArray(int[][] array) {
for (int[] a : array) {
for (int b : a) {
System.out.print(b+"\t");
}
System.out.println();
}
}
/* 将原始数组转换为稀疏数组 */
public static int[][] sparseArray(int[][] array) {
int count = 0;// 定义一个变量用于标记稀疏数组的行数
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0) {
count ++;// 统计数组中元素非0的的个数
}
}
}
int[][] newArray = new int[count + 1][3];// 定义一个稀疏数组
/* 赋值稀疏数组第一行 */
newArray[0][0] = 11;
newArray[0][1] = 11;
newArray[0][2] = count;
count = 0;
/* 遍历原始数组，赋值稀疏数组剩余行 */
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0) {
count ++;
newArray[count][0] = i;// 第0列为行值
newArray[count][1] = j;// 第1列为列值
newArray[count][2] = array[i][j];// 第2列为数值
}
}
}
return newArray;
}
/* 将稀疏数组转换为原始数组 */
public static int[][] restoreArray(int[][] array) {
int[][] initialArray = new int[array[0][0]][array[0][1]];// 定义一个数组
for (int i = 1; i < array.length; i++) {
initialArray[array[i][0]][array[i][1]] = array[i][2];// 将稀疏数组自第一行之后的值赋值数组
}
return initialArray;
}
}
输出结果：
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 2 1 0 0 0 0 0
0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
11 11 4
3 4 1
4 4 2
4 5 1
5 5 2
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 2 1 0 0 0 0 0
0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
