详述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(); } } } |
- 默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
