文章目录
1、数组的概念
数组概念： 数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致。可以是基本数据类型，也可以是引用数据类型
所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。
数组的特点：
- 数组的长度一旦确定就不能修改
- 创建数组时会在内存中开辟一整块连续的空间。
- 存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素。
2、一维数组和二维数组
2.1 一维数组
2.1.1 数组的声明
//元素的数据类型[] 一维数组的名称;
int[] arr;
2.1.2 数组的初始化
静态初始化
int[] arr = {1,2,3,4,5};//第一种方法
int[] arr;
arr = new int[]{1,2,3,4,5};//第二种方法
动态初始化及默认值
int[] arr = new int[5];
int[] arr;
arr = new int[5];
2.1.3 数组的访问和遍历
访问：通过数组名[索引]来访问元素，索引从0开始
遍历：通过数组的长度属性来遍历，数组名.length
2.1.4 数组内存图
一个数组内存图
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@5f150435
}
问：打印arr为什么是[I@5f150435，它是数组的地址吗？
答：它不是数组的地址。
问？不是说arr中存储的是数组对象的首地址吗？
答：arr中存储的是数组的首地址，但是因为数组是引用数据类型，打印arr时，会自动调用arr数组对象的toString()方法，默认该方法实现的是对象类型名@该对象的hashCode()值的十六进制值。
问？对象的hashCode值是否就是对象内存地址？
答：不一定，因为这个和不同品牌的JVM产品的具体实现有关。例如：Oracle的OpenJDK中给出了5种实现，其中有一种是直接返回对象的内存地址，但是OpenJDK默认没有选择这种方式。
问？数组下标为什么是从0开始
答：因为第一个元素距离数组首地址间隔0个单元
二个数组内存图
public static void main(String[] args) {
int[] arr = new int[3];
int[] arr2 = new int[2];
System.out.println(arr);
System.out.println(arr2);
}
两个变量指向同一个数组
public static void main(String[] args) {
// 定义数组，存储3个元素
int[] arr = new int[3];
//数组索引进行赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2，将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]);
}
2.2 二维数组
二维数组也可以看成一个二维表，行*列组成的二维表，只不过这个二维表，每一行的列数还可能不同。但是每一个单元格中的元素的数据类型是一致的，例如：都是int，都是String等。本质上就是元素为一维数组的一个数组。
2.2.1 数组的声明
//推荐
元素的数据类型[][] 二维数组的名称;
//不推荐
元素的数据类型 二维数组名[][];
//不推荐
元素的数据类型[] 二维数组名[];
int[] x, y[];
//x是一维数组，y是二维数组
2.2.2 数组的初始化
静态初始化
int[][] arr;
arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}};//错误，静态初始化右边new 数据类型[]中不能写数字
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};//声明与初始化必须在一句完成
动态初始化
/*
每一行的列数相同
*/
//（1）确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
//此时创建完数组，行数、列数确定，而且元素也都有默认值
//（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;
/*
每一行的列数不同
*/
//（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
//此时只是确定了总行数，每一行里面现在是null
//（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
//此时已经new完的行的元素就有默认值了，没有new的行还是null
//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;
2.2.3 数组的访问和遍历
访问
- 二维数组的长度（行数）：二维数组名.length
- 二维数组的某一行：二维数组名[行下标]，下标范围0-二维数据名.length-1
- 某一行的列数：二维数组名[行下标].length
- 某个元素：二维数组名[行下标] [列下标]
遍历
for(int i=0; i<二维数组名.length; i++){
for(int j=0; j<二维数组名[i].length; j++){
System.out.print(二维数组名[i][j]);
}
System.out.println();
}
2.2.4 二维数组的内存图
int[][] arr = {
{1},
{2,2},
{3,3,3},
{4,4,4,4},
{5,5,5,5,5}
};
//1、声明二维数组，并确定行数和列数
int[][] arr = new int[4][5];
//2、确定元素的值
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
arr[i][j] = i + 1;
}
}
//1、声明一个二维数组，并且确定行数
//因为每一行的列数不同，这里无法直接确定列数
int[][] arr = new int[5][];
//2、确定每一行的列数
for(int i=0; i<arr.length; i++){
/*
arr[0] 的列数是1
arr[1] 的列数是2
arr[2] 的列数是3
arr[3] 的列数是4
arr[4] 的列数是5
*/
arr[i] = new int[i+1];
}
//3、确定元素的值
for(int i=0; i<arr.length; i++){
for(int j=0; j<arr[i].length; j++){
arr[i][j] = i+1;
}
}
2.3 数组操作常见异常
- 数据越界异常：索引超过了数组长度-1
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arr[3]);
}
- 空指针异常：访问的元素还没有分配存储具体的空间，表现为
public static void main(String[] args) {
//定义数组
int[][] arr = new int[3][];
System.out.println(arr[0][0]);//NullPointerException
}
3、数组相关算法
3.1 顺序查找
//查找value第一次在数组中出现的index
public static void main(String[] args){
int[] arr = {4,5,6,1,9};
int value = 1;
int index = -1;
for(int i=0; i<arr.length; i++){
if(arr[i] == value){
index = i;
break;
}
}
if(index==-1){
System.out.println(value + "不存在");
}else{
System.out.println(value + "的下标是" + index);
}
}
3.2 查找最值
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
3.3 冒泡排序
Java中的经典算法之冒泡排序（Bubble Sort）
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放到前面，大数放到后面。
即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。
然后比较第2个和第3个元素，将小数放到前面，大数放到后面。
如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。
重复第一趟步骤，直至全部排序完成。
//例如：冒泡：从小到大，从左到右两两比较
/*
{6,3,8,2,9,1}
第一轮：
第1次：arr[0]与arr[1]比较，6>3成立，就交换，{3,6,8,2,9,1}
第2次：arr[1]与arr[2]比较，6>8不成立，不交换{3,6,8,2,9,1}
第3次：arr[2]与arr[3]比较，8>2成立，就交换，{3,6,2,8,9,1}
第4次：arr[3]与arr[4]比较，8>9不成立，不交换{3,6,2,8,9,1}
第5次：arr[4]与arr[5]比较，9>1成立，就交换，{3,6,2,8,1,9}
第一轮结果：{3,6,2,8,1,9} 9已经到达正确位置，下一轮不用在参与
第二轮：
第1次：arr[0]与arr[1]比较，3>6不成立，不交换{3,6,2,8,1,9}
第2次：arr[1]与arr[2]比较，6>2成立，就交换，{3,2,6,8,1,9}
第3次：arr[2]与arr[3]比较，6>8不成立，不交换{3,2,6,8,1,9}
第4次：arr[3]与arr[4]比较，8>1成立，就交换，{3,2,6,1,8,9}
第二轮结果：{3,2,6,1,8,9} 8已经到达正确位置，下一轮不用在参与
第三轮：
第1次：arr[0]与arr[1]比较，3>2成立，就交换，{2,3,6,1,8,9}
第2次：arr[1]与arr[2]比较，3>6不成立，不交换{2,3,6,1,8,9}
第3次：arr[2]与arr[3]比较，6>1成立，就交换，{2,3,1,6,8,9}
第三轮结果：{2,3,1,6,8,9} 6已经到达正确位置，下一轮不用在参与
第四轮：
第1次：arr[0]与arr[1]比较，2>3不成立，不交换{2,3,1,6,8,9}
第2次：arr[1]与arr[2]比较，3>1成立，就交换，{2,1,3,6,8,9}
第四轮结果：{2,1,3,6,8,9} 3已经到达正确位置，下一轮不用在参与
第五轮
第1次：arr[0]与arr[1]比较，2>1成立，就交换，{1,2,3,6,8,9}
第五轮结果：{1,2,3,6,8,9} 2已经到达正确位置，下一轮不用在参与
剩下1，肯定是最小的了，不用比较了
6个元素，比较了5轮， n个元素需要n-1轮
每一轮比较很多次
*/
public static void main(String[] args){
int[] arr = {6,3,8,2,9,1}; //arr.length = 6
//i=1,2,3,4,5 一共5轮
for(int i=1; i<arr.length; i++){//轮数
/*
i=1，第1轮，j=0,1,2,3,4 arr[j]与arr[j+1]
i=2，第2轮，j=0,1,2,3 arr[j]与arr[j+1]
i=3，第3轮，j=0,1,2 arr[j]与arr[j+1]
i=4，第4轮，j=0,1 arr[j]与arr[j+1]
i=5，第5轮，j=0 arr[j]与arr[j+1]
j=0, j<=arr.length-1-i
*/
for(int j=0; j<=arr.length-1-i; 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] + " ");
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
