本文仅作为个人笔记

数组

数组的引入

import java.util.Scanner;
public class TestArray01{public static void main(String[] args){//功能：键盘录入是个学生的成绩，求和，求平均数：//定义一个求和的变量：int sum = 0;Scanner sc = new Scanner(System.in);for(int i = 0; i<10;i++){//i:控制循环次数System.out.println("请录入第"+i+"个学生的成绩");int score = sc.nextInt();sum += score}System.out.println("是个学生的成绩之和为："+sum);System.out.println("是个学生的成绩平均数为："+sum/10);//这样写的缺点：//算出总成绩之后无法获得其中每个学生的成绩}
}

缺点：不能求每个学生的具体成绩是多少

解决：将成绩进行存储—》引入：数组

数组的作用：数组用来存储数据的，在程序设计中，为了处理方便，数组用来将相同类型的若干个数据组织起来，若干个数据的集合称为数组

数组的定义

静态初始化数组

定义数组的时候直接给数组赋值

静态初始化数组的格式

//完整格式
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3...};
double[] score = new double[]{1.1,1.2,1.3,1.4};
int[] ages = new int[]{11,12,13};

//简化格式
数据类型[] 数组名 = {元素1,元素2,元素3,...};
int[] ages = {12,24,36}

数组的存储原理

• 数组的访问

  数组名称[索引]

     System.out.println(scores[0]);//1.1System.out.println(scores[2]);//1.3scores[2] = 1.9;//数组的再赋值System.out.println(scores[2]);//1.9
  

  数组的长度属性：length

   //长度属性：length//获取数组的长度（就是数组的个数）System.out.println(scores.length);//4
  

  数组的最大索引

  数组的最大索引：数组名.length - 1 //前提：元素个数大于0
  

• 数组的注意事项

  • 数据类型[] 数组名 也可以写成 数据类型 数组名[]

    int[] ages =...;
    int ages[] = ...;double[] scores = ...;
    double[] = scores = ...;
    

  • 什么类型的数组存放什么类型的数据，否则报错

    int[] arrs = new int[]{30,40,"黑马"};
    

  • 数组一旦定义出来，程序执行的过程中，长度、类型就固定了。

​

public class ArrayAttentionDemo03 {public static void main(String[] args) {//目标：理解数组的注意事项//1、数据类型[] 数组名称 也可以写成 数据类型 数组名称[]int[] ages = {11,12,13};//int ages[] = {11,12,13};//2、什么类型的数组只能存放什么类型的元素// String[] names = {"小明","小王"，22};//错误的//3、数组一旦定义出来之后，类型和长度就固定了int[] ages2 = {22,23,24};//System.out.println(ages2[3]);//报错，长度固定是三了不能访问第四个元素}
}

总结：

1.如何访问数组的元素

数组名称[索引]

2.如何访问数组的长度

数组名称.length

3.数组的最大索引怎么获取？

数组的最大索引：数组名.length - 1 //前提：元素个数大于0

public class ArrayDemo01 {public static void main(String[] args){//目标：学会使用静态初始化的方式定义数组//数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3...};// double[] scores = new double[]{1.1,1.2,1.3,1.4};double[] scores = {1.1,1.2,1.3,1.4};// int[] ages = new int[]{11,12,13};int[] ages ={11,12,13};// String[] names = new String[]{"小明","小红","小王"};String[] names = {"小明","小红","小王"};System.out.println("scores中存的是："+scores);System.out.println(scores[0]);//1.1System.out.println(scores[2]);//1.3scores[2] = 1.9;System.out.println(scores[2]);//1.9//长度属性：length//获取数组的长度（就是数组的个数）System.out.println(scores.length);//4}
}

public class ArrayDemo02 {public static void main(String[] args) {//目标：学会访问数组的元素int [] ages = {11,12,13,14};//取值：数组名称[索引]System.out.println(ages[0]);System.out.println(ages[1]);System.out.println(ages[2]);System.out.println(ages[3]);//赋值：数组名称[索引] = 数据；ages[2] = 100;System.out.println(ages[2]);//访问数组的长度System.out.println(ages.length);//4//数组的最大索引：数组名.length - 1 //前提：元素个数大于0}
}

动态初始化数组

数组的动态初始化

• 定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据

数组的动态初始化格式：

数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];//后赋值
arr[0] = 10;
System.out.println(arr[0]);//10

总结

1.动态初始化的写法是什么样的？

数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[4];

2.两种数组定义时的特点和场景有什么区别

当前已经知道存入的元素值，用静态初始化。
当前还不清楚要存入哪些数据，用动态初始化

动态初始化数组的元素默认值

两种初始化的使用场景总结、注意事项说明：

• 动态初始化：只 指定数据 长度，后期赋值 ，适合开始知道数据的数量，但是不确定具体元素值的业务场景。

• 静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。

• 两种格式的写法时严格独立的，不可以混用

