java 命令行参数、随机数Math.random的用法及使用误区、Array.sort()的用法、Arrays类中的方法

前面已经看到多个使用java数组的示例。每一个Java应用程序都有一个带String [] args参数的main方法。这个参数表明main方法将接受一个字符串数组，也就是命令行参数。

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       //命令行参数
        /* 前面已经看到多个使用java数组的示例，每个java应用程序都有一个带String args[]参数的main方法。这个参数表明main方法将接受一个字符串数组String[] 也就是命令行参数

        */
        if(args[0].equals("h"))
            System.out.println("Hello");
        else if(args[0].equals("g"))
            System.out.println("google");
        for(int i=1;i<args.length;++i)
            System.out.println(args[i]);
    }          
}

如果使用下面这种形式运行下列程序：
java 第3章a hello，boy
数组排序
想对数值型数组进行排序，可以使用Arrays类中的sort方法

使用Arrays类中的sort方法，需要:
import java.util.Arrays;
或者：
import java.util.*;
简述Arrays类中的sort方法：
**sort**
public static void sort(long[] a)
对指定的 long 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法。
**sort**
public static void sort(long[] a , int fromIndex , int toIndex)

对指定 long 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）

数组的初始化方法

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {

       int[] a={1,2,3,4,5};  //第一种初始化方法：同C语言
       int [] b=new int[5];  //第二种初始化方法：先声明，后初始化
       b=new int[] {1,3,5,2,9};
     //  a=new int[] {1,3,2,9,8};   //
       Arrays.sort(a);
       System.out.println(Arrays.toString(b));  //不是Arrays.toString[a],而是Arrays. toString(a);使用Arrays.toString需要import java.util.*;
    }          
}

数组的初始化方法，使用原有的C语言初始方法最方便：
int[] a={1,2,4,5,6};

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {

        int[] a={1,2,4,5,6};  //使用这种！同C语言，只是由int A[]={1,2,3,4,5}，变为了int[] B={1,2,3,4,5}
        int[] b=new int[] {1,2,3,4,5,5};
        int[] c;
        c=new int[] {1,2,3,4,5,8};
     //  a=new int[] {1,3,2,9,8};   //
       Arrays.sort(a);
       System.out.println("b= "+Arrays.toString(b));  //不是Arrays.toString[a],而是Arrays. toString(a);使用Arrays.toString需要import java.util.*;
       System.out.println("a= "+Arrays.toString(a)); 
       System.out.println("c="+Arrays.toString(c)); 
    }          
}

随机数Math.random的用法，有注意事项：
不是int r=(int)(Math.random()）*n;
而是 random*n后整体强制转化

package 第3章;
import java.util.*;
import java.Math.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       //Scanner 属于import java.util.Scanner;,可以为import java.util.*;
        Scanner in=new Scanner(System.in);
        System.out.println("how many numbers you need to select?");
        int k=in.nextInt();
        System.out.println("how many numbers you  select from?");
        int n=in.nextInt();
        int[] number=new int[n];
        int[] result=new int[k];
        for(int i=0;i<number.length;++i)
        {
            number[i]=i+1;
        }
        for(int j=0;j<k;++j)
        {
            int r=(int)(Math.random()*n); //注意，不是int r=(int)(Math.random()）*n;而是 random*n后整体强制转化为（int），否则随机生成的数有问题
            result[j]=number[r];
            number[r]=number[n-1];
            --n;
        }
        Arrays.sort(result);  //Arrays.sort(数组)返回void，也就是修改参数数组,但是不返回数组
                              //所以Arrays.sort不能用int[] hello=Arrays.sort(result); 因为Array不返回数组

        System.out.println(Arrays.toString(result));
    }          
}

Arrays类中的方法

Arrays类属于java.util.*;
/*
        static String toString(type[] a)   //a为int char boolean类型的数组
        static type   copyOf(type[] a,int length) //a为int char boolean类型的数组
        static type   copyOfRange(type[] a,int start,int end)  //有范围的复制，不包括end，a为int char boolean类型的数组
        static void sort(type[] a)  //a为int char boolean类型的数组
        static int binarySearch(type[] a,type v)  //a为int char boolean类型的数组
        static int binarySearch(type[] a,int start,int end,type v)  //a为int char boolean类型的数组,查找成功，返回位置，查找不成功，返回一个负数值 
        static void fill(type[] a,type v)  //a为int char boolean类型的数组
        static boolean equals(type[] a,type[] b)  //a为int char boolean类型的数组,如果a与b完全相同，返回true，否则，返回false
        总结：Arrays类中的所有方法都可以对int double char boolean操作
             Arrays类方法常用的有 toString copyOf copyOfRange sort binarySearch 有范围的binarySearch fill equals  */

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       /* 多维数组使用多个下标来访问数组元素，他适用于表示表格或者更复杂的排列形式
        在java中，声明二维数组：

        */
        double [][] a;
        a=new double[A][B];
        //第二种方法
        double[][] b={ 
            {1,2},
            {3,5},
            {2,6}
        };
        //一旦数组被初始化，就可以利用两个方括号访问每一个元组，例如：b[0][0]
        for(int i=0;i<a[0].length;++i)   //访问第0行中的每一个元素
        {
            a[0][i]=1000;
        }  
        for(int j=1;j<a[0].length;++j)
        {

        }
        //for each 循环语句遍历二维数组
        for(double[] row:a)
        {
            for(double[] value:row)
            {
                //
            }
        }
        //如果想快速打印一个二维数组的数据元素列表，可以调用Arrays类的deepToString方法，import java.util.*;
        System.out.println(Arrays.deepToString(a));
    }          
}