JAVA方法及数组基础知识

最新推荐文章于 2022-12-30 12:04:19 发布

原创最新推荐文章于 2022-12-30 12:04:19 发布 · 195 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

这篇博客介绍了JAVA编程的一些基本概念，包括方法的设计原则、调用与重载，详细讲解了可变参数、递归以及冒泡排序的实现。此外，还探讨了数组的创建、操作以及与集合的区别，并展示了稀疏数组的概念及其转换。

JAVA方法

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合，因此设计方法的时候最好保持方法的原子性，即一个方法只完成一个功能，有利于后期的扩展。

方法的定义

修饰符 返回值类型 方法名（参数类型 参数名）{
    方法体
    ...
    return 返回值;
}

方法的调用

静态方法只能调用静态方法

方法的重载

在同一个类里面同名不同参的方法 仅仅返回类型不同不足以构成重载

原理：方法名称相同时，编译器会根据调用方法的参数个数、类型等逐个匹配，以选择对应的方法，如果匹配失败，则编译报错。

可变参数（不定项参数）

定义方法：参数类型后面加一个省略号即可但是必须是最后一个参数并且一个方法只能有一个可变参数

public static void printMax(double... nums) {
        if (nums.length == 0) {
            System.out.println("无参！！！！");
            return;
        }
        double result = nums[0];
        for (double num : nums) {
            if (num > result) {
                result = num;
            }
        }
        System.out.println("最大值为：" + result);
    }

递归

递归头（边界条件）：什么时候不调用自己，否则会进入死循环

递归体：什么时候需要调用自身方法

public static int fun(int n) {
    //递归头即为fun(1)
    if (n == 1) {
        return 1;
    } else {
        //else中的内容为递归体
        return n * fun(n - 1);
    } 
}

数组

定义：相同数据类型的有序集合

创建方法：

静态初始化数据类型[] 数组名字 = {数组值…};
动态初始化数据类型[] 数组名字 = new 数据类型[数组长度]; 手动赋值
默认初始化数据类型[] 数组名字 = new 数据类型[数组长度]; 数组中都是默认值

简单记录数组和集合的区别

数组中的数据类型是固定的，且长度是固定的不可扩展，灵活性不如集合
数组是java内置的，效率优于集合

冒泡排序

public static int[] sort(int[] array) {

    int temp = 0;


    for (int i = 0; i < array.length-1; i++) {
        boolean flag = true;
        for (int j = 0; j < array.length-1-i; j++) {//外循环多进行一次内循环就可以少进行一次
            if (array[j] < array[j + 1]) {
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = false;
            }
        }
        if (flag){//flag未变证明数组已经是最终结果所以不需要进行循环了
            break;
        }
    }

    return array;
}

稀疏数组

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



        int[][] arr1 = new int[11][11];

        arr1[1][3] = 2;
        arr1[2][4] = 1;

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

        System.out.println("===========================");

        //记录非0数字的数量
        int num = 0;
        //计算非9数量
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] != 0) {
                    num++;
                }
            }
        }
        System.out.println("共有"+num+"个数字");

        //稀疏数组的生成
        int[][] arr2 = new int[num+1][3];
        //填数字 第一行为原素组几行几列 以及非零数字的数量
        arr2[0][0] = 11;
        arr2[0][1] = 11;
        arr2[0][2] = num;

        int count = 1;//从第二行开始填数
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] != 0) {
                    arr2[count][0] = i;
                    arr2[count][1] = j;
                    arr2[count][2] = arr1[i][j];
                    count++;

                }
            }
        }
        System.out.println("=========稀疏数组===============");
        for (int[] ints : arr2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("==============还原数组================");
        //还原数组

        int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];

        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
        }
        for (int[] ints : arr3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }


    }
}