数组
?
1.数组概述
数组是一个类型的所有数据的一个集合，并用一个数组下标来区分或指定每一个数。数组的下标是从0开始的。
数组的定义：
-
数组是相同类型数据的有序集合.
-
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
-
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.
数组的四个基本特点：
-
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
-
其元素必须是相同类型,不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
-
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组 本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象 本身是在堆中的。
2.数组声明创建
1.首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
int[] nums ; ? //声明一个数组 ? ? ? 使用int[]创建了一个数组 ? 在栈中 nums = new int[10]; ? //创建一个数组 把创建的数组是引用赋值给变量nums 在堆中
2.声明并创建一个数组：
int[] nums = new int[10]; ? ?//数组的长度确定
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrays.length-1。
3.获取数组长度：
arrays.length
4.内存分析
?
5.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有 关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
6.声明一个数组的时候并没有数组被真正的创建。
7.构造一个数组，必须指定长度
8.数组下标越界：
ArrayIndexOutOfBoundsException : 数组下标越界异常！
9.数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实 例变量同样的方式被隐式初始化
数组的两种定义并赋值方式
1.动态初始化 声明创建一个数组并为其赋值。注意事项：new后面的中括号中不允许写任何内容，写了就编译失败。
数据类型[] 变量名 = new 数据类型[]{元素1，元素2，元素3};
int[] array = new int[]{45,65,78,78,1,5,9};
2.数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实 例变量同样的方式被隐式初始化。
数据类型[] 变量名 = new 数据类型[10]；
变量名[0] = 数值1；
变量名[1] = 数值2；
int[] a = new int[10]; a[0]=1; a[1]=2;
3.静态初始化 除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值
数据类型[] 变量名 = {元素1，元素2，元素3}；、
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};?
3.数组的使用
1.1 For-Each循环
?int[] arrays ={45,16,15,18,56,25,48,96,38}; //没有下标
? ? ? ?//1.For-Each循环
? ? ? ?for (int array:arrays) {
? ? ? ? ? ?System.out.println(array);
? ? ? }
1.2For-Each双循环
int[][] array1 = new int[11][11];
? ? ? ? ? ?array1[1][2] = 1;
? ? ? ? ? ?array1[2][3] = 2;
? ? ? ? ? ?for (int[] ints : array1) { ? ? ? ? ? ? ? //array1.for
? ? ? ? ? ? ? ?for (int anInt : ints) { ? ? ? ? ? ? ?//ints.for
? ? ? ? ? ? ? ? ? ?System.out.print(anInt + "\t"); ? //anInt
? ? ? ? ? ? ? }
? ? ? ? ? ? ? ?System.out.println();
? ? ? ? ? }
1.3 打印数组元素 Arrays.toString(arrays); 可直接调用函数。
2.数组作方法入参
public static void main(String[] args) {
? ? ? ?int[] arrays ={45,16,15,18,56,25,48,96,38};
? ? ? ?printArray(arrays);
? }
? ?// 2.数组作方法入参 --- 打印数组元素
? ?public static void printArray(int[] array){
? ? ? ?for (int i = 0; i <array.length; i++) {
? ? ? ? ? ?System.out.print(array[i] + "\t");
? ? ? }
? }
3.数组作返回值 rever 数组作为函数的返回值。
public static void main(String[] args) {
? ? ? ?int[] arrays ={45,16,15,18,56,25,48,96,38};
? ? ? ?printArray(revers(arrays));// 3.数组作返回值
? }
? ?public static void printArray(int[] array) { // 2.数组作方法入参 --- 打印数组元素
? ? ? ?for (int i = 0; i < array.length; i++) {
? ? ? ? ? ?System.out.print(array[i] + "\t");
? ? ? }
? }
? ? ? ?public static int[] revers(int[] array){ // 3.数组作返回值 --- 反转输出数组
? ? ? ? ? ?int[] rever = new int[array.length];
? ? ? ? ? ?for (int i = 0,j=array.length-1; i <array.length ; i++,j--) {
? ? ? ? ? ? ?rever[j] = array[i];
? ? ? ? ? }
? ? ? ? ? ?return rever;
? ? ? }?
4.普通for循环
public static void main(String[] args) {
? ? ? ?//1.打印全部的数组元素
? ? ? ?int[] arrays = {12,13,45,65,42,32,89,47};
? ? ? ?for (int i = 0; i <arrays.length ; i++) {
? ? ? ? ? ?System.out.print(arrays[i] ?+ "\t");
? ? ? }
? ? ? ?System.out.println();
? ? ? ?System.out.println("=====================");
? ? ? ?//2.计算所有元素的和
? ? ? ?double sum = 0;
? ? ? ?for (int i = 0; i <arrays.length ; i++) {
? ? ? ? ? ?sum += arrays[i];
? ? ? }
? ? ? ?System.out.println("数组的和为："+sum);
? ? ? ?//3.查找最大元素
? ? ? ?int max ?= arrays[0];
? ? ? ?for (int i = 1; i <arrays.length ; i++) {
? ? ? ? ? ?if(arrays[i]>max){
? ? ? ? ? ? ? ?max = arrays[i];
? ? ? ? ? }
? ? ? }
? ? ? ?System.out.println("数组的最大值："+ max);
? }
4.多维数组
多维数组可以看成是数组的数组
比如: 二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
多维数组的动态初始化（以二维数组为例）
type[][] typeName = new type[typeLength1][typeLengt2h]
type 可以为基本数据类型和复合数据类型，typeLenght1 和 typeLenghtt2 必须为正整数，typeLenght1 为行数，typeLenght2 为列数。
比如定义一个三行五列的二维数组：
int a[][] = new int[3][5]
获取数组长度：
a.length获取的二维数组第一维数组的长度，a[0].length才是获取第二维第一个数组长度。
? //二维数组为例
? ?int a[][] = new int[3][5];
? ? ? ?System.out.println(" 数组的行数为： "+ a.length);
? ? ? ?System.out.println( " 数组的列数为： "+ a[0].length);
?
//结果：
数组的行数为： 3
数组的列数为： 5
5.Arrays类
数组的工具类java.util.Arrays，java.util.Arrays 类能方便地操作数组. 使用之前需要导包！
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对
象来调用(注意:是"不用" 而不是 "不能")。
方法举例：
-
打印数组： 通过 toString 方法。
int a[] = {45,56,98,485,658,120,13,36};
System.out.println(a); ? ?//[I@1b6d3586 对象
System.out.println(Arrays.toString(a));//[45, 56, 98, 485, 658, 120, 13, 36]
-
给数组赋值：通过 fill 方法。
int a[] = {45,56,98,485,658,120,13,36}; Arrays.fill(a,2,3,3); //将2到3索引的元素替换为3 System.out.println(Arrays.toString(a));//[45, 56, 3, 485, 658, 120, 13, 36] -
对数组排序：通过 sort 方法,按升序。
int a[] = {45,56,98,485,658,120,13,36}; Arrays.sort(a); System.out.println(Arrays.toString(a));//[3, 13, 36, 45, 56, 120, 485, 658] -
比较数组：通过 equals 方法比较数组中元素值是否相等。
int a[] = {45,56,98,485,658,120,13,36}; int b[] = {0, 0, 13, 36, 45, 56, 120, 658}; Boolean zhi = Arrays.equals(a,b); System.out.println(zhi); //false -
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
int a[] = {45,56,98,485,658,120,13,36};
int ?re = Arrays.binarySearch(a,45);
System.out.println(re);//3
6.冒泡排序
冒泡排序算法的原理如下：
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会
是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public static void main(String[] args) { ? ? ? ?int[] array = {12, 51, 61, 6, 14, 19, 89, 15, 33, 1, 42, 0}; ? ? ? ?int[] sort = sort(array); ? ? ? ?for (int num : sort) { ? ? ? ? ? ?System.out.print(num + "\t"); ? ? ? ? } ? ? ? } ? ?public static int[] sort(int[] array) { ? ? ? ?int temp = 0; // 外层循环，它决定一共走几趟 ,-1为了防止溢出 ? ? ?for (int i = 0; i < array.length - 1; i++) { ? ? ? ? ?int flag = 0; //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环 ? ? ? ? ?// 内层循环，它决定每趟走一次 ? ? ? ? ?for (int j = 0; j < array.length - i - 1; j++) { ? ? ? ? ? ? ?//如果后一个大于前一个,则换位 ? ? ? ? ? ? ?if (array[j + 1] > array[j]) { ? ? ? ? ? ? ? ? ?temp = array[j]; ? ? ? ? ? ? ? ? ?array[j] = array[j + 1]; ? ? ? ? ? ? ? ? ?array[j + 1] = temp; ? ? ? ? ? ? ? ? ?flag = 1; ? ? ? ? ? ? } ? ? ? ? } ? ? ? ? ?if (flag == 0) { ? ? ? ? ? ? ?break; ? ? ? ? } ? ? } ? ? ? ?return array; ? } //89 61 51 42 33 19 15 14 12 6 1 0
7.选择排序
选择排序的工作原理：
1.每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置。
2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列的末尾。
3.以此类推，直到全部待排序的数据元素排完。
public static void main(String[] args) {
? ? ? ?int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
? ? ? ?int[] sort = sort(array);
? ? ? ?for (int num : sort) {
? ? ? ? ? ?System.out.print(num + "\t");
? ? ? ? ? }
? ? ? ? }
? ?public static int[] sort(int arr[]) {
? ? ? ?int temp = 0;
? ? ? ?for (int i = 0; i < arr.length - 1; i++) {
? ? ? ? ? ?// 认为目前的数就是最小的, 记 录最小数的下标
? ? ? ? ? ?int minIndex = i;
? ? ? ? ? ?for (int j = i + 1; j < arr.length; j++) {
? ? ? ? ? ? ? ?if (arr[minIndex] > arr[j]) {
? ? ? ? ? ? ? ? ? ?// 修改最小值的下标
? ? ? ? ? ? ? ? ? ?minIndex = j;
? ? ? ? ? ? ? }
? ? ? ? ? }
? ? ? ? ? ?// 当退出for就找到这次的最小值,就需要交换位置了
? ? ? ? ? ?if (i != minIndex) {
? ? ? ? ? ? ? ?//交换当前值和找到的最小值的位置
? ? ? ? ? ? ? ?temp = arr[i];
? ? ? ? ? ? ? ?arr[i] = arr[minIndex];
? ? ? ? ? ? ? ?arr[minIndex] = temp;
? ? ? ? ? }
? ? ? }
? ? ? ?return arr;
? ? ? ? ? ? }//0 1 1 2 2 3 4 5 5 6 8 9
8.稀疏矩阵?
稀疏数组记录有效的坐标，记录原始坐标的大小以及它的有效值。
?
?
题目要求：把稀疏矩阵用三元组法保存，然后再还原数组：
public class ArrayDemo09 {
? ? ? ?//打印二维数组 --- 稀疏矩阵 五子棋 ? 0：没有棋子 ? 1：黑棋 ? ? 2：白棋
? ? ? ?public static void main(String[] args) {
? ? ? ? ? ?int[][] array1 = new int[11][11];
? ? ? ? ? ?array1[1][2] = 1;
? ? ? ? ? ?array1[2][3] = 2;
? ? ? ? ? ?System.out.println("输出原始数组");
? ? ? ? ? ?for (int[] ints : array1) {
? ? ? ? ? ? ? ?for (int anInt : ints) {
? ? ? ? ? ? ? ? ? ?System.out.print(anInt + "\t");
? ? ? ? ? ? ? }
? ? ? ? ? ? ? ?System.out.println();
? ? ? ? ? }
? ? ? ? ? ?System.out.println("================================================================");
? ? ? ?//转换为稀疏数组保存
? ? ? ? ? ?int sum = 0; ?//记录有效值的个数
? ? ? ? ? ?for (int i = 0; i <11 ; i++) {
? ? ? ? ? ? ? ?for (int j = 0; j <11 ; j++) {
? ? ? ? ? ? ? ? ? ?if(array1[i][j] !=0){
? ? ? ? ? ? ? ? ? ? ? ?sum++;
? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? }
? ? ? ? ? }
? ? ? ? ? ?System.out.println("有效值的个数是：" +sum);
? ? ? ? //创建一个稀疏数组的数组
? ? ? ? int[][] array2 = new int[sum+1][3];
? ? ? ? ? ?array2[0][0]=11;
? ? ? ? ? ?array2[0][1]=11;
? ? ? ? ? ?array2[0][2]=sum;
? ? ? ? //遍历二维数组，将非零值存放到稀疏数组里
? ? ? ? ? ?int count = 0;
? ? ? ? ? ?for (int i = 0; i <array1.length ; i++) {
? ? ? ? ? ? ? ?for (int j = 0; j <array1[i].length ; j++) {
? ? ? ? ? ? ? ? ? ?if(array1[i][j] != 0){
? ? ? ? ? ? ? ? ? ? ? ?count++;
? ? ? ? ? ? ? ? ? ? ? ?array2[count][0] = i;
? ? ? ? ? ? ? ? ? ? ? ?array2[count][1] = j;
? ? ? ? ? ? ? ? ? ? ? ?array2[count][2] = array1[i][j];
? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? }
? ? ? ? ? }
? ? ? ? ? ?System.out.println("输出稀疏矩阵");
? ? ? ? ? ?for (int i = 0; i <array2.length ; i++) {
? ? ? ? ? ? ? System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
? ? ? ? ? }
? ? ? ? ? ?System.out.println("======================================================");
? ? ? ?//数组还原
? ? ? ? ? ?System.out.println("还原数组");
? ? ? ? ? ?int[][] array3 = new int[array2[0][0]][array2[0][1]];//读取稀疏矩阵
? ? ? ? ? ?for (int i = 1; i <array2.length ; i++) {
? ? ? ? ? ? ? ?array3[array2[i][0]][array2[i][1]] = array2[i][2];//给数组3还原它的值
? ? ? ? ? }
? ? ? ? ? ?System.out.println("输出还原的数组");
? ? ? ? ? ?for (int[] ints : array3) {
? ? ? ? ? ? ? ?for (int anInt : ints) {
? ? ? ? ? ? ? ? ? ?System.out.print(anInt+"\t");
? ? ? ? ? ? ? }
? ? ? ? ? ? ? ?System.out.println();
? ? ? ? ? }
? ? ? }
? ?//打印结果：
? ?输出原始数组
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
======================================================
有效值的个数是：2
输出稀疏矩阵
11 11 2
1 2 1
2 3 2
======================================================
还原数组
输出还原的数组
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