java基础数组

IT萌新@

已于 2023-07-07 13:57:33 修改

阅读量79

点赞数

分类专栏： java基础文章标签： java jvm 算法

于 2023-04-22 17:23:05 首次发布

本文链接：https://blog.csdn.net/m0_49102053/article/details/130307562

版权

java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

今日内容

零、复习昨日
一、作业
二、数组

零、复习昨日

1 方法的返回值类型都能写成什么?
基本类型,String,void

2 方法需要返回值时用什么关键字?
return 值;
执行到return,该方法就结束不再执行

3 方法能被谁调用?
方法能被其他方法调用.
但是最后要想执行方法,必须最后再main内调用

4 什么时候需要方法?
a. 将某部分功能单独抽取封装成方法
b. 编写代码时好看,复用
c.

5 总结
以后写作业,处理一个功能,写题要养成习惯,下意识先创建方法,由方法处理事情

一、作业

经验: 当循环次数已知用for最合适,当循环次数未知用while最合适

/*写一个方法将一个整数逆序打印
		int a = 3456;
		输出:6543
13456 % 10 = 6
13456 / 10 % 10 = 5
13456 / 10 /10 % 10 = 4
13456 / 10/10/10 % 10 = 3
13456 / 10/10/10/10 % 10 = 1*/
int ge = n % 10; 
System.out.print(ge);
while(n / 10 != 0){
	int num = n /10 %10;
    System.out.print(num);
	n = n / 10;
}

设计程序,实现简易计算器
欢迎使用>>> 计算器 <<<
可选功能有
1: 加
2: 减
3: 乘
4: 除
0: 退出
请选择功能按键: 1
请输入第一个数: 230
请输入第二个数: 320
230 + 320 的结果是: 550 
请选择功能按键: 2

	// 计算器
	public static void jsq() {
		Scanner scanner = new Scanner(System.in);
		System.out.println("欢迎使用>>> 计算器 <<<");
		while(true) {
			System.out.println("可选功能有\r\n" + 
					"1: 加\r\n" + 
					"2: 减\r\n" + 
					"3: 乘\r\n" + 
					"4: 除\r\n" + 
					"0: 退出");
			System.out.println("请选择:");
			int key = scanner.nextInt();
			if (key == 1) {
				System.out.print("请输入第一个数:");
				double a = scanner.nextDouble();
				System.out.print("请输入第二个数:");
				double b = scanner.nextDouble();
				// 调用方法
				double he = jia(a,b);
				System.out.println(a + " + " + b +" = " + he);
			} else if (key == 2) {
				// 执行减法
				System.out.print("请输入第一个数:");
				double a = scanner.nextDouble();
				System.out.print("请输入第二个数:");
				double b = scanner.nextDouble();
				// 调用方法
				double cha = jian(a,b);
				System.out.println(a + " - " + b +" = " + cha);
			} else if (key == 3) {
				// 乘法
			} else if (key == 4) {
				// 除法
			} else if (key == 0) {
				// 退出
				System.out.println(">>> 结束使用 <<<");
				// 方案一,return可以结束方法
				// return; 
				
				// 方案二 (系统退出方法,0是正常退出的意思)
				System.exit(0);
			} else {
				System.out.println("按键有误!");
			}
			System.out.println("--------- 本次计算结束  --------");
		}
		
	}
	// 加法
	public static double jia(double a,double b) {
		return a + b;
	}
	
	// 减法
	public static double jian(double a,double b) {
		return a - b;
	}

二、数组

2.1 为什么需要数组

考虑问题1：存储一个人的考试成绩， double score = 100；

考虑问题2：存储60个人的成绩，用60个变量存储!!!？？？？ 数组更合适

2.2 数组是什么

数组相对于是容器，可以装载（存储）多个数据。

使用特点：

数组一旦创建，容量（长度）固定
数组一旦创建，存储的数据的类型固定

内存空间的特点：

ps: 程序在jvm中运行,java程序运行需要耗费电脑内存空间.

数组的内存空间特点:

是在堆中创建
是连续空间
每个空间位置有下标(索引)

2.3 数组的使用

数组使用: 1声明,2创建,3存取数据

2.3.1 数组声明

数据类型[] 数组名;

int[] arr;

ps: 特殊的,有人这么写数据类型数组名[]; 也对,但是不推荐

