当前位置：首页 > article >正文

Java快速入门之数组、方法

article 2025/2/28 15:42:44

一、数组

1、数组的概念：

数组指的是一种容器，可以用来存储同种数据类型的多个值，但是数组容器在存储数据的时候，需要结合隐式转换考虑。

例如：

定义了一个int类型的数组，那么boolean、double类型的数据是不能存到这个数组中的，但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。

建议：

容器的类，和存储的数据类型保持一致。

举例：

2、数组的定义

格式一：

格式二：

注意点：

方法括号跟数组名，谁写在前面，谁写在后面都是一样的。

平时习惯性使用第一种方式。

3、数组的静态初始化

完整格式：

数据类型：限定了数组以后能存什么类型的数据。

方括号：表示现在定义的是一个数组。

数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。

new：就是给数组在内存中开辟了一个空间。

数据类型：限定了数组以后能存什么类型的数据。前面和后面的数据类型一定要保持一致。

错误写法如下：

方括号：表示现在定义的是一个数组。

大括号：表示数组里面的元素。元素也就是存入到数组中的数据。多个元素之间，一定要用逗号隔开。

注意点：

等号前后的数据类型必须保持一致。
数组一旦创建之后，长度不能发生变化。

简化格式:

练习1：

定义数组存储5个学生的年龄。

//分析如下：
1.给数组限定什么类型？ 年龄是整数所以决定使用int类型
2.利用静态初始化完成创建并添加元素
//答案一
int[] agesArr = new int[]{18,19,20,21,22};
//答案二
int[] agesArr = {18,19,20,21,22};

练习2：

定义数组存储3个学生的姓名。

//分析如下：
1.给数组限定什么类型？ 学生姓名所以觉得使用String
2.利用静态初始化完成创建并添加元素
//答案一
String[] namesArr = new String[]{"zhangsan","lisi","wangwu"};
//答案二
String[] namesArr = {"zhangsan","lisi","wangwu"};

练习3：

定义数组存储4个学生的身高。

//分析如下
1.给数组限定什么类型？ 身高所以使用double
2.利用静态初始化完成创建并添加元素
//答案一
double[] heightsArr = new double[]{1.85,1.82,1.78,1.65};
//答案二
double[] heightsArr = {1.85,1.82,1.78,1.65};

4、数组的动态初始化

格式：

数组的默认初始化值：

整数类型int：0

小数类型float、double：0.0

布尔类型boolean：false

字符类型string：‘’

引用类型：null

5、地址值

打印数组的时候，实际出现的是数组的地址值。注意：

数组的地址值：就表示数组在内存中的位置。（十六进制的）

地址值对于我们来说，作用不大，简单了解。

6、数组元素访问

格式：

作用：

获取数组中对应索引上的值

一旦修改之后，原来的值就会被覆盖了。

代码示例：

public class ArrayTest {
    /*
        数组中元素访问的格式：
                数组名[索引];
         作用：
            1.获取指定索引上对应的元素
            2.修改指定索引上对应的元素
    */
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5};
       //需求1：获取arr数组中，3索引上的值
        int number = arr[3];
        System.out.println(number); //4
        System.out.println(arr[3]); //4
       //需求2：将arr数组中，3索引上的值修改为10
            arr[3] = 10;
        System.out.println("修改之后为:" + arr[3]); //10
    }
}

6、索引

简称：角标、下标，就是数组容器中每一个小格子对应的编号。

索引的特点：

索引一定是从0开始的。
连续不间断。
逐个+1增长。

7、数组的遍历

遍历：就是把数组里面所有的内容一个一个全部取出来。

数组的长度：数组名.length;

通用代码：

idea中快速创建数组遍历的方法：数组名.fori

9.数组两种初始化方式的区别

静态初始化：int[] arr = {1,2,3,4,5};

手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。

动态初始化：int[] arr = new int[3];

动态初始化：手动指定数组长度，由系统给出默认初始化值。

使用场景：

只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。

已经明确了要操作的所有数据，推荐使用静态初始化。

//例一：使用数组来存储键盘录入的5个整数。
int[] arr = new int[5];
//例二：将全班的学生成绩存入数组中，已知学生成绩为：66,77,88,99,100
int[] arr = new int[5];
arr[0] = 66;
arr[1] = 77;
//例二虽然可以实现，但是太麻烦了。
//建议使用静态初始化：
int[] arr = {66,77,88,99,100};

10.数组常见问题

索引越界异常ArrayIndexOutOfBoundsException

当访问了数组中不存在的索引，就会引发索引越界异常。

避免：