  int[] arrs = new int[3]{30,40,50}//这是错误的
  

  public class ArrayDemo05 {public static void main(String[] args) {//目标：掌握动态初始化元素默认值的规则。//1、整形数组的元素默认值都是0int[] arr = new int[10];System.out.println(arr[0]);//0System.out.println(arr[9]);//0//2、字符数组的元素默认值都是0char[] chars = new char[100];System.out.println((int)chars[0]);//0System.out.println((int)chars[99]);//0//3、浮点型数组的元素默认值都是0.0double[] scores = new double[90];System.out.println(scores[0]);//0.0System.out.println(scores[89]);//0.0//4、布尔类型的数组boolean[] booleans = new boolean[100];System.out.println(booleans[0]);//falseSystem.out.println(booleans[99]);//false//5、引用类型的数组String[] names = new String[90];System.out.println(names[0]);//nullSystem.out.println(names[89]);//null}
  }
  

总结

1.动态初始化数组后元素的迷人之是什么样的？

• byte、short、int、long、char类型数组元素的默认值都是0
• float double 类型数组元素的默认值都是0.0
• boolean 类型数组元素的默认值是false、String类型数组元素的默认值是null

数组的遍历

• 遍历：就是一个一个数据的访问
• 遍历的作用：搜索、数据统计等等都需要用到遍历。

int[] ages = {20,30,40,50};
for(int i = 0; i System.out.println(ages[i]);
}

public class ArrayDemo {public static void main(String[] args) {//目标：学会进行数组元素的遍历int[] arr ={12,24,36,48};//数组遍历形势//数组快捷方式：数组名.forifor (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}

总结：

1.什么是遍历？

• 一个一个的把数据访问一遍

2.如何遍历数组？

 int[] arr ={12,24,36,48};for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}

数组的案例

• 数组元素求和

  需求：某部门5名员工的销售额分别是16、26、36、6、100，请计算出他们部门的总销售额。

  public class Test01 {public static void main(String[] args) {//需求数组求和int[] money ={16,26,36,6,100};//定义总和int sum = 0;//遍历数组中的每个元素for (int i = 0; i < money.length; i++) {sum +=money[i];}System.out.println("总金额为"+sum);//184}
  }
  

  总结

  1.如何实现批量数据的求和？

  • 使用数组存储批量数据

    int[] money ={16,26,36,6,100};
    

  • 遍历数组中的每个数据，然后定义变量把他们累加起来

        //定义总和int sum = 0;//遍历数组中的每个元素for (int i = 0; i < money.length; i++) {sum +=money[i];}System.out.println("总金额为"+sum);//184
    

• 数组求最值

  public class Test02 {public static void main(String[] args) {//需求：求数组元素最值。//1.定义一个静态初始化的数组，存储一批数据int[] data = {12,800,9000,20000,0,-5};//2.定义一个变量用于存储最大值元素，建议使用第一个元素作为参照int max = data[0];//3.遍历数组的每个元素，依次与最大值变量的数据比较，若较大，则替换。for (int i = 0; i < data.length; i++) {if(maxmax = data[i];}}//4.输出最大值变量存储的数据System.out.println("最大值为"+max);//20000}
  }
  

  总结：

  1.数组元素求最大值如何实现的？

  • 数据拿到程序中去，用数组存储起来
  • 定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照。
  • 遍历数组的元素，如果该元素大于变量存储的元素，则替换变量存储的值为该元素

• 猜数字游戏

  需求：开发一个幸运小游戏，游戏规则如下：

  游戏后台随机生成1-20之间的5个数（无所谓是否重复），然后让大家来猜数字

  • 未猜中提示：“未命中”，并继续猜测
  • 猜中提示：“运气不出，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。

  public class Test03 {public static void main(String[] args) {//需求：5个 1-20之间的是随机数，让用户猜测，猜中要提示猜中，还要输出该数据再数组中第一次出现的索引，并打印数组的内容出来。//没有猜中接续。//1、定义一个动态初始化数组存储5个随机的1-20之间的数据int[] data = new int[5];//2.动态的生成5个1-20之间的随机数并存入到数组中去。for (int i = 0; i //data[i]=  (int) (Math.random() * 20) + 1;}//3.使用一个死循环让用户进行猜测Scanner sc = new Scanner(System.in);OUT:while (true){System.out.println("请您输入一个1-20之间的整数进行猜测：");int guessData= sc.nextInt();//4.遍历数组中的每个数，看是否有数据与猜测的数据相同，相同代表猜中了，给出提示for (int i = 0; i < data.length; i++) {if(data[i] == guessData){System.out.println("您已经猜中了该数据，运气不错了！您猜中的数据索引是：" + i);break OUT;//结束了整个死循环代表游戏结束了！}}System.out.println("当前猜测的数据在数组中不存在，请重新猜测！");}//5、输出数组的全部元素，让用户看到自己确实是猜中了某个数据。for (int i = 0; i < data.length; i++) {System.out.print(data[i] + "\t");}}
  }
  