2.3.2 数组创建

数组名 = 数据类型[长度];

arr = int[3];

要求: 后面数据类型要与声明数据类型一致

2.3.3 使用数组

使用数组就只会存取.

取值:
数据类型变量 = 数组名[下标];

要求: 下标从0开始,最大到长度-1 , 接收的变量的数据类型要和数组类型一致

赋值:
数组名[下标] = 值;

要求: 下标从0开始,最大到长度-1 , 值的数据类型要和数组类型一致

	public static void main(String[] args) {
		// 1 声明数组
		int[] arr1;
		// 也行,不推荐
		int arr2[];
		
		// 2 创建数组
		// 数组名 = new 数据类型[长度];
		// 前后数据类型要一致
		arr1 = new int[3];
		
		// 一般会声明创建同时写
		int[] arr3 = new int[3];
		
		// 3 使用数组
		// 3.1 取值
		// 数据类型 变量名 = 数组名[下标];
		// 下标是从0至长度-1 (超过就会报错!!!!! 数组下标越界!!!)
		int i1 = arr3[0];
		int i2 = arr3[1];
		int i3 = arr3[2];
		System.out.println("数组的第一个元素:" + i1);
		System.out.println("数组的第二个元素:" + i2);
		System.out.println("数组的第三个元素:" + i3);
		
		// -----------------------------------
		// double数组
		double[] arr4 = new double[3];
		double d1 = arr4[0];
		double d2 = arr4[1];
		double d3 = arr4[2];
		System.out.println("数组的第一个元素:" + d1);
		System.out.println("数组的第二个元素:" + d2);
		System.out.println("数组的第三个元素:" + d3);
		
		// -----------------------------------
		// char的数组
		char[] arr5 = new char[3];
		char ch1 = arr5[0];
		char ch2 = arr5[1];
		char ch3 = arr5[2];
		System.out.println("数组的第一个元素:" + ch1);
		System.out.println("数组的第二个元素:" + ch2);
		System.out.println("数组的第三个元素:" + ch3);
		
		// -----------------------------------
		// String的数组
		String[] arr6 = new String[3];
		String s1 = arr6[0];
		String s2 = arr6[1];
		String s3 = arr6[2];
		System.out.println("数组的第一个元素:" + s1);
		System.out.println("数组的第二个元素:" + s2);
		System.out.println("数组的第三个元素:" + s3);
		
		// 3.2 存值
	    // 数组名[下标] = 值;	
		arr3[0] = 11;
		arr3[1] = 22;
		arr3[2] = 33;
		// 再次取出查看效果
		System.out.println("赋值后再取出:");
		System.out.println(arr3[0]);
		System.out.println(arr3[1]);
		System.out.println(arr3[2]);
		
	}

	// 整型数组,默认存储0
	// 浮点型数组,默认存储0.0
	// 字符数组,默认存储' '
	// 布尔型数组,默认 false
	// String数组,默认是null

数组的细节总结:

数组中的每⼀个数据称之为数组元素
数组中的每⼀个元素都对应有⼀个下标
数组中的下标范围0~数组的长度-1
数组的长度通过数组名.length获取
数组的长度如果超出的边界会报错（ArrayIndexOutOfBoundsException数组下标越界异常）

2.4 数组的内存图

方法执行会进栈

凡是new的,都会在堆中开启空间

new int[3];这行代码做了什么?

会在堆中开辟连续空间
且给空间设置下标,0-长度-1
且给每个空间赋默认初始值
给这个空间设置了内存地址

int[] arr = new int[3]; 赋值给arr的是什么? arr其实是数组在内存的地址
System.out.print(arr);// 输出内存地址

int a = arr[0]; 这行代码做了什么?

通过arr,arr本后是数组的地址,即通过地址找到数组
arr[0],找到数组中下标为0的那个准确位置
将值取出赋值给前面的变量a

arr[0] = 11; // 这行代码干了啥?

通过arr背后的地址找到数组
通过[0] 找到对应下标位置
= 11,给这个位置直接覆盖值为11
以后这个位置就是11,除非再次修改

2.5 数组的静态初始化

之前使用 int[] arr = new int[3]; 这种方法就是动态初始化数组.

何为动态? 这样创建出的数组,值是默认值,会随着程序运行,动态赋值.即先指定长度,后来再赋值

