Java学习第九天（一维数组练习，二维数组，main方法中String[]args详解，可变参数，Arrays工具类的使用）

约定不等于承诺〃 2021-12-18 06:59 77阅读 0赞

## 一维数组的练习： ##

import java.util.*;
    public class TestSys{
    	public static void main(String[]args){
    		int[]arr=new int[5];		
    		while(true){
    		System.out.println("-----------欢迎来到数字管理系统-----");
    		System.out.println("请输入选择的功能");
    		System.out.println("1:键盘录入5个数存入数组");
    		System.out.println("2：查询系统最大的那个数字");
    		System.out.println("3:查询正数的个数");
    		System.out.println("4：删除指定数");
    		System.out.println("5：退出");
    		Scanner sc=new Scanner(System.in);
    			int choose=sc.nextInt();
    			switch(choose){
    				case 1:Cun(arr);break;
    				case 2:Max(arr);break;
    				case 3:Num(arr);break;
    				case 4:Del(arr);break;
    				case 5:System.out.println("退出");return;
    			}
    		}
    
    	}
    	
    	//1:键盘录入5个数存入数组"
    	public static void Cun(int[]a){
    		for(int i=0;i<5;i++){
    			System.out.println("请输入"+(i+1)+"个数字,这些数字存入数组中");
    			Scanner sc2=new Scanner(System.in);
    			int num=sc2.nextInt();
    			a[i]=num;
    		}
    		System.out.println("您输入的数组为： "+Arrays.toString(a));	
    		return;
    	}
    	
    	//2：查询系统最大的那个数字
    	public static void Max(int[]a){
    		int max=0;
    		int index=a[0];
    		for(int i=0;i<=a.length-1;i++){
    			if(max<=a[i]){
    				max=a[i];
    				index=i;
    			}
    		}
    		System.out.println("这个数组遍历一边为： "+Arrays.toString(a));
    		System.out.println("最大的数是： "+max+" 它的索引是： "+index);
    		
    	}
    	
    	//3:查询正数的个数
    	public static void Num(int[]a){
    		int count=0;
    		for(int i=0;i<a.length;i++){
    			if(a[i]>0){
    				count++;
    			}
    		}
    		System.out.println("正数的个数是： "+count);
    	}
    
        // 4：删除指定数
        public static void Del(int[]a){
    		System.out.println("删除前这个数组变成为 ： "+Arrays.toString(a));		
    		System.out.println("请删除指定数：");
    		Scanner sc4=new Scanner(System.in);
    		int num=sc4.nextInt();
    		int flag=-1;
    		for(int i=0;i<=a.length-1;i++){
    			if(num==a[i]&&i!=a.length-1){
    				flag=1;
    				a[i]=a[i+1];
    			}else if(num==a[i]&&i==a.length-1){
    				flag=1;
    				a[a.length-1]=0;				
    			}
    		}
    		if(flag>0){
    			a[a.length-1]=0;
    		}else{
    			System.out.println("查无次数");
    		}
    		System.out.println("删除后这个数组变成为 ： "+Arrays.toString(a));
    
    	}
    
    
    
    	
    }

## main方法的解析： ##

【1】main方法：类中一个比较特殊的一个方法：在类中假如有多个方法的话，优先走这个方法---》程序的入口--》主方法---》main方法

