2021_2_24_数组
数组
数组概述
数组的定义
- 数组是相同类型数据的有序集合
- 每一个数据被称作为一个数组元素，每个数组数组元素可以通过一个数组下标来访问它们。
数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组。格式为，
类型名[] 数组名称;
-
java语言使用关键字new来创建新数组，格式如下，
类型名[] 数组名称 = new 类型名[数组长度]
-
数组的元素通过索引访问。索引从数字0开始有序排列。0,1,2,3,4...
-
获取数组长度的方法：.length方法。
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
// 声明一个数组
int[] list1;
// 创建一个新数组
list1 = new int[6]; // list1中可以存放5个int类型的数据
// 给数组元素赋值
list1[0] = 1;
list1[1] = 8;
list1[2] = 9;
list1[3] = 7;
list1[4] = 3;
// 将数组转换为字符串打印出来
System.out.println(Arrays.toString(list1));
// 将数组长度打印出来
System.out.println(list1.length);
}
}
//[1, 8, 9, 7, 3, 0]
//6
-
三种初始化
-
静态初始化
int[] a = {1, 2, 3}; Man[] mans = {new Man(1,1), new Man(2, 2)}; -
动态初始化
int[] a = new int[2]; int[0] = 1; int[1] = 2; -
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量。因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
-
import java.util.Arrays;
public class Demo02 {
public static void main(String[] args) {
// 静态初始化
int[] list1 = {1, 2, 3};
System.out.println(list1[2]);
// 动态初始化
int[] list2 = new int[3];
list2[0] = 0;
list2[1] = 1;
list2[2] = 2;
System.out.println(list2[2]);
// 默认初始化
int[] list3 = new int[2];
System.out.println(Arrays.toString(list3));
}
}
//3
//2
//[0, 0]
数组使用
- 增强型for循环
- 数组当作方法的参数
- 数组当作方法的返回值
比如，
import java.util.Arrays;
public class Demo04 {
public static void main(String[] args) {
int[] list1 = {1,2,3,4};
printList(list1);
printList(reverse(list1));
}
//打印数组
public static void printList(int[] args) {
System.out.println(Arrays.toString(args));
}
//反转数组
public static int[] reverse(int[] args) {
int position = args.length - 1;
int[] reverseList = new int[position + 1];
for (int item : args) {
reverseList[position] = item;
position--;
}
return reverseList;
}
}
//[1, 2, 3, 4]
//[4, 3, 2, 1]
多维数组
-
多维数组何以看成由数组组成的数组。比如二维数组就是由一些一维数组组成的数组。
-
二维数组：
int a[][] = new int[2][5]; // 由两个五个元素的数组组成的数组public class Demo05 { public static void main(String[] args) { int[][] list1 = {{1,2,6},{3,4,7},{8,9,0}}; System.out.println(list1[2][1]); } } // 9
Arrays类
-
数组的工具类: java.util.Arrays
import java.util.Arrays; //工具Arrays的各种用法 public class Demo06 { public static void main(String[] args) { int[] list1 = {911, 103, 5, 4, 76, 459, 1, 2}; int[] list2 = {911, 103, 5, 4, 76, 459, 1, 2}; int[] list3 = new int[4]; //打印数组 System.out.println(Arrays.toString(list1)); //对数组进行排序 : 升序 Arrays.sort(list1); System.out.println(Arrays.toString(list1)); //用二分法在排序好的数组中查找目标值 System.out.println(Arrays.binarySearch(list1, 5)); //判断两个数组中元素值是否完全相等(有序) System.out.println(Arrays.equals(list1,list2)); //数组填充(一般用于初始化)非初始化情况下将覆盖原有数据 Arrays.fill(list1, 10); Arrays.fill(list2, 0, 3, 9); // 下标0~3(不包括3)的元素填充为数字9 Arrays.fill(list3, 8); System.out.println(Arrays.toString(list1)); System.out.println(Arrays.toString(list2)); System.out.println(Arrays.toString(list3)); } } //[911, 103, 5, 4, 76, 459, 1, 2] //[1, 2, 4, 5, 76, 103, 459, 911] //3 //false //[10, 10, 10, 10, 10, 10, 10, 10] //[9, 9, 9, 4, 76, 459, 1, 2] //[8, 8, 8, 8]
冒泡排序
- 冒泡排序是八大排序算法之一。
- 冒泡排序包含：两层循环，外层为冒泡轮数，里层为依次比较。
- 根据嵌套循环，可以得出这个算法的时间复杂度为O(n2)。
冒泡排序的列子，
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[] list1 = {1,7,3,2,7,9};
System.out.println(Arrays.toString(sort(list1)));
}
/*
冒泡排序：(从小到大）
1. 比较数组中两个相邻的元素。如果第一个数比第二个数大，则交换他们的位置。
2. 每一轮的排序都会产生一个最大的元素。
3. 那么下一轮可以少一次比较。
*/
public static int[] sort(int[] targetList) {
int temp = 0;
//外层循环，判断走多少轮
for (int i = 0; i < targetList.length - 1; i++) {
//内层循环，进行判断交换位置
for (int j = 0; j < targetList.length -1 - i; j++) {
if (targetList[j+1] < targetList[j]) {
temp = targetList[j+1];
targetList[j+1] = targetList[j];
targetList[j] = temp;
}
}
}
return targetList;
}
}
//[1, 2, 3, 7, 7, 9]
优化方法如下，
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[] list1 = {1,7,3,2,7,9};
System.out.println(Arrays.toString(sort(list1)));
}
/*
冒泡排序：(从小到大）
1. 比较数组中两个相邻的元素。如果第一个数比第二个数大，则交换他们的位置。
2. 每一轮的排序都会产生一个最大的元素。
3. 那么下一轮可以少一次比较。
*/
public static int[] sort(int[] targetList) {
int temp = 0;
boolean didSorted = false;
//外层循环，判断走多少轮
for (int i = 0; i < targetList.length - 1; i++) {
//内层循环，进行判断交换位置
for (int j = 0; j < targetList.length -1 - i; j++) {
if (targetList[j+1] < targetList[j]) {
temp = targetList[j+1];
targetList[j+1] = targetList[j];
targetList[j] = temp;
didSorted = true; //当触发了交换位置。将判断是否触发的控制器改为true
}
}
//如果没触发交换，则说明数组已经排序。那就直接跳出循环，节省资源。
if (!didSorted) {
break;
}
}
return targetList;
}
}
//[1, 2, 3, 7, 7, 9]
稀疏数组
-
一种数据结构
-
需求：以下是一组数据组成的方阵（二维数组）。其中填充数据为0，有效数据只有两个。
0 0 0 0 0 0 0 0 0 0 0
0 1 0 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 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, 2] //11行11列 两个不同数值1,2
1 [1, 1, 1] //1,1的位置上的值为1
2 [2, 2, 2] //2, 2的位置上的值为2
public class Demo09 {
public static void main(String[] args) {
//创建一个2维数组 11*11 有三种值 0（填充）, 1, 2.
int[][] board1 = new int[11][11];
board1[1][1] = 1;
board1[2][2] = 2;
for (int[] ints : board1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("==========================");
//转换为稀疏数组来保存
//1. 获取有效值的个数
int noOfEffectiveNumbers = 0;
for (int[] ints : board1) {
for (int anInt : ints) {
if (anInt != 0) {
noOfEffectiveNumbers++;
}
}
}
System.out.println("有效数字个数： " + noOfEffectiveNumbers);
//2. 创建一个稀疏数组的数组
int[][] effectiveArray = new int[noOfEffectiveNumbers+1][3];
effectiveArray[0] = new int[]{11, 11, 2};
//3. 遍历二维数组，将非零的值存放入稀疏数组
int position = 1; // 从第二个一维数组开始
int i = 0; //列
int j; //行
for (int[] ints : board1) {
j = 0;
for (int anInt : ints) {
if (anInt != 0) {
effectiveArray[position] = new int[]{j, i, anInt}; // {行数，列数，数值}
position++;
}
j++;
}
i++;
}
//打印稀疏数组
for (int[] ints : effectiveArray) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("==========================");
//逆向转换为原数组
int line = effectiveArray[0][0];
int row = effectiveArray[0][1];
int[][] board2 = new int[line][row];
for (int i1 = 1; i1 < effectiveArray.length; i1++) {
board2[effectiveArray[i1][0]][effectiveArray[i1][1]] = effectiveArray[i1][2];
}
for (int[] ints : board2) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
/*
0 0 0 0 0 0 0 0 0 0 0
0 1 0 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 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
==========================
有效数字个数： 2
11 11 2
1 1 1
2 2 2
==========================
0 0 0 0 0 0 0 0 0 0 0
0 1 0 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 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
*/
浙公网安备 33010602011771号