静态初始化,就是提前确定(提前指定)数据,不指定长度,这样就是静态初始化.
int[] arr = new int[]{44,55,66};
静态初始化是指定数据,不指定长度,长度会自动计算(有length属性)

	public static void main(String[] args) {
		// 静态初始化
		int[] arr = new int[] {44,55,66};
		
		// 有属性自动计算长度
		int length = arr.length;
		System.out.println("数组长度: " + length);
		
		// 一样的取值
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		
		// 一样的赋值
		arr[0] = 40;
		arr[1] = 50;
		arr[2] = 60;
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}

静态初始化的简化格式:
数据类型[] 数组名 = {值1,值2,值3,…};
int[] arr = {1,2,3,4,5};

		// 简化格式
		double[] arr2 = {1.0,2.0,3.0,4};
		String[] arr3 = {"a","b","c"};
		int[] arr4 = {1,2,3,4};

2.6 数组的遍历

遍历: 一个一个的找到数组的元素.

// 遍历输出每个数组的元素

	public static void main(String[] args) {
		int[] arr = {6,5,2,4,1,7,3};
		
		// 遍历输出
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
	}

三、数组的应用

1、从键盘录入五个名字到数组中，遍历数组输出这五个名字


import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        
    }
    
    public static void printName() {
        Scanner scanner = new Scanner(System.in);
        
        // 定义一个数组,用于存储名字
        String[] names = new String[5];
        
        // 循环重复输入人名
        for(int i = 1;i <= 5;i++){
            System.out.print("请输入第"+i+"人的名字");
            String name = scanner.nextLine();
            
            // 人名存储入数组
            arr[i - 1] = name;
        }
       
        // 遍历数组
        for (int i = 0;i < names.length;i++){
            System.out.print(names[i]);
        }
    }
}

2、给定一个数组，求数组的最大值

public static int getMax(){
    // 给定数组
    int[] arr = {4,2,3,1,6,5};
    
    // 假设第一个数最大
    int max = arr[0];
    for(int i = 0;i < arr.length;i++){
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

3、给定一个数组，求数组的最小值

略

4、给定一个数组，求数组的平均值

public static void getAvg(){
	int[] arr = {4,2,3,1,6,5};
    // 平均数: 累加和/个数
    int sum = 0;
    for(int i = 0;i < arr.length;i++){
		sum += arr[i];
    }
    
    // 平均数
    double avg = sum * 1.0 / arr.length;
     System.out.print("平均数: " + avg);
}

5、给定一个数组，传入一个数字，如果在数组中存在这个数字，返回这个数字在数组中的下标，否则返回-1 (根据数据找下标)

   public static void main(String[] args) {
    	int index = getIndexByElement(2);
    	if(index != -1) {
    		System.out.println("你找到元素存在,下标 : " + index);
    	} else {
    		System.out.println("你找到元素在数组中不存在");
    	}
    }
    
    public static int getIndexByElement(int n) {
    	int[] arr = {4,2,3,1,5};
    	// 遍历,判断是否相等
    	for (int i = 0; i < arr.length; i++) {
			if (n == arr[i]) {
				return i;
			}
		}
        // -1是判断依据,因为下标是从0开始,不可能是-1
        // 一旦返回-1就意味着没找到
    	return -1;
    }

四、总结

数组: 声明,创建,使用

创建2种方案
长度已知就使用动态创建
数据已知就使用静态创建
使用2种
存值
取值

重点!!! 数组的内存图会画

重点!!! 遍历

} else {
		System.out.println("你找到元素在数组中不存在");
	}
}

public static int getIndexByElement(int n) {
	int[] arr = {4,2,3,1,5};
	// 遍历,判断是否相等
	for (int i = 0; i < arr.length; i++) {
		if (n == arr[i]) {
			return i;
		}
	}
    // -1是判断依据,因为下标是从0开始,不可能是-1
    // 一旦返回-1就意味着没找到
	return -1;
}


# 四、总结

> 数组: 声明,创建,使用
>
> 创建2种方案
> 	长度已知就使用动态创建
>    数据已知就使用静态创建
> 使用2种
> 	存值
> 	取值
>
> 重点!!!! 数组的内存图会画
>
> 重点!!!! 遍历
>
> 应用搞熟练,自己加注释