Java基础知识2

Java小结2

Java方法详解

1、写一个简单的比较两个数中最大值的方法：

public class Demo01 {
    //main 方法
    public static void main(String[] args) {

          int max = max(10,10)   ;
        System.out.println(max);

    }
	//max()方法，用来比较两个数的最大值
    public static int max(int a ,int b){
        int result = 0;
        if (a>b){
            result = a;
        }
        else if (a==b){
            System.out.println("两个数相等");
            return 0;
        }
        else{
            result = b;
        }
        return result;
    }
}

2、方法的重载：

• 方法的名称必须相同
• 方法的列表必须不同(个数不同，类型不同，参数排列顺序不同等)
• 方法的返回类型可以相同可以不同
• 仅仅返回类型不同不能重载

3、可变参数：

- 方法中的参数是一个数组

public class Demo02 {
    public static void main(String[] args) {
        //输出最大值为67.0
        printMax(1,2,3,45,66,67);
        //输出最大值为3.0
        printMax(new double[]{1,2,3});
    }
	//定义可变参数的方法，求最大值
    public static void printMax(double... numbers){
        if(numbers.length==0){
            System.out.println("错误");
        }
        double result = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if(numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("最大值是"+result);
    }
}

4、递归的应用：

• 自己调用自己
• 递归包括递归头和递归体两个部分
• 基数较小可以用，大计算尽量不要用，影响性能

public class Demo03 {
    public static void main(String[] args) {
        //测试5！
        System.out.println(test(5));
    }
    //递归调用，用来计算n！
    public static int test(int n ){
        if (n==1){
            return 1;
        }else{
            return n*test(n-1);
        }
    }
}

数组的应用

1、数组的声明与创建：

int[]  array ;//声明数组
array = new int[10];//创建数组

2、数组的使用

• 遍历数组
• 打印数组
• 反转数组

public class Demo02 {
    public static void main(String[] args) {
        int [] arrays = {1,2,3,4,5};
        //打印数组
        printArray(arrays);
        printArray(reverse(arrays));
    }
    //反转数组
    public static int[] reverse(int [] arrays) {
        int [] result = new int[arrays.length];
        for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {
            result[j]=arrays[i];
        }
        return result;
    }
    //输出数组
    public static void printArray(int [] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

3、多维数组

定义：数组的每一项又是一个数组，即数组嵌套数组

//定义二维数组
int [][] arrays = {{1,2},{3,4},{5,6}}

二维数组的使用：

public class Demo03 {
    public static void main(String[] args) {
        //定义二维数组
        int [][] array = {{1,2},{3,4},{5,6}};
        printArray(array);
    }
    //打印二维数组
    public static void printArray(int [][] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }
}

4、Arrays类的详解

public class Demo04 {
    public static void main(String[] args) {
        //定义一个数组
        int[] array = {5,2,7,9,13,56,3,75,1,4};
        //利用Arrays类打印数组
        System.out.println(Arrays.toString(array));
        //利用Arrays给数组排序
        Arrays.sort(array);
        //再次利用Arrays类打印数组
        System.out.println(Arrays.toString(array));
    }

}

5、冒泡排序

• 比较数组中，两个相邻的元素，如果第一个比第二个打，就交换位置
• 每一次比较都能找出一个最大或最小的数
• 下一轮少排序依次
• 依次循环，直到结束

public class Demo05 {
    public static void main(String[] args) {
        int [] array = {23,45,71,25,17,90,34,2,6,789};
        int [] sort=sort(array);
        System.out.println(Arrays.toString(sort));
    }
    //冒泡排序
    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
        //利用双重循环来升序排序
        for (int i = 0; i <array.length-1 ; i++) {
            for (int j = 0; j < array.length-1-i ; j++) {
                if (array[j]>array[j+1]){
                    temp=array[j];
                    array[i]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
}

6、稀疏数组

定义:有的数组重复的数据比较多，或者都是0的时候，我们采用稀疏数组，节省空间。

public class Demo06 {
    public static void main(String[] args) {

        //创建一个原始数组  11*11  0:没有棋子  1:黑棋  2:白棋
        int [][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");

        for (int[] ints:array1) {
            for (int anInt:ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=================");

        //1.获取有效值
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j <11 ; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效个数为:"+sum);

        //2.创建稀疏数组
        int [][] array2 = new int[sum+1][3];
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        //遍历二维数组，将非零的值存进稀疏数组中
        int count  = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j <array1[i].length ; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+
                               array2[i][1]+"\t"+
                               array2[i][2]+"\t");
        }
    }

}

结果如下