3.1数组
导语：今天整理了数组的笔记以及部分案例，希望对大家有用。
一.数组
1.数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，通过编号的方式对这些数据进行统一管理。
2.数组的常见概念
数组名
下标（索引）
元素
数组的长度
3.数组的特点：
①数组是有序排列的
②数组属于引用数据类型
③数组的元素，既可以是基本数据类型，也可以是引用数据类型
④数组对象会在内存中开辟一段连续的空间
⑤数组的长度一旦确定，不可修改
4.数组的分类
按照维数：一维数组，二维数组…
按照数组元素类型：基本数据类型元素的数组，引用数据类型元素的数组
5.一维数组的使用
①一维数组的声明和初始化
②如何调用数组的指定位置的元素
③如何获取数组的长度
④如何遍历数组的元素
⑤数组元素的默认初始化值
⑥数组的内存解析
案例//
{
//①一维数组的声明和初始化
int num;//声明
num = 10;//初始化
int[] ids;
//静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{
1001,1002,1003,1004};
//动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
//②如何调用数组的指定位置的元素：通过下标的方式调用
//数组的脚标从0开始，到数组的长度-1
names[0] = "张三1";
names[1] = "张三2";
names[2] = "张三3";
names[3] = "张三4";
names[4] = "张三5";
//③如何获取数组的长度
System.out.println(names.length);
//④如何遍历数组的元素
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
//⑤数组元素的默认初始化值
//整型：0
//浮点型：0.0
//char类型：字符集为0对应的字符，输出空字符" "，可以用分支语句和0判断相等
//boolean类型：false（0）
//数组元素类型是引用数据类型：null
int[] arr = new int[4];
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}//输出0000
char[] arr1 = new char[4];
System.out.println(arr1[0]);//" "空字符
if(arr1[0] == 0){
System.out.println("可以判定，并输出");
}
String[] arr2 = new String[4];
System.out.println(arr2[0]);//输出null
if(arr2[0] == null){
System.out.println("可以判定，并输出");
}
}
⑥一维数组的内存解析(在JVM中体现)主要部分如下
System.out.println(arr1[1]);//输出null
//案例
//输入五个同学成绩找出最高分，并判断ABCD
import java.util.Scanner;
{
//使用Scanner，读取学生个数
Scanner scanner = new Scanner(System.in);//ctrl + shift + o
System.out.println("输入学生人数");
int number = scanner.nextInt();
//创建数组，存储成绩
int[] scores = new int[number];
//遍历数组并赋值
System.out.println("请输入" + number "个成绩");
for(int i = 0;i < scores.length;i++){
scores[i] = scanner.nextInt();
}
//获取最大值
int maxScores = 0;
for(int i = 0;i < scores.length;i++){
if(maxScores < scores[i]){
maxScores = scores[i];
}
}
//判断每个学生和最高分的差值，得到等级并输出
char level;
for(int i = 0;i < scores.length;i++){
if(maxScore - scores[i] <= 10){
level = 'A';
}else if(maxScore - scores[i] <= 20){
level = 'B';
}else if(maxScore - scores[i] <= 30){
level = 'C';
}else{
level = 'D';
}
System.out.println("student" + i + "scores" + scores[i] + "level" + level);
}
}
6.多维数组的使用
多维数组可以看做是数组的嵌套使用，一个数组作为另一个数组的元素出现
①二维数组的声明和初始化
②如何调用数组的指定位置的元素
③如何获取数组的长度
④如何遍历数组的元素
⑤数组元素的默认初始化值
⑥数组的内存解析
//案例
{
//①二维数组的声明和初始化
//静态初始化
int [] arr = new int[]{
1,2,3};//一维数组
int [] arrs ={
1,2,3};//类型推断
int [][] arr1 = new int[][]{
{
1,2,3},{
4,5},{
6,7,8}};
//动态初始化
String[][] arr2 = new String[3][2];//外围数组中的每个元素含有具有两个元素的数组
String[][] arr3 = new String[3][];
String[] arr4[] = new String[3][];
//②如何调用数组的指定位置的元素
System.out.println(arr1[0][1]);//2
//arr3[1] = new String[4];给外层数组第二个区域写入四个空间，下一行则正常运行
System.out.println(arr3[1][0]);//报错空指针异常，数组arr3的内层数组没有开辟空间
//③如何获取数组的长度
//int [][] arr1 = new int[][]{
{1,2,3},{4,5},{6,7,8}};
System.out.println(arr1.length);//3
System.out.println(arr1[1].length);//2
//④如何遍历数组的元素
for(int i = 0;i < arr1.length;i++){
for(int j = 0;j < arr1[i].length;j++){
System.out.println(arr1[i][j]);
}
}
//⑤数组元素的默认初始化值
int[][] arr5 = new int[4][3];
//外层元素初始化值：地址值
//内层元素初始化值：与一维数组情况相同
System.out.println(arr[0]);//输出其地址值
System.out.println(arr[0][0]);//0
System.out.println(arr);//输出外层数组
double[][] arr6 = new double[4][];
//外层元素初始化值：null
//内层元素初始化值：不能调用，报错空指针
System.out.println(arr6[1]);//null
//System.out.println(arr6[1][0]);//报错空指针异常
}
⑥多维数组的内存解析
//案例
//获取数组中所有元素的和
{
int[][] arr = new int[][]{
{
3,5,8},{
12,9},{
7,0,6,4}};
int num = 0;
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
num += arr[i][j];
}
}
System.out.println(num);
}
3.2数组的算法
1.杨辉三角
//案例 使用二维数组打印一个10行的杨辉三角
//提示：每一行有第n行n个元素，第一个元素和最后一个元素都为1
//从第三行开始，对于非第一个元素和最后一个元素
//yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
{
int[][] yangHui = new int[10][];
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1];
yangHui[i][0] = yangHui[i][i] = 1;
if(i > 1){
for(int j = 1;j < yangHui[i].length - 1;i++){
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
}
}
}
for(int i = 0;i < yangHui.length;i++){
for(int j = 0;j < yangHui[i].length;j++){
System.out.print(yangHui[i][j] + " ");
}
}
}
2.生成不相同的随机数
//案例
//创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，要求各值都不相同
{
int[] nums = new int[6];
int dest = 0;
loop:for(int i = 0;i < 6;i++){
dest = Math.floor(Math.random() * 31);
if(i == 0){
nums[i] = dest;
}else{
for(int j = 0;j < i;j++){
if(dest == nums[j]){
i = i-1;
continue loop;
}else{
nums[i] = dest;
}
}
}
}
for(int i = 0;i < 6;i++){
System.out.print(nums[i]);
}
}
3.回形数
//n = 4
//1 2 3 4
//12 13 14 5
//11 16 15 6
//10 9 8 7
//案例
{
int n = 4;
int m = 0;
int[][] arr = new int[n][n];
int maxX = n;//n - 1
int minX = -1;
int maxY = n - 1;
int minY = 0;
while(minX <= maxX){
for(int i = 0; i < maxX; i++){
arr[minY][++minX] = ++m;
}
maxX--;
for(int i = 0; i < maxY; i++){
arr[++minY][minX] = ++m;
}
maxY--;
for(int i = 0; i < maxX; i++){
arr[minY][--minX] = ++m;
}
maxX--;
for(int i = 0; i < maxY; i++){
arr[--minY][minX] = ++m;
}
maxY--;
}
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
4.求数组中元素的最大值，最小值，平均数，总和
//案例
{
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int)(Math.random()*(99-10+1)+10);
}
//求最大值
int maxValue = arr[0];
for(int i = 0;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
//最小值
int minValue = arr[0];
for(int i = 0;i < arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
//总和
int allValue = 0;
for(int i = 0;i < arr.length;i++){
allValue += arr[i];
}
//平均值
int avgValue = allValue / arr.length;
}
5.使用简单数组
//案例
//创建一个类，声明array1和array2两个int[]数组
//用大括号吧array1初始化8个素数：2,3,5,7,11,13,17,19
//显示arra1的内容
//赋值array2等于array1，修改array2中的偶索引元素，使其等于索引值(array[0] = 0)，打印array1
//array1和array2的关系：array2就像是array1的快捷方式，他们拥有相同的地址
{
int[] = array1,array2;
array1 = new int[]{
2,3,5,7,11,13,17,19};
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
array2 = array1;//不是数组的复制，是吧array1的地址赋给array2
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
//因为array1的地址赋值给array，更改array2就等于更改array1
array2[i] = i;
}
}
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}//打印出来和array2更改一样
}
6.数组的复制，反转，查找(线性查找，二分法查找)
{
String[] arr = new String[]{
"aa","bb","cc","dd"};
//复制
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[i];
}
//反转
//方法1
for(int i = 0;i < arr.length / 2;i++){
String temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
//方法2
for(int i = 0,j = arr.length - 1;i < j; i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = trmp;
}
}
7.查找
//案例 线性查找
{
String[] arr = new String[]{
"aa","bb","cc","dd"};
String dest = "bb";
boolean ifFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.println(i);
ifFlag = false;
break;
}
}
if(isFlag){
System.out.println("没有相同的内容");
}
}
//案例 二分法查找
//前提：所要查找的数组必须有序
{
int[] arr = new int[]{
-99,-45,2,8,10,,24,48,54};
int dest = 24;
int head = 0;
int end = arr.length - 1;
boolean isFlag = true;
while(head <= end ){
int middle = (head + end) / 2;
if(dest == arr[middle]){
System.out.println(middle);
isFlag = false;
break;
}else if(arr[middle] > dest){
end = middle - 1;
}else{
end = middle + 1;
}
}
if(isFlag){
System.out.println("没有相同的内容");
}
}
8.排序
①选择排序：直接选择排序，堆排序√
②交换排序：冒泡排序√，快速排序√
③插入排序：直接插入排序，折半插入排序，Shell排序
④归并排序√
⑤桶式排序
⑥基数排序
//案例①冒泡排序
{
int[] arr = new int[]{
8,9,1,5,-10,48,55,4,20};
int dest = 0;
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j+1]){
dest = arr[j];
arr[j] = arr[j+1];
arr[j+1] = dest;
}
}
}
for(int i = 0;i < arr.length;i++) {
System.out.print(arr[i] + " ");
}
}
9.arrays工具类
①boolean eauals(int[] a,int[] b); 比较数组是否相等
//案例
{
//①boolean eauals(int[] a,int[] b); 比较数组是否相等
int[] arr1 = new int[]{
1,2,3,4};
int[] arr2 = new int[]{
1,4,2,3};
boolean isEquals = Arrays.equals(arr1,arr2);
System.out.println(isEquals);
//②String toString(int[] a);输出数组信息
System.out.println(Arrays.toString(arr1));
//③void fill(int[] a,int val);将指定值填充到数组之中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//④void sort(int[] a);对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//⑤int binarySearch(int[] a,int key)二分查找
int[] arr3 = new int[]{
8,9,1,5,-10,48,55,4,20};
int index = Arrays.binarySearch(arr3, 4);
System.out.println(index);//没找到时返回一个负数
}
10.说明
①如何判断算法的优劣：时间复杂度、空间复杂度、稳定性
②排序的分类：内部排序，外部排序（借助磁盘）
<1.理解
①定义在java.util.Arrays包下
②Arrays提供了很多操作数组的方法
<2.数组的常见异常
①数组的角标越界异常:ArrayIndexOutOfBoundsExcetion
②空指针异常：NullPointerException
情况一：给数组赋值null，覆盖地址
情况二：未赋值，未开辟内存空间输出则报错空指针