JavaSE第5篇：数组
文章目录
- 一、数组简介
- 二、一维数组的使用
- 三、二维数组的使用
- 四、数组的常见算法
- 五 、Arrays工具类
- 六、数组的常见异常
- 总结
一、数组简介
1、多个相同类型的数据按一定的顺序排列的集合就是数组。其实数组就是一个容器
2、数组名、元素、 下标、 数组长度
3、数组是有序排列的
4、数组属于引用数据类型的变量、但是数组中的元素可以是任何数据类型(基本数据类型和引用数据类型)
5、数组的分类：
① 按维度：一维数组、二维数组(多维数组)
②按数组元素的类型：基本类型元素的数组、引用数据类型元素的数组
二、一维数组的使用
1、数组的声明和初始化
int a; //变量的声明
a = 1;//初始化
int b = 1;//声明和初始化
int array[]; //数组声明
array = new int [2]; //初始化(数组是引用数据类型、必须是new关键字)
//①静态初始化：数组的初始化和数组元素的赋值操作同时进行
int n[] = new int[]{1,2,3};
//②动态初始化：数组的初始化和数组的元素分开进行
int n1[] = new int[3];
//动态初始化
int array [] = new int[5];
//静态初始化
int array1[] = new int[]{1,2};
数组一旦初始化其长度是确定的array.length
数组长度一旦确定、长度是不可能修改的
总结：数组一旦初始化完成、其长度是确定的
2、调用数组指定位置的元素
通过索引的方式调用、索引从0开始到数组的长度减1结束
//动态初始化
int array[] = new int[5];
log.info(String.valueOf("长度：" + array.length));
array[0]=1;
//获取字符串元素
String s [] =new String[]{"12"};
String s1 = s[0];
char c = s1.charAt(1);
System.out.println(c);
3、获取数组的长度
String s [] =new String[]{"12"};
int cd =s.length;
4、遍历数组的元素
String s [] =new String[]{"12"};
for (int i = 0; i <s.length ; i++) {
System.out.println(s[i]);
}
5、数组元素默认的初始化值
数组元素是整型 byte int short long 默认初始化值是0
数组元素是浮点型 float double 是0.0
数组元素是char类型 默认是0 这个0是ASCII码 或者是'\u0000' unicode码 而不是'0'
数组元素是boolean型 false
数组元素是引用数据类型时默认是null
6、数组的内存解析
简单的内存结构
一维数组内存解析
三、二维数组的使用
1、二维数组理解
我们可以看成一维数组array1作为另一个一维数组array2的元素存在的是二维数组(数组本身是引用数据类型)
2、二维数组使用
1、二维数组的声明和初始化
二维数组的元素就是一个数组
//类型推断
int a[] = {1, 2};
//静态初始化
int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
//动态初始化
int[][] array2 = new int[1][2];//行和列都行
int[][] array3 = new int[1][];//行可以写 列可以去掉
2、二维数组调用数组指定位置的元素
System.out.println(array[0][1]);
String [][] array4 = new String[3][];
array4[1] = new String[4];
System.out.println(array4[1][0]);
3、二维数组获取数组的长度
int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
System.out.println(array.length);
System.out.println(array[0].length);
4、二维数组遍历
//静态初始化
//1 2 3
//4 5
//6 7 8
int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
for (int[] ints : array) {
for (int anInt : ints) {
System.out.println(anInt);
}
}
5、二维数组元素默认的初始化值
规定：二维数组分为 外层数组元素 内层数组元素
int [][] array =new int[2][3];
//外层元素：array[0] array[1]
//内存元素：array[0][0],array[1][2]
System.out.println( array[0]);//地址值 [I@783e6358
System.out.println( array[0][0]);//0
double [][] array2 =new double[2][];
System.out.println( array2[0]);//null
System.out.println( array2[0][0]);//java.lang.NullPointerException
对于初始化方式一
比如int [][] array = new int[2][3]
外层元素初始化值为地址值
内存元素初始化值与一维数组初始化情况相同(看内存元素数据类型)
对于初始化方式二
int [][] array = new int[2][]
外层元素初始化值为null
内存元素初始化值不能调用 报错空指针
6、二维数组数组的内存解析
数据结构
1、数据与数据之间的逻辑关系: 集合 一对一、 一对多、多对多
2、数据的存储结构：
线性表：顺序表（数组）、链表、栈、队列
树形结构：二叉树
图形结构
算法
排序算法
搜索算法
四、数组的常见算法
1、数值型元素数组的操作-最大值、最小值、平均数、总和
@Test
public void maxArrays() {
int[] array = {10,22,34};
int max =0;
// for (int i = 0; i < array.length; i++) {
// array[i] =(int) ((Math.random() * (99-10+1)) + 10);
// }
for (int i = 0; i < array.length; i++) {
if(max<array[i]){
max=array[i];
}
}
System.out.println(max);
}
@Test
public void minArrays() {
int[] array = {10, 22, 34};
int min = array[0];
// for (int i = 0; i < array.length; i++) {
// array[i] =(int) ((Math.random() * (99-10+1)) + 10);
// }
for (int i = 0; i < array.length; i++) {
if (min > array[i]) {
min = array[i];
}
}
System.out.println(min);
}
@Test
public void sumArrays() {
int[] array = {1, 2, 3};
int sum = 0;
// for (int i = 0; i < array.length; i++) {
// array[i] =(int) ((Math.random() * (99-10+1)) + 10);
// }
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
System.out.println(sum);
}
@Test
public void avgArrays() {
int[] array = {1, 2, 3};
int sum = 0;
// for (int i = 0; i < array.length; i++) {
// array[i] =(int) ((Math.random() * (99-10+1)) + 10);
// }
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
//平均数
int avg = sum/array.length;
System.out.println(avg);
}
2、数组赋值、复制
//数组赋值
@Test
public void arrays1() {
int[] array1, array2;
array1 = new int[]{2, 3, 4};
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i] + "\t");
}
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.println(array1[i]);
}
}
//数组复制
@Test
public void arrays2() {
//数组复制
int[] array1, array2;
array1 = new int[]{2, 3, 4};
array2 = new int[array1.length];
for (int i = 0; i < array2.length; i++) {
array2[i] = array1[i];
}
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
}
思考array1和array2地址值相同、都指向了堆空间的唯一一个数组实体
复制（区别与数组变量的赋值: array1 =array）
@Test
public void copyArrays() {
String[] array1 = {"a", "b"};
//复制操作就是在堆内存中在创建一个数组、数组长度为复制的数组的length
String[] array2 = new String[array1.length];
for (int i = 0; i < array1.length; i++) {
array2[i] = array1[i];
}
}
二维数组赋值使用
@Test
public void arrays2() {
int array[][] = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
int sum =0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
sum +=array[i][j];
}
}
System.out.println(sum);
}
@Test
public void arrays2() {
int[][] yanghui = new int[10][];
for (int x = 0; x < yanghui.length; x++) {
//给数组的元素赋值
yanghui[x] = new int[x + 1];
//给首末元素赋值
yanghui[x][0] = 1;
yanghui[x][x] = 1;
//给每行的非首末元素赋值
if (x >1) {
for (int y = 1; y < yanghui[x].length-1; y++) {
yanghui[x][y] = yanghui[x - 1][y - 1] + yanghui[x - 1][y];
}
}
}
//打印
for (int i = 0; i < yanghui.length; i++) {
for (int i1 = 0; i1 < yanghui[i].length; i1++) {
System.out.print(yanghui[i][i1] + " ");
}
System.out.println();
}
}
@Test
public void arrays3() {
int[] array = new int[6];
for (int i = 0; i < array.length; i++) {
array[i] = (int) ((Math.random() * 30) + 1);
for (int j = 0; j < i; j++) {
if (array[i] == array[j]) {
i--;
break;
}
}
}
//遍历
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
回形算法
3、反转、查找（线性查找、二分法查找）
反转：就是两个变量进行交换
@Test
public void arrays3() {
// int a =1;
// int b =2;
// int tem =a;
// a =b;
// b =tem;
// System.out.println(a);
// System.out.println(b);
String[] array = new String[]{"AA", "BB", "CC", "DD"};
// for (int i = 0; i < array.length / 2; i++) {
// String temp = array[i];
// array[i] = array[array.length - i - 1];
// array[array.length - i - 1] = temp;
// }
for (int i = 0, j = array.length - 1; i < j; i++, j--) {
String temp = array[i];
array[i] = array[j];
array[j] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
线性查找
String[] array = new String[]{"AA", "BB", "CC", "DD"};
String f = "BB";
for (int i = 0; i < array.length; i++) {
if(f.equals(array[i])){
System.out.println(array[i]);
break;
}
}
二分法查找
前期必须有序
@Test
public void arraysFen() {
//二分法查找叫折半查找
int a = -7;
int array[] = {23, 33, 12, 3, -7, 55, 89, 0, 13, 11};
boolean flag = true;
int head = 0;//头部索引
int end = array.length - 1;//尾部索引
int mid = (head + end) / 2;//中间索引
while (head < end) {
if (a == array[mid]) {
System.out.println("找到了指定元素，位置为：" + mid);
flag =false;
break;
} else if (array[mid] > a) {
end = mid - 1;
} else {//array[mid]
head = mid + 1;
}
}
if(flag){
System.out.println("没有找到");
}
}
4、排序
时间复杂度 空间复杂度 稳定性
内部排序在内存中完成
外部排序借助磁盘完成
1、冒泡排序
思想：比较相邻的两个元素、第一个比第二个大、就交换他们两个
@Test
public void maopao() {
int array[] = {44, 33, 12, 3, -7, 55, 89, 0, 13, 11};
//array.length-1 外层长度减一 最后一个元素不需要比较 也可以比较不用减一
for (int i = 0; i < array.length-1; i++) {
//array.length-1-i
// 内层长度：就是数组长度相邻比较后的次数就是长度减一
// 减i:就是每比一次少个元素进行减i
for (int j = 0; j < array.length-1-i; j++) {
if(array[j]>array[j+1]){
int temp =array[j];
array[j] =array[j+1];
array[j+1]=temp;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+"\t");
}
}
2、快速排序
五 、Arrays工具类
六、数组的常见异常
1、数组越界 java.lang.ArrayIndexOutOfBoundsException
2、空指针