Java快速入门之数组、方法

简介: ### Java快速入门之数组与方法简介#### 一、数组数组是一种容器,用于存储同种数据类型的多个值。定义数组时需指定数据类型,如`int[]`只能存储整数。数组的初始化分为静态和动态两种:- **静态初始化**:直接指定元素,系统自动计算长度,如`int[] arr = {1, 2, 3};`- **动态初始化**:手动指定长度,系统给定默认值,如`int[] arr = new int[3];`数组访问通过索引完成,索引从0开始,最大索引为`数组.length - 1`。遍历数组常用`for`循环。常见操作包括求和、找最值、统计特定条件元素等。

Java快速入门之数组、方法
一、数组
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、方法概述
方法是程序中最小的执行单元
• 注意:
o 方法创建在类中。
o 方法必须先创建才可以使用,创建方法的过程成为方法定义。
o 方法创建后并不是直接可以运行的,需要手动使用后,才执行,该过程成为方法调用。
2、方法的定义和调用
2.1 无参数方法定义和调用

2.2 无参数方法的练习
• 需求:设计一个方法用于打印两个数中的较大数
• 思路:
o ①定义一个方法,用于打印两个数字中的较大数,例如getMax()
o ②方法中定义两个变量,用于保存两个数字
o ③使用分支语句分两种情况对两个数字的大小关系进行处理
o ④在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 带参数方法练习
• 需求:设计一个方法用于打印两个数中的较大数,数据来自于方法参数 }
• 思路:
o ①定义一个方法,用于打印两个数字中的较大数,例如getMax()
o ②为方法定义两个参数,用于接收两个数字
o ③使用分支语句分两种情况对两个数字的大小关系进行处理
o ④在main()方法中调用定义好的方法(使用常量)
o ⑤在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、方法的注意事项
• 方法不能嵌套定义
o 错误示例:
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方法/
//方法体
}
}

o 方法重载练习
• 需求:使用方法重载的思想,设计比较两个整数是否相同的方法,兼容全整数类型(byte,short,int,long)
• 思路:
o ①定义比较两个数字的是否相同的方法compare()方法,参数选择两个int型参数
o ②定义对应的重载方法,变更对应的参数类型,参数变更为两个long型参数
o ③定义所有的重载方法,两个byte类型与两个short类型参数
o ④完成方法的调用,测试运行结果
• 代码:
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;
}

}

相关文章
|
6天前
|
Java
Java快速入门之判断与循环
本文介绍了编程中的流程控制语句,主要包括顺序结构、判断结构(if语句和switch语句)以及循环结构(for、while和do...while)。通过这些语句可以精确控制程序的执行流程。if语句有三种格式,分别用于简单条件判断、二选一判断和多条件判断。switch语句适用于有限个离散值的选择判断,而循环结构则用于重复执行某段代码,其中for循环适合已知次数的情况,while循环适合未知次数但有明确结束条件的情况,do...while则是先执行后判断。文中还提供了多个示例和练习,帮助读者理解并掌握这些重要的编程概念。
|
2月前
|
消息中间件 Java Kafka
在Java中实现分布式事务的常用框架和方法
总之,选择合适的分布式事务框架和方法需要综合考虑业务需求、性能、复杂度等因素。不同的框架和方法都有其特点和适用场景,需要根据具体情况进行评估和选择。同时,随着技术的不断发展,分布式事务的解决方案也在不断更新和完善,以更好地满足业务的需求。你还可以进一步深入研究和了解这些框架和方法,以便在实际应用中更好地实现分布式事务管理。
|
2月前
|
Java
java小工具util系列5:java文件相关操作工具,包括读取服务器路径下文件,删除文件及子文件,删除文件夹等方法
java小工具util系列5:java文件相关操作工具,包括读取服务器路径下文件,删除文件及子文件,删除文件夹等方法
100 9
|
1天前
|
存储 Java 索引
Java基础(六):数组
Java基础(六):数组
Java基础(六):数组
|
2月前
|
安全 Java 开发者
Java中WAIT和NOTIFY方法必须在同步块中调用的原因
在Java多线程编程中,`wait()`和`notify()`方法是实现线程间协作的关键。这两个方法必须在同步块或同步方法中调用,这一要求背后有着深刻的原因。本文将深入探讨为什么`wait()`和`notify()`方法必须在同步块中调用,以及这一机制如何确保线程安全和避免死锁。
59 4
|
2月前
|
Java
深入探讨Java中的中断机制:INTERRUPTED和ISINTERRUPTED方法详解
在Java多线程编程中,中断机制是协调线程行为的重要手段。了解和正确使用中断机制对于编写高效、可靠的并发程序至关重要。本文将深入探讨Java中的`Thread.interrupted()`和`Thread.isInterrupted()`方法的区别及其应用场景。
82 4
|
2月前
|
Java 数据处理 数据安全/隐私保护
Java处理数据接口方法
Java处理数据接口方法
32 1
|
3月前
|
Java API
Java 对象释放与 finalize 方法
关于 Java 对象释放的疑惑解答,以及 finalize 方法的相关知识。
73 17
|
2月前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解(社招面试不踩坑)
本文介绍了Java中`Object`类的几个重要方法,包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点,掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景,详细解析了每个方法的作用和重写技巧,帮助读者更好地应对面试和技术开发。
148 4
|
2月前
|
Java 测试技术 Maven
Java一分钟之-PowerMock:静态方法与私有方法测试
通过本文的详细介绍,您可以使用PowerMock轻松地测试Java代码中的静态方法和私有方法。PowerMock通过扩展Mockito,提供了强大的功能,帮助开发者在复杂的测试场景中保持高效和准确的单元测试。希望本文对您的Java单元测试有所帮助。
446 2