数组
一、概述
1. 数组的概念：相同数据类型元素的集合
2. 数组的作用：用来存储基本数据类型和引用数据类型的数据
3. 数组可以看成是多个相同类型数据组合，对这些数据的统一管理。
4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
5. 数组的元素可以是任何数据类型，包括基本类型和引用类型。
6. C和C++中的数组都可以分配在栈上面，而JAVA中的数组是只能分配在堆上面的，因为JAVA中的数组是引用类型。
二、常用操作
查看代码
1 public class TestArray {
2 public static void main(String[] args) {
3 /**
4 * 1. 数组的初始化
5 */
6 // 1.1 数组的静态初始化
7 int[] array1 = { 1, 3, 5, 6, 7, 2, 4, 10 };
8
9 // 1.2 数组的动态初始化
10 int[] array2 = new int[5];
11 array2[0] = 1;
12 array2[1] = 2;
13 array2[2] = 7;
14 array2[3] = 3;
15 array2[4] = 4;
16
17 /**
18 * 2. 数组的遍历
19 */
20 // 2.1 for循环打印数组
21 for (int i = 0; i < array2.length; i++) {
22 System.out.print(array2[i]);
23 }
24
25 // 2.2 foreach打印数组
26 for (int i : array2) {
27 System.out.print(i);
28 }
29
30 /**
31 * 3. 数组排序
32 */
33
34 // 3.1 冒泡排序
35 for (int i = 0; i < array2.length; i++) {
36 for (int j = i + 1; j < array2.length; j++) {
37 // 1. 比较相邻元素，将较大的数冒泡
38 if (array2[i] > array2[j]) {
39 // 2. 交换
40 int temp = array2[i];
41 array2[i] = array2[j];
42 array2[j] = temp;
43 }
44 }
45 }
46 for (int i : array2) {
47 System.out.println(i);
48 }
49
50 // 3.2 选择排序
51 for (int i = 0; i < array2.length; i++) {
52 int min = i;
53 for (int j = i; j < array2.length; j++) {
54 // 1. 找到最小的数
55 if (array2[j] < array2[min]) {
56 // 2. 将最小的数赋值给min
57 min = j;
58 }
59 }
60 // 3. 交换两个数的位置
61 int temp = array2[i];
62 array2[i] = array2[min];
63 array2[min] = temp;
64 }
65 for (int i : array2) {
66 System.out.println(i);
67 }
68
69 // 3.3 反转排序
70 for (int i = 0; i < array2.length / 2; i++) {
71 // 将第i位元素与array2.length-1-i位元素交换
72 int temp = array2[i];
73 array2[i] = array2[array2.length - 1 - i];
74 array2[array2.length - 1 - i] = temp;
75 }
76 for (int i : array2) {
77 System.out.println(i);
78 }
79
80 // 3.4 插入排序
81 for (int i = 0; i < array2.length; i++) {
82 int j = i;
83 int tmp = array2[i];
84 for (; j > 0 && tmp < array2[j - 1]; j--) {
85 // 1. 将大于待排序的数向后移
86 array2[j] = array2[j - 1];
87 }
88 // 2. 交换
89 array2[j] = tmp;
90 }
91 for (int i : array2) {
92 System.out.println(i);
93 }
94 }
95 } 三、Arrays工具类
查看代码
1 package pers.mj;
2
3 import static org.hamcrest.CoreMatchers.instanceOf;
4
5 import java.util.Arrays;
6 import java.util.List;
7
8 import org.junit.Test;
9
10 public class Demo {
11 @Test
12 public void test() {
13
14 int[] array1 = { 1, 3, 5, 2, 4 };
15 int[] array2 = { 3, 2 };
16
17 // 1. 排序
18 Arrays.sort(array2);
19 for (int i : array2) {
20 System.out.print(i);
21 }
22
23 // 2. 二分法查找
24 System.out.print(Arrays.binarySearch(array2, 3));
25
26 // 3. 数组元素比较
27 System.out.println(Arrays.equals(array1, array2));
28
29 // 4. 数组元素填充
30 Arrays.fill(array2, 1);
31 for (int j : array2) {
32 System.out.println(j);
33 }
34
35 /**
36 * aslist详解
37 * 1. 该方法适用于对象型数据的数组（String、Integer...）
38 * 2. 该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
39 * 3. 该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
40 * 4. 不支持add()、remove()、clear()等方法
41 */
42
43 // 1、对象类型(String型)的数组数组使用asList()，正常
44 String[] strings = { "aa", "bb", "cc" };
45 List stringList = Arrays.asList(strings);
46 System.out.print("1、String类型数组使用asList()，正常： ");
47 for (String str : stringList) {
48 System.out.print(str + " ");
49 }
50 System.out.println();
51
52 // 2、对象类型(Integer)的数组使用asList()，正常
53 Integer[] integers = new Integer[] { 1, 2, 3 };
54 List integerList = Arrays.asList(integers);
55 System.out.print("2、对象类型的数组使用asList()，正常： ");
56 for (int i : integerList) {
57 System.out.print(i + " ");
58 }
59 System.out.println();
60
61 // 3、基本数据类型的数组使用asList()，出错
62 int[] ints = new int[] { 1, 2, 3 };
63 List intList = Arrays.asList(ints);
64 System.out.print("3、基本数据类型的数组使用asList()，出错(输出的是一个引用，把ints当成一个元素了)：");
65 for (Object o : intList) {
66 System.out.print(o.toString());
67 }
68 System.out.println();
69
70 System.out.print(" " + "这样遍历才能正确输出：");
71 int[] ints1 = (int[]) intList.get(0);
72 for (int i : ints1) {
73 System.out.print(i + " ");
74 }
75 System.out.println();
76
77 // 4、当更新数组或者List,另一个将自动获得更新
78 System.out.print("4、当更新数组或者List,另一个将自动获得更新： ");
79 integerList.set(0, 5);
80 for (Object o : integerList) {
81 System.out.print(o + " ");
82 }
83 for (Object o : integers) {
84 System.out.print(o + " ");
85 }
86 System.out.println();
87
88 }
89 }
四、数组的分类
一维数组
一维数组的声明方式有2种：
- 格式一：数组元素类型 数组名[ ]; 即type var[ ];
- 格式二：数组元素类型[ ] 数组名; 即type[ ] var;
- 格式二声明数组的方法与C#上声明一维数组的方法一样。
例如：int a1[ ]; int[ ] a2;
double b[ ];
person[ ] p1; String s1[ ];
注意：JAVA语言中声明数组时不能指定其长度(数组中的元素个数)
如：int a[5]; 这样声明一维数组是非法的。
数组的模型
- 一维数组：一维数组就是一行，一行小格。
- 二维数组：二维数组就是一行加一列组成的一个平面分成的小格，有行有列。
- 三维数组：三维数组就是一个立方体。
- 人类对最多认识到三维空间。
数组对象的创建
JAVA中使用关键字new创建数组对象。
格式为：数组名 = new 数组元素的类型[数组元素的个数]
例如：
元素为引用数据类型的数组
注意：元素为引用数据类型的数组中的每一个元素都需要实例化。
例如：
class Date{
int year; int moth; int day;
Date(int y; int m, int d){
year=y ;
month=m ;
day=d ;
}
}
数组的初始化
- 1.动态初始化
数组定义与为数组元素分配空间和赋值的操作分开进行。
例如：
查看代码
public class Test{
public static void main(String args[ ]){
int a[ ]; //定义数组，即声明一个int类型的数组a[ ]
a=new int[3]; //给数组元素分配内存空间。
a[0]=3; a[1]=9; a[2]=8; //给数组元素赋值。
Date days[ ];
days=new Date[3];
days[0]=new Date(1, 4, 2004);
days[1]=new Date(2, 4, 2004);
days[2]=new Date(3, 4, 2004);
}
}
class Date{
int year, month, day;
Date(int y, int m, int d){
year = y ;
month = m ;
day = d ;
}
}- 2.静态初始化
在定义数组的同时就为数组元素分配空间并赋值。
例如：
查看代码
puclic class Test{
public static void main(String args[ ]){
int a[ ] = { 3, 9, 8}; //在定义数组的同时给数组分配空间并赋值。
Date days[ ] = {
new Date(1, 4, 2004),
new Date(2 ,4 ,2004),
new Date(3 ,4, 2004)
};
}
}
class Date{
int year, month, day;
Date(int y, int m, int d){
year = y ;
month = m ;
day = d ;
}
} 数组元素的默认初始化.
-
数组是引用类型，它的元素相当于类的成员变量，因此给数组分配内存空间后，每个元素也被按照成员变量的规则被隐式初始化。
查看代码
public class Test{ public static void main(String args[ ]){ int a[ ] = new int[5]; Date[ ] days=new Date[3]; System.out.println(a[3]); System.out.println(days[2]); } } class Date{ int year, month, day; Date(int y, int m, int d){ year = y ; month = m ; day = d ; } } /**输出结果 System.out.println(a[3]); 打印出来的结果是：0。 System.out.println(days[2]); 打印出来的结果是：null(空) */
数组元素的引用
定义并用运算符new为之分配内存空间后，才可以引用数组中的每个元素，数组元素的引用方式为：arrayName[index]， index为数组元素下标，可以是整型常量或整型表达式。如：a[3], b[i], c[6*i]。
数组元素下标从0开始；长度为n的数组的合法下标取值范围为0 ～ n—1。
每个数组都有一个属性length指明它的长度，例如：a.length的值为数组a的长度(元素个数)。
二维数组
格式1
/*
二维数组：就是元素为一维数组的一个数组。
格式1：
数据类型[][] 数组名 = new 数据类型[m][n];
m:表示这个二维数组有多少个一维数组。
n:表示每一个一维数组的元素有多少个。
注意：
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
B:注意下面定义的区别
int x;
int y;
int x,y;
int[] x;
int[] y[];
int[] x,y[];//这个x是一维数组，y是二维数组
*/
class Array2Demo {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][2];
//定义了一个二维数组arr
//这个二维数组有3个一维数组的元素
//每一个一维数组有2个元素
//输出二维数组名称
System.out.println(arr); //地址值 [[I@175078b
//输出二维数组的第一个元素一维数组的名称
System.out.println(arr[0]); //地址值 [I@42552c
System.out.println(arr[1]); //地址值 [I@e5bbd6
System.out.println(arr[2]); //地址值 [I@8ee016
//输出二维数组的元素
System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
}
}
格式1：内存图解
格式2
/*
格式2：
数据类型[][] 数组名 = new 数据类型[m][];
m:表示这个二维数组有多少个一维数组。
列数没有给出，可以动态的给。这一次是一个变化的列数。
*/
class Array2Demo2 {
public static void main(String[] args) {
//定义数组
int[][] arr = new int[3][];
System.out.println(arr); //[[I@175078b
System.out.println(arr[0]); //null
System.out.println(arr[1]); //null
System.out.println(arr[2]); //null
//动态的为每一个一维数组分配空间
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];
System.out.println(arr[0]); //[I@42552c
System.out.println(arr[1]); //[I@e5bbd6
System.out.println(arr[2]); //[I@8ee016
System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
//ArrayIndexOutOfBoundsException
//System.out.println(arr[0][2]); //错误
arr[1][0] = 100;
arr[1][2] = 200;
}
}
格式2: 内存图解
格式3
/*
格式3：
基本格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
简化版格式：
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
举例：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};
*/
class Array2Demo3 {
public static void main(String[] args) {
//定义数组
int[][] arr = {{1,2,3},{4,5},{6}};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]); //1
System.out.println(arr[1][0]); //4
System.out.println(arr[2][0]); //6
System.out.println(arr[0][1]); //2
System.out.println(arr[1][1]); //5
//越界
System.out.println(arr[2][1]); //错误
}
}
格式3: 内存图解
遍历二维数组
/*
需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。
*/
class Array2Test {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
//用方法改进
//调用方法
printArray2(arr);
}
/*
需求：遍历二维数组
两个明确：
返回值类型：void
参数列表：int[][] arr
*/
public static void printArray2(int[][] arr) {
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}
二维数组求和
/*
公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
分析：
A:把题目的数据用二维数组来表示
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
B:如何求和呢?
求和其实就是获取到每一个元素，然后累加即可。
C:定义一个求和变量sum，初始化值是0。
D:通过遍历就可以得到每一个二维数组的元素。
E:把元素累加即可。
F:最后输出sum，就是结果。
*/
class Array2Test2 {
public static void main(String[] args) {
//把题目的数据用二维数组来表示
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
//定义一个求和变量sum，初始化值是0。
int sum = 0;
//通过遍历就可以得到每一个二维数组的元素。
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
//把元素累加即可。
sum += arr[x][y];
}
}
//最后输出sum，就是结果。
System.out.println("一年的销售额为："+sum+"万元");
}
}
二维数组输出杨辉三角：打印杨辉三角形(行数可以键盘录入)
/*
需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
分析：看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
*/
import java.util.Scanner;
class Array2Test3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//这个n的数据来自于键盘录入。
System.out.println("请输入一个数据：");
int n = sc.nextInt();
//定义二维数组
int[][] arr = new int[n][n];
//给这个二维数组任何一行的第一列和最后一列赋值为1
for(int x=0; x<arr.length; x++) {
arr[x][0] = 1; //任何一行第1列
arr[x][x] = 1; //任何一行的最后1列
}
//按照规律给其他元素赋值
//从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
for(int x=2; x<arr.length; x++) {
//这里如果y<=x是有个小问题的，就是最后一列的问题
//所以这里要减去1
//并且y也应该从1开始，因为第一列也是有值了
for(int y=1; y<=x-1; y++) {
//每一个数据是它上一行的前一列和它上一行的本列之和。
arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
}
}
//这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
for(int x=0; x<arr.length; x++) {
for(int y=0; y<=x; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}