  总结：

  猜数字游戏的实现步骤？

  • 动态初始化数组，存入5个随机的1-20之间的数据
  • 定义一个死循环，不断的才数据，遍历数组，判断数据是否再数组中，如果在，进行对应提示并结束死循环；如果没有猜中，提示继续

• 随机排名

  需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。

  请线依次录入5名员工的工号，然后展示出一组随机的排名顺序

  22、33、35、13、88 -----》13、35、88、33、22

  分析：

  • 在程序录入5名员工的工号存储起来 —》使用数组
  • 依次遍历数组中的每个元素，随机一个索引数据，让当前元素与该索引位置处的元素进行交换。

  public class Test04 {public static void main(String[] args) {//目标：键盘录入一组工号，最终要随机输出一组出来作为排名//1.动态初始化一个数组，存储5个工号int[] codes = new int[5];//2.定义一个循环，遍历数组，依次录入一个工号存入对应的位置Scanner sc = new Scanner(System.in);for (int i = 0; i < codes.length; i++) {//正式录入工号System.out.println("请您输入第"+(i+1)+"个员工的工号：");int code = sc.nextInt();//存入到数组中去codes[i] = code;}//3.遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换（重点）Random r = new Random();for (int i = 0; i < codes.length; i++) {//当前遍历的元素值：code[i]//随机一个索引位置出来：codes[index];int index = r.nextInt(codes.length);//定义一个临时变量存储index位置处的值int temp = codes[index];codes[index] = codes[i];codes[i] = temp;}//遍历数组元素输出就是随机排名的结果for (int i = 0; i < codes.length; i++) {System.out.print(codes[i] + "\t");}}
  }
  

  总结：

  如何实现随机排名

  • 定义一个动态初始化的数组用于录入数据。
  • 遍历数组中的每个元素，每次随机一个索引值，让当前元素与该索引位置处的元素进行交换。

• 数组排序

  数组排序就是对数组中的元素，进行升序(由小到大)或者降序(由大到小)的操作。

  数组排序的技术

  • 冒泡排序
  • 选择排序
  • 快速排序
  • 插入排序
  • …

  数组搜索相关的技术

  • 二分搜索
  • 分块查找
  • 哈希表查找
  • …

  冒泡排序思路

  • 每次从数组中找出最大值放在数组中的最后面去（每个索引的数据都比较一遍）

  实现冒泡排序的步骤分析

  • 确定总共需要做几轮：数组的长度-1

  • 每轮做几次：

    i（轮数）	次数	次数规律
    1	3	数组的长度-1
    2	2
    3	1

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bs10o9Ms-1668566772252)(C:\Users\邢金政\Pictures\冒泡排序.png)]

  public class Test05 {public static void main(String[] args) {//定义一个数组，存储一些数据int[] arr = {5,2,3,1};//           0,1,2,3//2.定义一个循环控制比较的轮数for (int i = 0; i < arr.length -1; i++) {//i = 0 时 比较3次 j = 0,1,2//i = 1 时 比较2次 j = 0,1//i = 2 时 比较1次 j = 0for (int j = 0; j //判断j当前位置的索引值 是否 大于后一个位置 若较大 则交换if(arr[j] > arr[j+1]){int temp =  arr[j+1];arr[j+1] = arr[j];arr[j] = temp;}}}//遍历数组内容输出for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+"\t");}}
  }
  

  总结

  冒泡排序的思想

  • 从头开始两两比较，把较大的元素与较小的元素进行交换
  • 每轮把当前最大的一个元素存入到数组当前的末尾。

  冒泡排序的实现步骤

  • 定义一个外部循环控制总共需要判断几轮（数组的长度-1）
  • 定义一个内部循环，控制每轮一次往后比较几个位置（数组长度 -i-1）

数组的内存原理

Java内存分配、数组内存图

Java内存分配介绍

• 栈
• 堆
• 方法区
• 本地方法栈
• 寄存器

两个变量指向同一个数组对象

数组使用常见问题

问题1：如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutBoundsException(数组索引越界异常)

public class Test06 {public static void main(String[] args) {int[] arr ={11,22,33};System.out.println(arr[2]);//33System.out.println(arr[3]);//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3}
}

问题2：如果数组变量中没有存储数组的地址，而是null，在访问数组信息是会出现NullPointerException(空指针异常)

public class Test06 {public static void main(String[] args) {int[] arr ={11,22,33};System.out.println(arr[2]);//33arr = null;System.out.println(arr);//null//System.out.println(arr.length);//Exception in thread "main" java.lang.NullPointerException}
}