【2】main方法格式固定：  
public static void main(String\[\] args)\{

public static -->修饰符    
void--->方法返回值类型---》证明main方法没有返回值  
main--->见名知意的方法名

public class TestMain{
            //程序的入口-->main方法
            public static void main(String[] a){//String[] a=new Sting[0]
                    //String[] str;//只声明没赋值，相当于白写。
                    
                    
                    //String[] str2=null;//str2会在栈中开辟空间，里面存的是null（没有堆中的指向）
                    //System.out.println(str2.length);
                    //空指针异常：Exception in thread "main" java.lang.NullPointerException
                    
                    //String[] str3=new String[0];//开辟了一个数组，长度为0
                    //System.out.println(str3.length);//0
                    
                    System.out.println(a.length);
                    
                    
            }
            //普通方法：只是恰好名字也叫main，跟上面的那个方法构成了：方法的重载（方法名相同，形参列表不同就重载）
            public static void main(String b){
                    
            }
    }

## 可变参数： ##

在方法重载的时候，我们可以写多个同名但是形参不同的方法，我们可以使用一个可变参数的方法，一次性搞定方法

public class TestMain{ 
    /*
    1.可变参数：格式：int...arr  double...arr   String...arr
    2.可变参数在JDK1.5以后才有的 
    3.我们学习了可变参数之后，没非得要求你写代码这样写，主要别人写（源码）你能看懂即可。
    4.可变参数：作用：帮助我们解决了部分重载的问题
    5.可变参数可接受的参数个数：0,1,2，。。n个，数组
    6.可变参数内部当做：数组来处理。
    */
            public static void main(String[] args){
                    add(10,20);
                    add();
                    add(10);
                    add(10,20,30);
                    add(new int[]{10,20,30,40,50});
                    add(1.9,4.6);
                    
            }
            public static void add(int...arr){
                    System.out.println("执行add方法,传入的参数为：");
                    for(int a:arr){
                            System.out.println(a);
                    }
            }
    }

public class TestMain{ 
    /*
    7.可变参数和其它类型一起作为形参的时候，可变参数必须放在最后。
    */
            public static void main(String[] args){	
                    add(10,20,30);	
            }
            public static void add(int num,int...arr){
                    System.out.println("执行add方法,传入的参数为：");
                    for(int a:arr){
                            System.out.println(a);
                    }
                    
                    System.out.println(num);
            }
    }

## 【1】Arrays：数组的工具类，专门操作数组。   【2】常用方法： ##

## 数组遍历： Arrays.toString(数组); ##

int[]a=new int[]{1,2,3,4,5};
    		System.out.println("数组的遍历为: "+Arrays.toString(a));

![20190702205749163.png][]

## 数组的排序: Arrays.sort(数组); ##

int[]a=new int[]{1,2,9,4,3};
    		Arrays.sort(a);//数组的排序
    		System.out.println("数组的遍历为: "+Arrays.toString(a));

![20190702205932616.png][]

## 二分法查找：Arrays.binarySearch(a,b); ##

查看API![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70][]

第一个填入的:是指定类型数组

第二个填入的:是查找某个数组元素

查询出来的是第二个元素对应的索引值。

int[]a=new int[]{1,2,3,4,5,7};
    		Arrays.sort(a);//数组的排序
    		System.out.println(Arrays.binarySearch(a,4));
    		System.out.println("数组的遍历为: "+Arrays.toString(a));

![20190702211023210.png][]

## 复制数组元素：Arrays.copyOf(A,B); ##

第一个元素： 需要复制的数组名称

第二个元素：新的数组的长度，如果小于原来的，就按顺序走，没走完就不要了。要是大于原来的数组长度，那么后面的都为0

（我此时给的新的长度大于原来的数组长度，所以此时后面的应该全都是0）

int[]a=new int[]{1,2,3,4,5,7};
    		Arrays.sort(a);//数组的排序
    		int[]arr=Arrays.copyOf(a,16);
    		System.out.println("数组的遍历为: "+Arrays.toString(arr));

![20190702211459174.png][]

## 区间复制：Arrays.copyOfRange(A,B,C)； ##

第一个A：数组

B：需要开始截取的元素索引值

C：结束元素的索引值。

\[B~C) 包含B  但是不包含C

如果C是大于数组长度，则 后面用0代替

int[]a=new int[]{1,2,3,4,5,7};
    		Arrays.sort(a);//数组的排序
    		int[]arr=Arrays.copyOfRange(a,0,3);
    		System.out.println("数组的遍历为: "+Arrays.toString(arr));

![2019070221230644.png][]

int[]a=new int[]{1,2,3,4,5,7};
    		Arrays.sort(a);//数组的排序
    		int[]arr=Arrays.copyOfRange(a,0,10);
    		System.out.println("数组的遍历为: "+Arrays.toString(arr));

![20190702212338796.png][]

## 数组的填充：   Arrays.fill(数组，填充的数字); ##

int[]a=new int[]{1,2,3,4,5,7};
    		Arrays.sort(a);//数组的排序
    		Arrays.fill(a,10);
    		System.out.println("数组的遍历为: "+Arrays.toString(a));

![20190702212644521.png][]

## 数组的复制： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 1][]

## 二维数组： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 2][]

## 二维数组的初始化： ##

public class TestMain{ 
            public static void main(String[] args){	
                    //方式1：---》动态初始化
                    //int[][] arr=new int[3][];//定义一个数组长度为3，每个里面放的数组长度 不确定。
                    
                    
                    //方式2：---》动态初始化
                    int[][] arr=new int[3][4];//定义一个长度为3的数组，每个格子里面放的数组长度为4.
                    
                    arr[0]=new int[]{1,2};
                    
                    
                    for(int i=0;i<=arr.length-1;i++){
                                    //arr[i]就是二维数组中的每一个小的那个数组。再对arr[i]这个数组再遍历。
                                    for(int j=0;j<=arr[i].length-1;j++){
                                                    System.out.println(arr[i][j]);
                                    }
                    }
                    
                    //方式3：--->静态初始化
                    int[][] arr3={
       {1,2},{34,45,67,78},{324,34,45,456}};
            }
    }

[20190702205749163.png]: /images/20211218/3071177cfd5c4911bf86b03678591879.png
[20190702205932616.png]: /images/20211218/4a728f99a58442bd995f9a8062e306b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70]: /images/20211218/cdce768835ad4786a0205d480f0960aa.png
[20190702211023210.png]: /images/20211218/85f1713631c94c6f8e660d3676ba2ce9.png
[20190702211459174.png]: /images/20211218/b70e005221ed42919587dd2a218cdf04.png
[2019070221230644.png]: /images/20211218/f9a5a48cc4b146218595233c0a04bd7e.png
[20190702212338796.png]: /images/20211218/1de042ab22a045debe499a8bbb30cde8.png
[20190702212644521.png]: /images/20211218/58275dfcb31c4f7488f8c0bc91a2d3ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 1]: /images/20211218/da5541a40e9d40cba20c2f3e85f48956.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 2]: /images/20211218/da9188a91c894b0aaf5644d394b3bd3d.png