针对于任意一个数组，索引的范围：最小索引：0 最大索引：数组的长度 - 1 数组名.length - 1

11.数组的练习

练习1：求和

需求：定义一个数组，存储1,2,3,4,5

遍历数组得到每一个元素，求数组里面所有的数据和

代码如下：

/*定义一个数组，存储1,2,3,4,5
        遍历数组得到每一个元素，求数组里面所有的数据和*/
//1.定义一个数组，并添加数据1,2,3,4,5
int[] arrary = {1,2,3,4,5};
//求和变量
int sum = 0;
//2.遍历数组得到每一个数据，累加求和
for (int i = 0; i < arrary.length; i++) {
    //i 依次表示数组里面的每一个索引
    //arrary[i] 依次表示数组里面的每一个元素
    sum = sum + arrary[i];
}

//当循环结束之后，sum的值就是累加之后的结果
System.out.println(sum);

练习2：求最值

需求：求数组中的最大值

代码示例：

//定义数组求最大值：33,5,22,44,55
//1.定义数组用来存储5个值
int[] arr = {33,5,22,44,55};
//2.定义一个变量max用来存储最大值
//临时认为0索引的数据是最大的
int max = arr[0];
//3.循环获取数组中的每一个元素
//拿着每一个元素跟max进行比较
for (int i = 1; i < arr.length; i++) {
    //i 索引  arr[i] 元素
    if(arr[i] > max){
        max = arr[i];
    }
}
//4.当循环结束之后，max记录的就是数组中的最大值
System.out.println(max);//55

练习3：统计个数

需求：定义一个数组，存储1,2,3,4,5,6,7,8,9,10

遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字

代码示例：

//分析：
//1.定义一个数组 存储1,2,3,4,5,6,7,8,9,10
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//定义一个变量，用来统计次数
int count = 0;
//2.遍历数组得到每一个元素
for (int i = 0; i < arr.length; i++) {
    //i 表示数组里面的每一个索引
    //arr[i] 表示数组里面的每一个元素
    //3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
    if(arr[i] % 3 == 0){
        // System.out.println(arr[i]);
        count++;
    }
}
//当循环结束之后，就表示数组里面所有的数字都判断完毕了，直接打印count即可
System.out.println("数组中能被3整除的数字有" + count + "个");

练习4：变化数据

需求：

定义一个数组，存储1,2,3,4,5,6,7,8,9,10

遍历数组得到每一个元素。

要求：

1，如果是奇数，则将当前数字扩大两倍

2，如果是偶数，则将当前数字变成二分之一

代码示例：

//分析：
//1.定义一个数组，存1,2,3,4,5,6,7,8,9,10
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//2.遍历数组得到每一个元素
for (int i = 0; i < arr.length; i++) {
    //i 依次表示数组里面的每一个索引
    //arr[i] 依次表示数组里面的每一个元素
    //3.对每一个元素进行判断
    if(arr[i] % 2 == 0){
        //偶数 变成二分之一
        arr[i] = arr[i] / 2;
    }else{
        //奇数 扩大两倍
        arr[i] = arr[i] * 2;
    }
}

//遍历数组
//一个循环尽量只做一件事情。
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

练习5：交换数据

需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。

交换前：1,2,3,4,5

交换后：5,2,3,4,1

代码示例：

