文章目录
数组
数组的定义与访问
静态初始化数组
定义数组时直接给数组赋值
//正常版本
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; 结束当前所在循环的当此继续,进入下一次执行。