文章目录
数组
数组的定义与访问
静态初始化数组
定义数组时直接给数组赋值
//正常版本
int[] ages = new int[]{12,24,36};
//简化版本
int[] ages = {12,24,36};
-
什么类型的数组只能存放什么类型的数据。
-
int[] ages = {12,24,36};
计算机中的程序都是在内存中执行的，计算机遇到代码之后会在内存中开辟一块空间，但暂时不装东西，会等到等号右边的东西进来。右边的代码也会新开辟一块区域，分三块存储（12,24,36）。然后右边会把数组地址交给左边的数组变量，用数据变量指向数组，然后进行访问。
- 对象可以理解为就是个东西
int[] ages = new int[]{121, 234, 234};
System.out.println(ages);
//响应结果
[I@afb5f4df
Process finished with exit code 0
//[代表是数组的地址，I代表是Int类型数组，@在哪个地址，在afb5f4df这个地址
注意：数组变量名中存储的是数组在内存中的地址，数组是引用数据类型
🧙♂️数组的访问
取值、赋值、数组的长度属性
数组名[索引] 索引可以理解为就是数组里的第几个
索引就是数组中的编号
//取值
System.out.println(ages[0]);
//赋值
ages[1] = 900;
System.out.println(ages[1]);
//响应结果
121
900
Process finished with exit code 0
//数组的长度属性：length
System.out.println(ages.length);
//响应结果
3
Process finished with exit code 0
-
技巧：获取非空数组的最大索引：arr.length-1
-
如果访问数组时，使用的索引超过了数组的最大索引，会提示：索引越界的bug
🧙♂️数组的遍历
-
遍历就是一个一个访问一遍容器中的数据。
-
为什么要遍历？求和、元素搜索、找最大值最小值
-
怎么遍历数组？ 用for循环
int[] ages = new int[]{12,23,36};
for (int i = 0; i < ages.length; i++) {
System.out.println(ages[i]);
}
//响应结果：
12
23
36
Process finished with exit code 0
技巧：编码的时候写ages.fori一回车就可以了
动态初始化数组
定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组长度
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
//后赋值
arr[0] = 10;
System.out.println(arr[0]);
-
提示：静态初始化和动态初始化数组的写法是独立的，不能混用
int[] arr = new int[3]{12,23,34}; 就是错的！
//动态初始化数据没有放数据之前，初始值是0
int[] arr = new int[3];
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//相应结果：
0
0
0
Process finished with exit code 0
//往数组里存入数据
int[] arr = new int[3];
arr[0] =11;
arr[1] =22;
arr[2] =33;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//
11
22
33
Process finished with exit code 0
案例
某歌唱比赛，需要开发一个系统，可以录入六个评委的打分，录入完毕后立即输出平均分作为选手得分。
public static void main(String[] args) {
int[] grades = new int[6];
Scanner sc = new Scanner(System.in); //准备一个扫描器
int total = 0;
for (int i = 0; i < grades.length; i++) {
System.out.println("输入第" + (i+1) + "位评委的分数：");
int scores = sc.nextInt(); //接收数据
grades[i] =scores; //把数据存起来
}
for (int i = 0; i < grades.length; i++) {
total += grades[i];
}
System.out.println("总分为：" + total);
}
//响应结果：
输入第1位评委的分数：
5
输入第2位评委的分数：
6
输入第3位评委的分数：
7
输入第4位评委的分数：
8
输入第5位评委的分数：
9
输入第6位评委的分数：
10
总分为：45
Process finished with exit code 0
两种数组定义的方法适合什么业务场景？
动态初始化：适合开始不确定具体元素值，只知道元素个数的业务场景。
静态初始化：适合一开始就知道要存入哪些元素值的业务场景
数组在计算机中的执行原理
数组的执行原理，java程序的执行原理
运行一个java程序，主要看JVM中包含的3块内存区域：方法区、栈内存、堆内存
程序都是在计算机中的内存中执行的，Java程序编译之后会产生class文件，
这个class文件提取到内存中正在运行的JVM虚拟机里面执行
Java为了便于虚拟机执行程序，将虚拟机中的这块内存区域进行划分，划分成方法区、栈、堆、本地方法栈、程序计数器。
Java程序在计算机中的执行过程，主要通过方法区、栈、堆这三块区域配合执行的
-
方法区是放编译后的class文件（字节码文件）的，先加载到方法区里。
-
栈内存是方法运行时所进入的内存。由于变量是在方法里的，所以变量也在这片区域里。执行main方法时，是把main方法提到栈里进行执行。
-
堆内存里放的都是new出来的东西，这些东西会在堆内存中开辟空间并产生地址。
数组在计算机中的执行原理：
1.首先程序执行的时候，程序的class文件会被提取出来，到方法区里。
2.会把main方法加载到栈里执行，此时正式执行第一行代码。
3.第一行在定义一个基本类型变量，这个变量会在栈里开辟空间，并存储数据10。
4.接着执行第二行代码，输出变量a，把数据10直接打印出来。
5.第三行代码时，会在栈内存开辟arr变量的空间，一开始变量中没有存储数据
6.接着会执行等号右边的代码，右边的代码相当于是New一个数据对象，所以会放在堆内存中，因此会在堆内存中开辟一个空间。这个空间会分成三个等分的区域，第一个区域存11，第二个区域存22，第三个区域存33。
7.然后将地址信息赋值给arr，再arr指向数组对象
8.接着第四行，输出引用类型的变量，arr变量里存储的是右边数组对象的地址，所以输出地址。
9.第五行，通过arr变量，可以找到数组对象。再通过申请索引1，定位到第二个元素，输出22
10.第6 7 8行，通过arr变量找到数据对象以及索引，改数。第9 10 11行同理。
多个变量指向同一个数组的问题
//声明一个数组arr1
int[] arr1 = {11,22,33};
//把int类型的数组变量arr1赋值给int类型的数组变量arr2
int[] arr2 = arr1;
System.out.println(arr1);
System.out.println(arr2);
//响应结果：
[I@81ed48b1
[I@81ed48b1
Process finished with exit code 0
多个变量指向同一数组对象：（其实赋值的是数组的地址，所以指向的一样）
int[] arr1 = {11,22,33};
int[] arr2 = arr1;
arr2[1] = 99;
System.out.println(arr1[1]);
//响应结果：
99
Process finished with exit code 0
注意：如果某个数组变量存储的地址是null，那么该变量将不再指向任何数组对象
arr2 = null; //把Null赋值给arr2
System.out.println(arr2); //null
System.out.println(arr2[0]); //会出异常
System.out.println(arr2.length); //会出异常
//响应结果
null
Exception in thread "main" java.lang.NullPointerException
at ArrayDemo7.main(ArrayDemo7.java:15)
Process finished with exit code 1
java.lang.NullPointerException空指针异常
代码量：5000行（入门） 20000行（工作）
专项训练： 数组常见案例
1.数组求最值
定义一个数组（静态），定义一个变量用于记录最终的最大值（建议存储数组的第一个元素值作为参照）
public static void main(String[] args) {
int[] faceScores = new int[]{15, 900, 1000, 2000, 950, -5};
int max = faceScores[0];
int num = 0;
for (int i = 0; i < faceScores.length; i++) {
if (faceScores[i] > max) {
max = faceScores[i];
num = i;
}
}
System.out.println("第" + num + "位分数最高，分数为：" + max);
}
//响应结果
第3位分数最高，分数为：2000
Process finished with exit code 0
2.数组反转
某个数组有5个数据：10，20，30，40，50，请将这个数组中的数据进行反转。
[10,20,30,40,50] 反转后 [50,40,30,20,10]
分析：数组的反转操作实际上就是依次前后交换数据
//单指针
public static void main(String[] args) {
//数组反转
int[] arr = new int[]{10,20,30,40,50};
int temp = 0;
for (int i = 0; i < arr.length/2; i++) {
temp = arr[arr.length-(i+1)];
arr[arr.length-(i+1)] = arr[i];
arr[i] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//响应结果：
50
40
30
20
10
Process finished with exit code 0
//双指针
public static void main(String[] args) {
//数组反转
int[] arr = new int[]{10, 20, 30, 40, 50};
int temp = 0;
for (int i = 0, j = arr.length - 1; i < j; i++,j--) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//响应结果：
50
40
30
20
10
Process finished with exit code 0
3.随机排名
某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随即排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
分析：在程序中录入5名员工的工号存储起来（使用动态初始化数组的方式）；依次遍历数组中的每个数据；每遍历到一个数据，都随机一个索引值出来，让当前数据与该索引位置处的数据进行交换。
public static void main(String[] args) {
//随机排名
int[] codes = new int[5];
int temp = 0;
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;
}
Random r = new Random();
for (int i = 0; i < codes.length; i++) {
int index = r.nextInt(codes.length);
temp = codes[index];
codes[index] = codes[i];
codes[i] = temp;
}
for (int i = 0; i < codes.length; i++) {
System.out.println(codes[i]);
}
}
tip：随机
Random r = new Random();
int index = r.nextInt(codes.length);
tip：输入
Scanner sc = new Scanner(System.in);
int code = sc.nextInt();
codes[i] = code;
Debug工具的使用
IDEA自带的断点调试工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
方法
方法的定义
方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用
修饰符 返回值类型 方法名（形参列表）{
方法体代码（需要执行的功能代码）
return 返回值；
}
public class MethodDemo1 {
public static void main(String[] args) {
int rs = sum(10, 20);
System.out.println(rs);
}
public static int sum(int a, int b) {
int c = a+b;
return c;
}
}
//响应结果：
30
Process finished with exit code 0
方法如何执行：方法定义后，必须调用才可以跑起来，调用格式：方法名(…);
注意：
-
方法的修饰符：暂时都用public static修饰。
-
方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。
-
形参列表可以有很多个，甚至可以没有；如果有多个形参必须用”,“隔开，且不能给初始化值。
//无参数，无返回值的方法
public class MethodDemo1 {
public static void main(String[] args) {
printHello();
System.out.println("==============");
printHello();
}
//无参数，无返回值的方法
public static void printHello(){
for (int i = 0; i < 3; i++) {
System.out.println("Hello World");
}
}
}
//响应结果：
Hello World
Hello World
Hello World
==============
Hello World
Hello World
Hello World
Process finished with exit code 0
//有参数，无返回值的方法
public class MethodDemo1 {
public static void main(String[] args) {
printHello(2);
}
//有参数，无返回值的方法
public static void printHello(int n){
for (int i = 0; i < n; i++) {
System.out.println("Hello World");
}
}
}
//响应结果：
Hello World
Hello World
Process finished with exit code 0
注意：
- 如果方法不需要返回结果，返回值类型必须声明成
void()，此时方法内部不可以使用return返回数据。 - 方法如果不需要接收数据，则不需要定义形参，且调用方法时也不可以传数据给方法了。
- 没有参数，且没有返回值类型（void）申明的方法，称为无参数、无返回值的方法，以此类推。
方法使用时的常见问题
-
方法在类中的位置放前放后无所谓，但一个方法不能定义在另一个方法里面。
-
方法的返回值类型写**void（无返回申明)**时，方法内不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
-
return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。
-
方法不调用就不会执行，调用方法时，传给方法的数据，必须严格匹配方法的参数情况。
-
调用有返回值的方法，有3种方式：1、可以定义变量接收结果 2、或者直接输出调用 3、甚至直接调用；
//1 int rs = sum(10,20); System.out.println(rs); //2 System.out.println(sum(1,2)); //3 sum(3,4); -
调用无返回值的方法，只有1种方式：1、只能直接调用。
printHello();
方法的案例
设计方法的技巧，主要关注三个方面：
- 方法是否需要接收数据进行处理？
- 方法是否需要返回数据？
- 方法要处理的业务？
一、求1-n的和
import java.util.Scanner;
public class MethodDemo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
int rs = add(score);
System.out.println(rs);
}
public static int add(int n){
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
return sum;
}
}
//响应结果：
3
6
Process finished with exit code 0
二、判断一个整数是奇数还是偶数，并把判断的结果输出出来
public class MethodDemo3 {
public static void main(String[] args) {
ifodd(7);
}
public static void ifodd(int a) {
if (a % 2 == 0) {
System.out.println("输入的" + a + "是偶数");
} else {
System.out.println("输入的" + a + "是奇数");
}
}
}
//响应结果：
输入的7是奇数
Process finished with exit code 0
方法在计算机中的执行原理
- 方法被调用的时候，是进入到栈内存中运行。 栈
-方法为什么要在栈中运行自己？
保证一个方法调用完另一个方法后，可以回来
java的参数传递机制
基本类型的参数传递
java的参数传递机制都是：值传递
- 所谓的值传递：指的是在传递实参给方法的形参时，传输的是实参变量中存储的值的副本。
实参：在方法内部定义的变量。
形参：定义方法时 “(…)” 中声明的参数
public class MethodDemo4 {
public static void main(String[] args) {
int a = 10;
change(a); //这步执行完之后，从栈中出去了，所以下一行里a还是10
System.out.println("main:" + a); //10
}
public static void change(int a) {
System.out.println("change1:" + a); //10
a = 20;
System.out.println("change2:" + a); //20
}
}
//响应结果：
change1:10
change2:20
main:10
Process finished with exit code 0
引用类型的参数传递
public class MethodDemo5 {
public static void main(String[] args) {
int[] arrs = new int[]{10, 20,30};
change(arrs);
System.out.println("main：" + arrs[1]);
}
public static void change(int[] arrs){
System.out.println("方法内1：" + arrs[1]);
arrs[1] = 222;
System.out.println("方法内2：" + arrs[1]);
}
}
//响应结果：
方法内1：20
方法内2：222
main：222 //因为数组传递的是地址变量
Process finished with exit code 0
基本类型和引用类型的参数在传递的时候有什么不同？
- 都是值传递
- 基本类型的参数传输存储的是数据值
- 引用类型的参数传递存储的是地址值
参数传递的案例
引用类型参数传递的相关案例（数组的传递）
案例一：打印int类型的数组内容
需求：输出一个int类型的数组内容，要求输出的格式为：[11,22,33,44,55]
分析：
-
方法是否需要接收数据进行处理？
需要接收一个int类型的数组，因此形参声明为：int[] arr
-
方法是否需要返回数据？
方法内部直接输出数组内容即可，无需返回，因此返回值类型声明为：void
-
方法内部的业务？
遍历数组，并输出相应的内容
public class MethodDemo6 {
public static void main(String[] args) {
int[] arr = new int[]{11, 22, 33};
printArray(arr);
int[] arr2 = null;
printArray(arr2);
}
public static void printArray(int[] arr) {
if (arr == null) {
System.out.println(arr); //null
return; //跳出当前方法（break只能跳出循环，不能跳出方法，方法执行到return会结束方法）
} else {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
// if (i == arr.length-1){
// System.out.print(arr[i]);
// }else {
// System.out.print(arr[i] + ",");
// }
//优化：
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ",");
}
System.out.println("]");
}
}
}
//响应结果：
[11,22,33]
Process finished with exit code 0
案例二：比较两个int类型的数组是否一样
需求：如果两个int类型的数组，元素个数，元素顺序和内容是一样的，我们就认为这两个数组是一模一样的
-
方法是否需要接收数据进行处理？
需要接收2个int类型的数组，因此形参声明为：int[] arr1，int[] arr2
-
方法是否需要返回数据？
方法判断完后需要返回：true, false，因此返回值类型声明为boolean类型
-
方法内部的业务？
判断两个数组内容是否一样
public class MethodDemo7 {
public static void main(String[] args) {
int[] arr1 = null;
int[] arr2 = null;
System.out.println(equals(arr1, arr2));
int[] arr11 = null;
int[] arr22 = {10,20,30};
System.out.println(equals(arr11, arr22));
int[] arr111 = {10,20,30,40};
int[] arr222 = {10,20,30};
System.out.println(equals(arr111, arr222));
int[] arr1111 = {10,20,31};
int[] arr2222 = {10,20,30};
System.out.println(equals(arr1111, arr2222));
int[] arr11111 = {10,20,30};
int[] arr22222 = {10,20,30};
System.out.println(equals(arr11111, arr22222));
}
public static boolean equals(int[] arr1, int[] arr2) {
//1.判断arr1和arr2是否都是null
if (arr1 == null && arr2 == null) {
return true;
}
//2.判断arr1是null，或者arr2是null
if (arr1 == null || arr2 == null) {
return false;
}
//3.判断2个数组的长度是否一样，如果长度不一样，直接返回false
if (arr1.length != arr2.length) {
return false;
}
//4.两个数组的长度是一样的，接着比较它们的内容是否一样
for (int i = 0; i < arr1.length; i++) {
//判断当前位置2个数组的元素是否不一样，不一样直接返回false
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
}
//响应结果：
true
false
false
false
true
Process finished with exit code 0
👆注意这个方法里层层筛的思想！！！
方法重载
方法重载：同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法称为方法重载。
public class MethodOverload {
public static void main(String[] args) {
test();
test1(100);
}
public static void test(){
System.out.println("===test1===");
}
public static void test1(int a){
System.out.println("===test2====" + a);
}
}
//响应结果：
===test1===
===test2====100
Process finished with exit code 0
注意事项：
- 一个类中，只要一些方法的名称相同、形参列表不同，那么他们就是方法重载了，其他的都不管（如：修饰符，返回值类型是否一样都无所谓）
- 形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称
方法重载的应用场景：
开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
例如：开发武器系统，功能需求如下：
①可以默认发一枚武器 ②可以指定地区发射一枚武器 ③可以指定地区发射多枚武器
public class MethodDemo8 {
public static void main(String[] args) {
fire();
fire("Am");
fire("Am", 5);
}
public static void fire(){
System.out.println("发射一枚武器");
}
public static void fire(String country){
System.out.println("向" + country + "发射一枚武器");
}
public static void fire(String country, int num){
System.out.println("向" + country + "发射"+ num + "枚武器");
}
}
//响应结果：
发射一枚武器
向Am发射一枚武器
向Am发射5枚武器
Process finished with exit code 0
单独使用return关键字
return; 可以用在无返回值的方法中，作用是：立即跳出并结束当前方法的执行。
public class MethodDemo9 {
public static void main(String[] args) {
System.out.println("程序开始");
division(10,0);
System.out.println("程序结束");
}
public static void division(int a, int b){
if (b == 0){
System.out.println("您输入的分母为0");
return;
}
System.out.println("结果为：" + a/b);
}
}
//响应结果：
程序开始
您输入的分母为0
程序结束
Process finished with exit code 0
注意：
return; 跳出并立即结束所在方法的执行。
break; 跳出并结束当前所在循环的执行。
continue; 结束当前所在循环的当此继续，进入下一次执行。
扫一扫
1095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