//1.定义数组存储数据
int[] arr = {1,2,3,4,5};
//2.利用循环去交换数据
for(int i = 0,j = arr.length - 1; i < j; i++,j--){
    //交换变量i和变量j指向的元素
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
//当循环结束之后，那么数组中的数据就实现了头尾交换
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

二、方法

1、方法概述

方法是程序中最小的执行单元

注意：
- 方法创建在类中。
- 方法必须先创建才可以使用，创建方法的过程成为方法定义。
- 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用。

2、方法的定义和调用

2.1 无参数方法定义和调用

2.2 无参数方法的练习

需求：设计一个方法用于打印两个数中的较大数
思路：
- ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
- ②方法中定义两个变量，用于保存两个数字
- ③使用分支语句分两种情况对两个数字的大小关系进行处理
- ④在main()方法中调用定义好的方法
代码：

public class Test {
    public static void main(String[] args) {
        //调用getMax方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数，名为getMax()
    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

3、带参数方法定义和调用

3.1 带参数方法定义和调用

3.2 形参和实参

形参：方法定义中的参数

等同于变量定义格式，例如：int number

实参：方法调用中的参数

等同于使用变量或常量，例如： 10 number

具体如图所示：

3.3 带参数方法练习

需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数 }
思路：
- ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
- ②为方法定义两个参数，用于接收两个数字
- ③使用分支语句分两种情况对两个数字的大小关系进行处理
- ④在main()方法中调用定义好的方法（使用常量）
- ⑤在main()方法中调用定义好的方法（使用变量）
代码：

public class Test {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用常量）
        getMax(10,20);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的

        //在main()方法中调用定义好的方法（使用变量）
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    //为方法定义两个参数，用于接收两个数字
    public static void getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

4、带返回值方法的定义和调用

4.1 带返回值方法定义和调用

4.2 带返回值方法练习

需求：

定义一个方法，求一家商场每个季度的营业额。根据方法结果再计算出全年营业额。

代码示例：

public class Test {
    public static void main(String[] args) {
        /*需求：定义一个方法，求一家商场每个季度的营业额。
        根据方法结果再计算出全年营业额。*/
        int sum1 = getSum(10, 20, 30);
        int sum2 = getSum(10, 20, 30);
        int sum3 = getSum(10, 20, 30);
        int sum4 = getSum(10, 20, 30);

        int sum = sum1 + sum2 + sum3 + sum4;
        System.out.println(sum);

    }
    
    public static int getSum(int month1,int month2,int month3){
        int sum = month1 + month2 + month3;
        //因为方法的调用处，需要继续使用这个结果
        //所以我们必须要把sum返回
        return sum;
    }
}

5、方法的注意事项

方法不能嵌套定义
- 错误示例：

public class MethodDemo {
    public static void main(String[] args) {

    }

    public static void methodOne() {
		public static void methodTwo() {
       		// 这里会引发编译错误!!!
    	}
    }
}

void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

6、方法重载

概念

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

1、多个方法在同一个类中

2、多个方法具有相同的方法名

3、多个方法的参数不相同，类型不同或者数量不同

正确示范：

public class Test {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}

public class Test {
	public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}

错误示范：

public class Test {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { 	/*错误原因：重载与返回值无关*/
    	//方法体
    }
}

public class Test01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class Test02 {
    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
        //方法体
    }
}

- _<font style="color:rgb(51, 51, 51);">方法重载练习</font>_

需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
思路：
- ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
- ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
- ③定义所有的重载方法，两个byte类型与两个short类型参数
- ④完成方法的调用，测试运行结果
代码：

public class Test {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }

}

查看全文

http://www.kler.cn/a/514375.html

磁盘与库之间的结构关系

C# OpenCvSharp 部署读光-票证检测矫正模型（cv_resnet18_card_correction）

T-SQL语言的数据结构

Spring Boot 中高并发场景下的数据一致性问题与解决方案

第四部分：Linux编辑器vim

Swift语言的数据结构

在现有 Docker Desktop 环境下安装与配置独立 Kubernetes环境（Mac)

MySQL的备份还原

[深度学习]多层神经网络

图片专栏——概念

管道符、重定向与环境变量

LeetCode：3097. 或值至少为 K 的最短子数组 II（滑动窗口 Java）

element UI的日期选择器固定日期变色

GD32F303 GCC 环境搭建

2025展望：“安全计算”平价时代加速到来，数据流通产业兴起

期权懂|你了解场内期权和场外期权的区别吗？

Windows 服务程序实现鼠标模拟

【头歌】Scrapy爬虫（二）热门网站数据爬取

【Vim Masterclass 笔记22】S09L40 + L41：同步练习11：Vim 的配置与 vimrc 文件的相关操作（含点评课内容）

【2024 博客之星评选】请继续保持Passion

一、数组

1、数组的概念：

2、数组的定义

格式一：

格式二：

注意点：

3、数组的静态初始化

完整格式：

注意点：

简化格式:

练习1：

练习2：

练习3：

4、数组的动态初始化

格式：

数组的默认初始化值：

5、地址值

6、数组元素访问

格式：

作用：

代码示例：

6、索引

索引的特点：

7、数组的遍历

9.数组两种初始化方式的区别

10.数组常见问题

11.数组的练习

练习1：求和

练习2：求最值

练习3：统计个数

练习4：变化数据

练习5：交换数据

二、方法

1、方法概述

2、方法的定义和调用

2.1 无参数方法定义和调用

2.2 无参数方法的练习

3、带参数方法定义和调用

3.1 带参数方法定义和调用

3.2 形参和实参

3.3 带参数方法练习

4、 带返回值方法的定义和调用

4.1 带返回值方法定义和调用

4.2 带返回值方法练习

5、方法的注意事项

6、 方法重载

相关文章：

4、带返回值方法的定义和调用

6、方法重载