JavaSE笔记03

JavaSE笔记03

一：方法

方法定义以及调用

1. Java方法是语句的集合，他们在一起执行一个功能
2. 方法包含于类或对象中
3. 方法在程序中创建，在其他地方被调用
4. 一个方法完成一个功能，称原子性

package day02;
public class Demo01 {
    public static void main(String[] args) {
        int add = add(2, 4);
        System.out.println(add);
    }
    /**
     * 实现两个整数相加
     * @param a
     * @param b
     * @return
     */
    public static int add(int a, int b){
        return a + b;
    }
}

方法头

    public static int add(int a, int b){
        //方法体
    }

方法体

        return a + b;

修改符

    public

返回值类型

		int

方法名

		add

参数类型

    (int,int)

形式参数

		(int a, int b)

实参

		(2,4)

方法重载

1. 在同一个类中有相同名字的方法，但是方法的形式参数不同
2. 方法重载，必须是方法的方法名称一样，方法的形式参数不同
3. 返回值可以一样，也可以不一样

package day02;

public class Demo01 {
    public static void main(String[] args) {
        int add = add(2, 4);
        int add1 = add(2, 4, 6);
        System.out.println(add);
        System.out.println(add1);
    }
    /**
     * 实现两个整数相加
     * @param a
     * @param b
     * @return
     */
    public static int add(int a, int b){
        return a + b;
    }

    /**
     * 求三个整数相加
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static int add(int a, int b, int c){
        return a + b + c;
    }
    
}

命令行传参(扩展)

可变参数

1. 一个方法中只能声明一个可变参数，它必须是方法的最后一个参数。
2. 在方法声明中，在指定参数类型之后加一个省略号

   /**
     * 测试可变参数
     * @param a
     */
    public void test(int b, int ... a){
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
    }

递归（尽量少用）

1. A方法调用A方法！自己调用自己
2. 递归由两部分组成：递归头+递归体

package day02;

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(f(3));
    }

    public static int f(int n){
        if(n == 1){
            return n;
        }else {
            return n * f(n-1);
        }
    }
}

二：数组

数组声明创建

1. 数组是相同类型数据的有序集合
2. 按一定的先后顺序排列而成
3. 每一个数据成为数组的元素，可以通过对应下标访问他们
4. 数组的长度是固定的，数组一旦别创建，大小不能改变
5. 元素必须是相同类型。
6. 元素可以是基本数据类型，也可以是引用数据类型
7. 数据变量属性引用数据类型，数据也可以看成对象，数据中每个元素相当于该对象的成员变量
8. 数据本省就是对象，Java中对象是在堆中的。所以数组对象本身是在堆中

package day02;

public class Demo03 {
    public static void main(String[] args) {
//        首选方法（静态初始化）
        int [] a = {1,2,4};

//        效果相同，但不是首选方法
        int b[];

//      声明数组，并给出空间大小,(动态初始化)
        int[] ints = new int[10];

//        获得数组长度
        System.out.println(ints.length);

//        数组赋值
        ints[0] = 1;

//        通过下标获取数组中的值
        System.out.println(ints[0]);

//        数组遍历
        for (int item: ints){
            System.out.println(item);
        }
    }
}

数组使用

1. for-Each循环数组（遍历数组）
2. 当成函数返回值类型

//    数组可以作为函数的返回类型
    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;
    }

多维数组

1. 多维数组可以看成数组的数组
2. 比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

//一个二行五列数组
int a[][] = new int[2][5]

Arrays类

1. 很多静态方法可以使用，通过javados查看使用

冒泡排序

1. 通过两层循环实现，外层冒泡轮数，里层依次比较
2. 时间复杂度为O(n^2)

package day02;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] a = {2,4,6,1,8};

//        冒泡排序函数调用
        int[] sort = sort(a);

//        Arrays类中静态方法的使用，打印出数组
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] arrays){
//        定义一个临时变量
        int temp = 0;

//        外层循环，判断我们这个要走多少次
        for (int i = 0;i < arrays.length-1;i++){

            boolean flag = false;
            
//            内层循环，比较判断两个数，如果第一个比第二个大，则交换位置
            for(int j = 0; j < arrays.length-1-i;j++){
                if(arrays[j+1] > arrays[j]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return arrays;
    }
}

稀疏数组

1. 记录数组一共有几行几列，有多少个 不同的值
2. 把具有不同的值的元素和行列以及值记录在一个小规模的数组中，从而缩小程序的规模

package day02;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
//        创建一个二维数组11*11   0：没有棋子   1：黑棋子   2：白棋子
         int[][] arrays= new int[11][11];

         arrays[1][2] = 1;
         arrays[2][3] = 2;

        for (int[] item : arrays){
            for (int x : item){
                System.out.print(x + "\t");
            }
            System.out.println();
        }



//        转换成稀疏数组
//       获取有效值的个数
        int sum = 0;
        for (int[] item : arrays){
            for (int x : item){
                if(x != 0){
                    sum++;
                }
            }

        }
//        有效值个数
        System.out.println(sum);

//        创建一个稀疏数组
        int[][] ints = new int[sum+1][3];

        ints[0][0] = 11;
        ints[0][1] = 11;
        ints[0][2] = sum;

//        遍历数组，将非零的值，存放在稀疏数组中
        int count = 0;

        for(int i = 0;i < arrays.length;i++){
            for(int j = 0; j < arrays[i].length;j++){
                if (arrays[i][j] !=0){
                    count++;
                    ints[count][0] = i;
                    ints[count][1] = j;
                    ints[count][2] = arrays[i][j];
                }
            }
        }
//        输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0;i < ints.length;i++){
            System.out.println(ints[i][0] + "\t"
                    +ints[i][1] + "\t"
                    +ints[i][2] + "\t"
            );
        }

        System.out.println("还原");

//        读取稀疏数组
        int[][] array3 = new int[ints[0][0]][ints[0][1]];

//        给其中的元素还原它的值
        for(int i = 1;i < ints.length;i++){
            array3[ints[i][0]][ints[i][1]] = ints[i][2];
        }

        System.out.println("还原的数组");
        for (int[] item : array3){
            for (int x : item){
                System.out.print(x + "\t");
            }
            System.out.println();
        }
    }
}