3.17 Java基础 第三天
数组
数组的概念
数组是指一组数据的集合，数组中的每个数据被称作元素。
在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。
数组定义格式
数据类型[] 数组名 = new 数据类型[数组的长度];
示例代码：
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组的长度];
int[] arr = new int[5]; //该数组可以存储五个 int类型的数据
/*
左边:
int:数据类型
[]：表示数组，几个中括号就代表几维数组（后续讲）
arr：合法的标识符、变量名
右边:
new：创建新的实体或对象
int：数据类型
[]：表示数组
5：表示数组的长度（给定几个空间存东西）
*/
}
数组的初始化和赋值
初始化和默认值
初始化就是为数组开辟连续的内存空间，并为每个数组元素赋值
初始化分为动态初始化和静态初始化
- 动态初始化：只指定长度，由系统给出初始化值
int[] arr = new int [5]- 静态初始化：给出初始化值
数据类型[] 数组名 = new 数据类型[]{元素 1,元素 2,元素3};
代码示例：默认初始化
/*
默认初始化值：
整数类型：byte,short,int,long默认初始化值都是 0
浮点类型：float,double默认初始化值都是 0.0
布尔类型：boolean默认初始化值 false
字符类型：char默认初始化值'\u0000'
*/
class Demo {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[5]; //动态初始化,在内存中开辟连续
的 5块空间
System.out.println(arr[0]); //系统给出默认初始化值,整数类
型的都是 0
arr[0] = 10;
System.out.println(arr[0]);
System.out.println(arr); //[I@56bc3aa
//默认值是 0.0
float[] arr2 = new float[10];
System.out.println(arr2[0]);
//String s = "李四";//字符串
// String 引用类型，默认值是 null
String[] arr3 = new String[10];
System.out.println(arr3[0]);
//boolean 默认值是 false
boolean[] arr4 = new boolean[10];
System.out.println(arr4[0]);
char[] arr5 = new char[10];
System.out.println(arr5[0]);
}
}
代码示例：静态初始化
/**
* 数组初始化方式二
* 静态初始化：给出初始化值
*/
public class Demo04 {
public static void main(String[] args) {
// 0 1 2 3 下标
int[] arr1 = new int[]{1,2,3,4};
System.out.println(arr1[2]);
//String 类型的数组
String[] arr2 = new String[]{"李四","王五"};
System.out.println(arr2[0]);
System.out.println(arr2[1]);
}
}
数组赋值
数组中使用下标取值
如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值
赋值语法：
arr[0]=1 给arr数组的第 0个位置赋值为 1
示例代码
public class ArrayDemo02 {
public static void main(String[] args) {
int[] arr = new int[4]; // 定义可以存储 4个整数的数组
arr[0] = 1; // 为第 1个元素赋值 1
arr[1] = 2; // 为第 2个元素赋值 2
// 下面的代码是打印数组中每个元素的值
System.out.println("arr[0]=" + arr[0]);
System.out.println("arr[1]=" + arr[1]);
System.out.println("arr[2]=" + arr[2]);
System.out.println("arr[3]=" + arr[3]);
}
}
数组的常见操作
数组遍历
使用for循环获取数组的值，通常使用.length()方法获得数组的长度
public class Demo {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
// 使用 for循环遍历数组的元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素
}
}
数组取最值
在操作数组时，经常需要获取数组中元素的最值（最大、最小）
思路步骤：
1. 首先假设数组中第一个元素 arr[0]为最大值
2. 后使用 for 循环对数组进行遍历并比较比 max 值还大的元素，并赋值给 max，此时
max就能够在循环结束时记住数组中的最大值。
示例代码
public class ArrayDemo05 {
public static void main(String[] args) {
int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量 max用于记住最大数，并假设第一个元素为最
大值
// 下面通过一个 for循环遍历数组中的元素
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) { // 比较 arr[x]的值是否大于 max
max = arr[x]; // 条件成立，将 arr[x]的值赋给max
}
}
System.out.println("max=" + max); // 打印最大值
}
}
注意：在 for循环中的变量 i是从 1开始的，原因是程序已经假设第一个元素为最大值
数组排序
冒泡排序
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的
元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
排序算法还有：选择排序等
冒泡排序示例代码：
public static void main(String[] args) {
int[] numbers = new int[] { 5, 7, 3, 8, 5, 11 };
int temp = 0;
int size = numbers.length;
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - 1 - i; j++) {
if (numbers[j] > numbers[j + 1]) // 交换两数位置
{
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
}
}
}
// 打印排序结果
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + " ");
}
}
多维数组
多维数组可以简单地理解为在数组中嵌套数组，常见的就是二维数组
二维数组的定义
二维数组的定义方式一
int[][] arr = new int[3][4]
上面的代码相当于定义了一个 3*4 的二维数组，即二维数组的长度为 3，二维数组中的每
个元素又是一个长度为 4的数组。
示例代码：
class Demo1 {
public static void main(String[] args) {
int[][] arr = new int[3][4];
System.out.println(arr); // 二维数组
System.out.println(arr[0]); // 二维数组中的第一个一维数组，打印的是内
存地址
System.out.println(arr[0][0]); // 二维数组中的第一个一维数组的第一个
元素
}
}
二维数组的定义方式二
int[][] arr = new int[3][]
第二种方式和第一种类似，只是数组中每个元素的长度不确定
示例代码：
//只是数组中每个元素的长度不确定并且没有赋初始值，取到的是 null
//赋值后取到的是数组的内存地址
class Demo2 {
public static void main(String[] args) {
int[][] arr = new int[3][];//这是一个二维数组,这个二维数组中有三个一
维数组,三个一维数组都没有被赋值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("------------------");
arr[0] = new int[3]; //第一个一维数组中可以存储三个int值
arr[1] = new int[5]; //第二个一维数组中可以存储五个int值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
二维数组的定义方式二
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}
上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}
示例代码
class Demo4_Array {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; //这是一个二维数组,这个二
维数组中每个大括号都代表一个一维数组
System.out.println(arr); //[[I@xxxxx，二维数组的地址值
System.out.println(arr[0]); //[I@xxxx，一维数组的地址值
System.out.println(arr[0][0]); //1,一维数组中的元素值
}
}
二维数组赋值、遍历方式与一维数组类似。
二维数组赋值
public class Demo15 {
public static void main(String[] args) {
int[][] arr = new int[3][4];
//arr[0] 是一个数组
arr[0][0] = 10;
arr[2][1] = 100;
System.out.println("arr[0][0]:"+arr[0][0]);
System.out.println("arr[2][1]:"+arr[2][1]);
}
}
二维数组遍历
class Demo1 {
public static void main(String[] args) {
int[][] arr = {{ 1, 2, 3 }, { 4, 5 }, { 6, 7, 8, 9 } };
for (int i = 0; i < arr.length; i++) { // 获取到每个二维数组中的一维数组
for (int j = 0; j < arr[i].length; j++) { // 获取每个一维数组中的元素
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
方法
方法的语法格式
在 Ja 中，声明一个方法的具体语法格式如下
修饰符 返回值类型 方法名(参数类型 参数名 1,参数类型 参数名 2,．．．．．．){
执行语句（方法体）
………
return 返回值;
}
方法格式解释
修饰符：后面会详细介绍。目前记住：public static
返回值类型：用于限定返回值的数据类型
方法名一个名称：为了方便我们调用方法
参数类型：限定调用方法时传入参数的数据类型
参数名：是一个变量，接收调用方法时传入的参数
方法体：完成功能的代码
return：结束方法以及返回方法指定类型的值，返回结果给调用者
示例代码
//求两个数的和
public static int sum1(int a, int b){
int sum = (a + b);
//System.out.println("和是："+ sum);
return sum;
}
参数传递（形参和实参）
参数传递，可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，在方法中就可以使用该值进行相应的运算了。这种传递方式，我们称为参数传递
形参和实参
在定义方法时，参数列表中的变量，我们称为形式参数
调用方法时，传入给方法的数值，我们称为实际参数
代码示例：编写求和方法，并调用，观察形参和实参
class Demo {
public static void main(String[] args) {
int sum = sum(3, 5); // 调用方法时，传入的数值称为实际参数
System.out.println(sum);
}
public static void sum(int a, int b){// 方法中指定的多个参数称为形式参数
int sum = (a + b);
System.out.println("和是："+ sum);
}
}
方法的注意事项
- 方法不调用不执行
- 方法与方法是平级关系，不能嵌套定义
- 方法定义的时候参数之间用逗号隔开
- 方法调用的时候不用在传递数据类型
- 如果方法有明确的返回值，一定要有 return 带回一个值
方法重载
在同一个类中，存在一个以上的同名方法，只要它们的参数个数或者参数类型（形参列表）不同即可。
方法重载的特点
与返回值类型无关，只看方法名和参数列表
示例代码：在类里面定义多个计算和的方法，方法名一致，但是方法参数列表不一致
class Test3_Overload {
// main 的方法
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
int e = 40;
sum(a,b);
sum(a,b,c);
sum(a,b,c,d);
//调用不同参数类型的重载方法
sum(15.5,15.5);
}
/**
* 计算两个参数和
*/
public static void sum(int a, int b) {
int sum = (a + b);
System.out.println("和是：" + sum);
}
/**
* 计算三个参数和
*/
public static void sum(int a, int b, int c) {
int sum = (a + b + c);
System.out.println("和是：" + sum);
}
/**
* 计算四个参数和
*/
public static void sum(int a, int b, int c, int d) {
int sum = (a + b + c + d);
System.out.println("1和是：" + sum);
}
//方法参数类型不同，也称为重载
public static void sum(double a, double b) {
double sum = (a + b);
System.out.println("和是：" + sum);
}
}
可变参数方法
在 JDK5 中提供了变长参数(varargs），也就是在方法定义中可以使用个数不确定的参数，对于同一方法可以使用不同个数的参数调用
例如上面的例子：sum(a,b)、sum(a,b,c);、sum(a,b,c,d);
在具有可变长参数的方法中可以把参数当成数组使用，例如可以循环输出所有的参数值
示例代码，关注 sum方法即可
class Test3_Overload {
// main 的方法
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
int e = 40;
sum(a,b);
sum(a,b,c);
sum(a,b,c,d);
}
/**
* 可以定义任意参数长度的方法
*/
public static void sum(int... a) {// a 可以当做是一个数组来使用
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
}
System.out.println("和是："+sum);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
