概述
数组是多个相同数据类型按一定顺序排列的一组数据
特点：
- 数据类型相同！！
- 长度固定！！
构成数组的几个要素
- 数组名称
- 下标，又称索引
- 元素
- 数组长度
数组是一种引用类型，就像使用变量一样必须要有引用才能可控的访问
下标是数组的书签，访问数组的元素必须依靠下标
元素，数组所存储的数据，元素的数据类型必须和数组相同
长度，数组所存储的元素的个数
按维度分类，可以分为一维数组和多维数组
声明与初始化
package cn.dai; public class Arrays { public static void main(String[] args) { //声明一个数组 int[] array; // 初始化 array = new int[]{1,2,3,4,5,6,7}; // 如果简写，也就是静态初始化，必须 声明和初始化同时完成 int[] array2 = {2,3,4,5,7,8,9}; // 或者不对数组具体赋值元素而是初始化时声明数组的长度 int[] array3 = new int[10]; } }
访问元素和使用下标
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,3,5,7,9}; // 下标起始位置从0开始，结尾到数组的长度-1 System.out.println(array[0]); // 通过下标更改元素的值 array[3] = 10; } }
长度与遍历
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,3,5,7,9}; // 使用for循环遍历数组 length是数组的一个属性，表示数组的长度 for (int i = 0; i < array.length ; i++) { System.out.println( array[i] ); } } }
默认值？引用类型的属性问题
一维数组的内存分布图
多维数组
声明和初始化
package cn.dai; public class Arrays { public static void main(String[] args) { // 二维数组的初始化 静态 int[][] array = new int[][]{ {1,3,5,7,9}, {2,4,6,8,10} }; // 动态 二维数组可以只声明外围长度， // 内围数组没有声明就是未初始化的状态 // Java允许内围可以先不初始化 int[][] array2 = new int[4][]; } }
下标访问和遍历
package cn.dai; public class Arrays { public static void main(String[] args) { // 二维数组的初始化 静态 int[][] array = new int[][]{ {1,3,5,7,9}, {2,4,6,8,10} }; // 元素的访问 System.out.println(array[1][2]); // 遍历 // 先遍历外围长度，也就是内围的数组个数 for (int i = 0; i < array.length; i++) { // 再遍历下标指向的数组 for (int j = 0; j < array[i].length ; j++) { // 这样就能遍历每一个元素了 System.out.println( array[i][j] ); } } } }
数组练习
杨辉三角/帕斯卡三角
package cn.dai; public class Arrays { public static void main(String[] args) { // 杨辉三角形 外围的长度不限制 (不要低于5) int[][] pascalTriangle = new int[10][]; // 名字太长 声明一个简写引用一下 int[][] tri = pascalTriangle; for (int i = 0; i < tri.length; i++) { // 声明内围的数组 tri[i] = new int[i + 1]; // 连续赋值 每一行，也就是每一组数组的头和尾都是1 tri[i][0] = tri[i][i] = 1; // 对既不是头也不是尾的内部元素进行赋值 for (int j = 1; j < tri[i].length - 1 ; j++) { tri[i][j] = tri[i - 1][j - 1] + tri[i - 1][j]; } } // 打印查看 for (int i = 0; i < tri.length; i++) { for (int j = 0; j < tri[i].length; j++) { System.out.print(tri[i][j]+"\t"); } System.out.println(); } } }
一维数组：求最大最小值，平均值，总和
package cn.dai; public class Arrays { // 求最大值 static int getMaximum(int[] array){ // 设置游标 int max = array[0]; // 因为已经设置第一个赋值给了游标 从第二个开始遍历 for (int i = 1; i < array.length; i++) { // max = array[i] > max ? array[i] : max; max = Math.max(array[i], max); } return max; } // 求最小值 static int getMinimum(int[] array){ int min = array[0]; for (int i = 1; i < array.length; i++) { // min = array[i] < min ? array[i] : min; min = Math.min(array[i], min); } return min; } // 求和 static int getSummation(int[] array){ int sum = 0; for (int element : array) { sum += element; } return sum; } // 求平均值 static double getAverage(int[] array){ double sum = 0.0; for (int element : array) { sum += element; } return sum / array.length; } }
一维数组的复制
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,3,5,7,9}; // 先复制长度 int[] array2 = new int[array.length]; for (int i = 0; i < array2.length; i++) { // 复制元素 array2[i] = array[i]; } } }
一维数组的反转
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,2,5,10,9}; } static int[] reverse1(int[] array){ // 遍历一半长度进行元素交换 for (int i = 0; i < array.length / 2; i++) { int temp = array[i]; array[i] = array[array.length - 1 - i]; array[array.length - 1 - i] = temp; } return array; } static int[] reverse2(int[] array){ // 头尾双向交换 for ( int i = 0,j = array.length -1; i < j ; i++,j--) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } return array; } }
一维数组的线性查找 和 二分查找
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,2,5,10,9}; } // 线性查找 static int linearSearch(int[] array,int target){ for (int i = 0; i < array.length; i++) { if (target == array[i]) return i; // 找到直接返回索引 } return -1; // 找不到 返回-1 } // 二分查找 static int binarySearch(int[] array,int target){ int start = 0; int end = array.length -1; while ( start <= end ){ int mid = (start + end) / 2; // 每次二分都在不断变化的中轴游标 if (target == array[mid]) return mid; // 碰上了正好直接返回 else if (target > array[mid]) start = mid + 1; // 目标位置大于中轴，起始位置前推 else end = mid + 1; // 反之后退 } return -1; } }
【排序算法】
衡量排序算法的指标
- 时间复杂度 需要比较的次数和记录的移动次数
- 空间复杂度 内存耗费
- 稳定性 是否需要改变数据
按内外状态划分
- 内部排序 不需要外界辅助实现算法
- 外部排序 算法需要多部份完成，依赖外界辅助实现
【算法的特征】
- 对输入的描述和定义必须正确
- 输出必须要有结果产生
- 有穷性，在完成计算实现之后必须停止
- 确定性，算法的每一步都是明确的，不会歧义
- 可行性，算法的每一步都是清晰的，纸笔也能实现答案获取
冒泡排序
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,2,5,10,9}; } // 冒泡排序 static int[] bubbleSort(int[] array){ for (int i = 0; i < array.length -1; i++) { for (int j = 0; j < array.length -1; j++) { if (array[j] > array[j + i]){ int temp = array[i]; array[j] = array[j + 1]; array[j + 1] = temp; } } } return array; } }
快速排序 递归
https://blog.csdn.net/shujuelin/article/details/82423852
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,2,5,10,9}; } // 快速排序 static void quickSort(int[] arr,int start,int end){ int i,j,temp,t; if(start > end) return; i = start; j = end; //temp就是基准位 temp = arr[start]; while (i < j) { //先看右边，依次往左递减 while (temp <= arr[j] && i<j) j--; //再看左边，依次往右递增 while (temp>=arr[i]&&i<j) i++; //如果满足条件则交换 if (i<j) { t = arr[j]; arr[j] = arr[i]; arr[i] = t; } } //最后将基准为与i和j相等位置的数字交换 arr[start] = arr[i]; arr[i] = temp; //递归调用左半数组 quickSort(arr, start, j-1); //递归调用右半数组 quickSort(arr, j+1, end); } }
Arrays工具类
直接看源码，这里有非常多的重载
右边可以看到所有基本类型的重载方法
Arrays.sort() 将参数数组按顺序方式排序
关于parallelSort并行排序的资料：
https://www.infoq.cn/article/Java-8-Quiet-Features/
二分的重载
判断两个数组是否相同
fill 填充数组 你可以设置填充范围，不过默认全填充
复制数组直接照搬系统的复制方法...
将数组转换成String字符串形式
越界异常
package cn.dai; public class Arrays { public static void main(String[] args) { int[] array = {1,2,5,10,9}; // 越界异常 访问超过索引个数的位置 System.out.println(array[11]); } } Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11 at cn.dai.Arrays.main(Arrays.java:10) Process finished with exit code 1