正文
【Java】Array 数组
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
概述
数组是多个相同数据类型按一定顺序排列的一组数据
特点：
- 数据类型相同！！
- 长度固定！！
构成数组的几个要素
- 数组名称
- 下标，又称索引
- 元素
- 数组长度
数组是一种引用类型，就像使用变量一样必须要有引用才能可控的访问
下标是数组的书签，访问数组的元素必须依靠下标
元素，数组所存储的数据，元素的数据类型必须和数组相同
长度，数组所存储的元素的个数
按维度分类，可以分为一维数组和多维数组
声明与初始化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; // 初始化
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 = {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 = 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 = 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
