Java学习-详述main方法、可变参数、数组的工具类、二维数组

详述main方法

【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口

【2】main方法格式严格要求：

public static void main(String\[\] args){}

public static --->修饰符，暂时用这个 -->面向对象一章

void --->代表方法没有返回值对应的类型void

main --->见名知意名字

String\[\] args --->形参 ---》不确定因素

【3】问题：程序中是否可以有其他的方法也叫main方法？

可以，构成了方法的重载。

public class TestArray10{
public static void main(String\[\] args){
}
public static void main(String str){
}
}

【4】形参为String\[\] 那么实参到底是什么？

public class TestArray10{
public static void main(String\[\] args){
//从侧面验证：
//int\[\] arr1; //如果对数组只声明，没有后续操作，那么相当于白定义了。
//int\[\] arr2 = null;
//System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException
//int\[\] arr3 = new int $0$ ;
//System.out.println(arr3.length);
//int\[\] arr4 = new int $4$ ;
//System.out.println(arr4.length);
//System.out.println(args.length);//0
//从这个结果证明，参数是String\[\],实参是 new String $0$
//默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组
System.out.println(args.length);
for(String str:args){
System.out.println(str);
}
}
}

手动传入实参：

有特殊符号的时候可以加上""

没有特殊符号用空格隔开即可：

可变参数

public class TestArray12{
/*
1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
int...num
double...num
boolean...num
2.可变参数在JDK1.5之后加入的新特性
3.方法的内部对可变参数的处理跟数组是一样
4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
5.我们自己在写代码的时候，建议不要使用可变参数。
*/
public static void main(String\[\] args){
//method01(10);
//method01();
//method01(20,30,40);
method01(30,40,50,60,70);
//method01(new int\[\]{11,22,33,44});
}
public static void method01(int num2,int...num){
System.out.println("-----1");
for(int i:num){
System.out.print(i+"\t");
}
System.out.println();
System.out.println(num2);
}
}

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

import java.util.Arrays;
public class TestArray13{
public static void main(String\[\] args){
//给定一个数组：
int\[\] arr = {1,3,7,2,4,8};
//toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
System.out.println(Arrays.toString(arr));
//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
//这个方法的使用前提：一定要查看的是一个有序的数组：
//sort：排序 -->升序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.binarySearch(arr,4));
int\[\] arr2 = {1,3,7,2,4,8};
//copyOf:完成数组的复制：
int\[\] newArr = Arrays.copyOf(arr2,4);
System.out.println(Arrays.toString(newArr));
//copyOfRange:区间复制：
int\[\] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
System.out.println(Arrays.toString(newArr2));
//equals:比较两个数组的值是否一样：
int\[\] arr3 = {1,3,7,2,4,8};
int\[\] arr4 = {1,3,7,2,4,8};
System.out.println(Arrays.equals(arr3,arr4));//true
System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
//fill：数组的填充：
int\[\] arr5 = {1,3,7,2,4,8};
Arrays.fill(arr5,10);
System.out.println(Arrays.toString(arr5));
}
}

数组的复制操作

原理：

代码：

import java.util.Arrays;
public class TestArray14{
public static void main(String\[\] args){
//给一个源数组：
int\[\] srcArr = {11,22,33,44,55,66,77,88};
//给一个目标数组：
int\[\] destArr = new int $10$ ;
//复制：
System.arraycopy(srcArr,1,destArr,3,3);
//遍历查看目标数组：
System.out.println(Arrays.toString(destArr));
}
}

结果：

二维数组

【1】引入：本质上全部都是一维数组：

【2】基本代码：

public class TestArray15{
public static void main(String\[\] args){
//定义一个二维数组：
int\[\]\[\] arr = new int $3$ \[\];//本质上定义了一个一维数组，长度为3
int\[\] a1 = {1,2,3};
arr $0$ = a1;
arr $1$ = new int\[\]{4,5,6,7};
arr $2$ = new int\[\]{9,10};
}
}

对应内存：

【3】四种遍历方式：

public class TestArray15{
public static void main(String\[\] args){
//定义一个二维数组：
int\[\]\[\] arr = new int $3$ \[\];//本质上定义了一个一维数组，长度为3
int\[\] a1 = {1,2,3};
arr $0$ = a1;
arr $1$ = new int\[\]{4,5,6,7};
arr $2$ = new int\[\]{9,10};
//读取6这个元素：
//System.out.println(arr $1$ $2$ );
//对二维数组遍历：
//方式1：外层普通for循环+内层普通for循环：
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr $i$ .length;j++){
System.out.print(arr $i$ $j$ +"\t");
}
System.out.println();
}
//方式2：外层普通for循环+内层增强for循环：
for(int i=0;i<arr.length;i++){
for(int num:arr $i$ ){
System.out.print(num+"\t");
}
System.out.println();
}
//方式3：外层增强for循环+内层增强for循环：
for(int\[\] a:arr){
for(int num:a){
System.out.print(num+"\t");
}
System.out.println();
}
//方式4：外层增强for循环+内层普通for循环：
for(int\[\] a:arr){
for(int i=0;i<a.length;i++){
System.out.print(a $i$ +"\t");
}
System.out.println();
}
}
}

二维数组的初始化方式

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:

int\[\]\[\] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

int\[\]\[\] arr =new int\[\]\[\] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

eg:

int\[\]\[\] arr = new int $3$ \[\]; //本质上定义了一维数组长度为3，每个"格子"中放入的是一个数组

arr $0$ = new int\[\]{1,2};

arr $1$ = new int\[\]{3,4,5,6};

arr $2$ = new int\[\]{34,45,56};

eg:

int\[\]\[\] arr = new int $3$ $2$ ;

|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| public class TestArray16{ public static void main(String\[\] args){ int\[\]\[\] arr = new int $3$ $2$ ; //本质上：定义一维数组，长度为3，每个数组"格子"中，有一个默认的长度为2的数组： arr $1$ = new int\[\]{1,2,3,4}; //数组遍历： for(int\[\] a:arr){ for(int num:a){ System.out.print(num+"\t"); } System.out.println(); } } } |

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。