0714（009天数组基操）-CSDN博客

本文链接：https://blog.csdn.net/weixin_48015656/article/details/125791468

0714（009天数组基操）

每日一狗（一只明智的生活）

在这里插入图片描述

主标题

文章目录

0714（009天数组基操）
主标题
1. 数组
扩展小芝士

1. 数组

你是否还在为变量名的创建而发愁，是不是还在用n1、n2、n3…在为同类型变量命名，是不是已经因为声明变量而频繁的使用cv大法，数组他来了，抛弃原有的变量名，你只需要给他一个长度、一个类型，用于告知它你要存放的数据的数量和数据类型，同是在赋予它一个优雅的名字（数组），他就可以放下海量数据，同是还可以通过索引的方法来操作数组内部的任意一个值，同是他还亲切的提供了很多操作方法属性，让你随心所欲并且高效的数据处理。

数组的应用可是说是相当的广泛了，大家所熟知的数据库一样，他可以将拥有一定模式信息的信息以二维表的形式存储到数据库中，我们想要找啥数据直接select就行了，当然增删改查都得是基本功。一维数组就相当于只有一个标签的表格，它的索引就像是表格中的主键。

这里的数组就像是一个书架一样，只不过书架中有很多的格子，格子等宽，（在java中为了方便为数组分配空间，有定长数组和可变数组两种这里说的是定长的），我们想要往里边放一本书（数据），只需要找到想要放的书架的编号，把书塞进去，要用的时候，可以通过编号在从书架中吧对应的书拿出来看。

数组在这里充当的就是这个书架的作用，用于存储同一类型的不同数据值。方便我们后期调用

专业描述：所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，数组变量是引用（地址）型变量

内存分配：

创建时就已经全部分配
分配的内存是一整块连续的空间

特点

数组是有序的
数组属于引用数据类型
数组的元素既可以是基本数据类型；也可以是引用数据类型（套娃二维数组的诞生）
数组一旦声明，数组的长度就不可以进行修改
数组的内存空间在开辟的时候就已经全部分配了。

分类

维度：一维或多维度
按照存储的元素的数据类型：引用数据类型或者基本数据类型

优势：自动给数组中的元素从0开始编号，方便操作

坑位：

数组在存储简单类型时都有初始值（布尔为假，整形为零，字符型为0所对应的字符）
- 整形：0
- 浮点数：0.0
- char：0或者'\u0000'
- 布尔值：byte[]，存的是false
甲骨文的jvm中采用byte[]方式进行存储

1.1 基本操作

声明并开辟数组

元素类型[] 数组名 = new 元素类型[元素个数或者数组长度];
eg： int[] arr1 = new int[5]; // 初始化默认用 0 占位
赋值	;
	arr1[0] = 10;

静态初始化

元素类型[] 数组名 = new 元素类型[]{元素1,元素2...元素n};
int[] arr = new int[]{1, 2, 3}
简写 int[] arr = {1, 2, 3}

遍历操作

// TODO Auto-generated method stub
int[] arr = new int[6];
Scanner sc = new Scanner(System.in);

// 索引操作
for (int i = 0; i < arr.length; i++) {
    arr[i] = sc.nextInt();	// 1 2 3 4 5 6
}
// for_each
for (int i : arr) {
    System.out.print(i + "\t");// 	1	2	3	4	5	6	
}

练习题

计算学生的平均分（静态创建数组）

// TODO Auto-generated method stub
//	int[] arr = new int[]{72,85,95,64,99};
int[] arr = { 72, 85, 95, 64, 99, 80 };
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    sum += arr[i];
}
System.out.println("总分为" + sum);
System.out.println("该班的平均分为" + 1. * sum / arr.length);

将一个整数插入一个有序数组，要求新数组依然有序

// TODO Auto-generated method stub
int[] old = { 12, 14, 23, 45, 66, 68, 70, 77, 90, 91 };
int kk = 50;
int[] newArr = new int[old.length + 1];
boolean inster = true;
for (int i = 0; i < old.length; i++) {
    if (kk > old[i]) {
        newArr[i] = old[i];
    } else if (kk < old[i]) {
        if (inster) {
            newArr[i] = kk;
            inster = false;
        }
        newArr[i + 1] = old[i];
    }
}
for (int i = 0; i < newArr.length; i++) {
    System.out.print(newArr[i] + "\t");
}

将一个数组的奇数值方到左边，偶数数方到右边

0是偶数

// 定义一个数组，将其中奇数方到左边，偶数方到右边
int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };
int[] brr = new int[arr.length];
int k = 0;
int m = arr.length - 1;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] % 2 == 0) {
        brr[k++] = arr[i];
    } else {
        brr[m--] = arr[i];
    }
}
for (int i = 0; i < brr.length; i++) {
    System.out.print(brr[i] + "\t");
}

1.2 常见异常

空指针异常（NullPointerException）

原因：引用类型变零没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

int[] obj=null;
System.out.println(obj.length);

索引越界（ArrayIndexOutOfBoundsException）

原因：访问了不存在的索引值n < 0 || n > arr.length

1.3 经典案例

排序算法的衡量

时间复杂度（程序运行时间和问题的规模的增长比率）
- 只找它的最高次方
空间复杂度
- O(1)：需要的变量空间为固定值，不跟着规模大小变化
稳定性
- 处理同样的数据会不会有不同处理结果
- 订单按照金额进行排序，相同数据的相对位置会不会改变

冒泡排序（原地操作，n^2，稳定）

// TODO Auto-generated method stub
double[] arr = { 12.9, 53.54, 75.0, 99.1, 3.14 };
// 外层循环控制范围
for (int i = 1; i < arr.length; i++) {
    // 内层循环判定规则，不满足的交换数据
    for (int j = 0; j < arr.length - i; j++) {
        if (arr[j] > arr[j + 1]) {
            double tmp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = tmp;
        }
    }
}
for (double i : arr) {
    System.out.print(i + "\t");
}

折半查找（logn）

// TODO Auto-generated method stub
int[] arr = new int[10];
// 生成随机数
for (int i = 0; i < arr.length; i++) {
    arr[i] = (int) (Math.random() * 101);
}
arr[0] = 20;
int tmp;
// 冒泡排序
for (int i = 1; i < arr.length; i++) {
    for (int j = 0; j < arr.length - i; j++) {
        if (arr[j] > arr[j + 1]) {
            tmp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = tmp;
        }
    }
}
for (int i : arr) {
    System.out.print(i + "\t");
}
// 折半查找
int start = 0;
int end = arr.length - 1;
int num = 20;
int pos = -1;
int mean;
while (start <= end) {
    mean = (start + end) / 2;
    if (arr[mean] > num) {
        end = mean - 1;
    } else if (arr[mean] < num) {
        start = mean + 1;
    } else {
        System.out.println(mean);
        pos = mean;
        break;
    }

}
System.out.println("\n" + num + ":" + pos);

扩展小芝士

数组在存储简单类型时都有初始值（布尔为假，整形为零，字符型为0所对应的字符）
甲骨文的jvm中采用byte[]方式进行存储
临时变量必须先创建后赋值，先赋值后使用
常见排序算法
- 冒泡
- 选择
- 插入
- 快速
- 希尔
- 堆
- 归并
排序算法的衡量
- 时间复杂度（程序运行时间和问题的规模的增长比率）
  - 只找它的最高次方
- 空间复杂度
  - O(1)：需要的变量空间为固定值，不跟着规模大小变化
- 稳定性
  - 处理同样的数据会不会有不同处理结果
  - 订单按照金额进行排序，相同数据的相对位置会不会改变