Java学习笔记02（方法，数组）

Java方法

方法的定义

方法就是完成某种功能的一段代码，相当于c语言中的函数。

定义一个方法：

修饰符 返回值类型 方法名（参数）{

​ 方法体；

}

如：

public static int add(int a, int b){
    return a+b;
}

方法的使用是通过 对象名.方法名；若要想直接在main方法中使用某方法 ，可以在方法名前面加修饰符static。

（在某个类定义的变量前加上static会使变量变成类变量，在main中可以直接使用）

static 方法 可以通过 类名.方法名进行直接使用

方法的重载

方法重载满足的条件

• 方法名必须相同
• 方法中的参数必须不同（参数个数不同，参数类型不同等）
• 方法的返回值类型可以相同也可以不相同（参数相同，返回值类型不同不叫重载）

可变参数

当不确定方法中要用到多少参数时，可以使用可变参数。

使用方法：在指定参数的类型后面加一个省略号（…）；

可变参数的本质是将所有的参数放入一个数组之中

如一个可以传递任意参数的累加求和方法：

   public int add(int... a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum  = sum + a[i]; 
        }
        return sum;
    }

注意：可变参数必须放在参数列表的最后的一个位置。

 public int add(int... a，int i){}    //  ×
 public int add(int i,int... a){}    //   √

函数递归

定义： 一个函数在函数体中调用自己。

递归结构包含两个部分：

• 递归头：什么时候不调用自身；若没有递归头，将陷入死循环。（递归出口）
• 递归体：什么时候调用自身。

静态方法和非静态方法

在方法前加上 static 修饰符方法会变成一个静态方法。
一个类中的静态方法可以通过 类名.方法名 直接进行调用。而非静态方法必须通过对象实例化进行调用，即 new 一个具体的对象 ， 通过 对象名.方法名 进行调用。
静态方法随着类的加载也被同时加载，而非静态方法只有创建一个具体对象时才会加载。

数组

数组的定义

数组就是存放一组相同数据类型的一种数据结构。

数组的声明和创建

数组声明的两种方法：

int array[]; // 第一种
int[] array; // 第二种

数组的创建（为声明的数组分配内存空间）

array = new int[10]; 

声明和创建可以合在一起

int[] array = new int[10];

数组三种初始方法

1. 静态初始化

   int[] array = {1,2,3}; // 创建+赋值
   

2. 动态初始化

   int[] array = new int[10];  //此时 已经默认初始化
   array[0] = 0;
   

3. 默认初始化：当数组内存空间被分配时，自动进行默认初始化。

数组本身就是对象，数组在声明时会存放在栈中，通过new建立出来的对象或数组都存放在堆中。

数组的使用

• 增加for循环遍历数组

  int[] arrays = {1,2,3,4,5};
  for(int array : arrays)  //  遍历数组，  将arrays数组中的每一个元素 赋值给 遍历 array
  {
      system.out.println(arry+" ");
  }
  

• 数组可以作为方法中的参数

public int arraysSum(int[]  arrays){}  //参数为数组类型

• 数组可以作为返回类型进行返回

public int[] arraysReverse(int[] arrays){}  //返回值为数组

二维数组

int[][] arrays{{1,2,3},{4,5,6}; //两行三列数组

稀疏数组

若一个数组的中的元素大多数为 0 或者 相同的元素时， 可以用一个稀疏数组来表示该数组。

稀疏数组如何存储：第 0 行 记录 原始数组 有几行 ，几列， 多少个不同的值。

稀疏数组有三列 第一列记录原始数组中数据的行，第二列记录 列，第三列 记录 值。

稀疏数组的创建：

1. 遍历原数组，用sum记录原数组中共有多少个不同的值；
2. 创建稀疏数组，稀疏数组的行数为 sum+1，列数为 3；
3. 为稀疏数组的第一行赋值，通过原数组的长度和sum值；
4. 设置一个 count = 0 变量来控制稀疏数组的行数；
5. 遍历原数组，判断数组中的每一个值是否为不同值；
6. 若是，count+1 (表示稀疏数组的第 count行)，通过此时循环中的原数组的下标，对稀疏数组赋值。

稀疏数组的还原：

1. 通过稀疏数组的第 0 行 创建还原数组；
2. 除去第一行，遍历稀疏数组的每一行，通过每一行的第 0 1 2 三个元素确定 还原数组的下标和值；

稀疏数组的代码举例：

        // 创建一个初始数组 大多数值为0的数组
        int[][] array1 = new int[5][6];
        array1[1][1] = 1;
        array1[3][4] = 2;
        array1[4][4] = 1;
        //打印该初始数组
        System.out.println("原始数组为：");
        for (int[] arrays : array1){
            for (int array : arrays){          // 增强for的嵌套使用
                System.out.print(array + " ");
            }
            System.out.println();
        }


        // 为初始数组建立一个稀疏数组
           //1.首先得到稀疏数组的第0行数据
        int sum = 0;
        for (int[] arrays : array1){
            for (int array : arrays) {
                if(array != 0) {
                    sum++;
                }
            }
        }
        System.out.println("原始数组中有多少数据："+ sum);
            //2.建立压缩数组array2，为数组第一行赋值
        int[][] array2 = new int[sum+1][3];    //稀疏数组的行数为 sum + 1；
        array2[0][0] = array1.length;
        array2[0][1] = array1[0].length;
        array2[0][2] = sum;                    // 稀疏数组的第一行第一列赋值
            // 3. 遍历初始数组，为稀疏数组赋值
        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) {            //当值不为0时 count++
                    count++;
                    array2[count][0] = i;           //将原始数组的行数赋值给 稀疏数组的第一列
                    array2[count][1] = j;           //将原始数组的列数赋值给  稀疏数组的的二列
                    array2[count][2] = array1[i][j]; //将原始数字的对应值赋值给 稀疏数组的的三列
                }
            }
        }
            // 4 .打印稀疏数组
        System.out.println("稀疏数组为：");
        for (int[] arrays : array2){
            for (int array : arrays){
                System.out.print(array + " ");
            }
            System.out.println();
        }



        //还原稀疏数组
            //1.创建一个新数组  行数列数 为 稀疏数组的第0行 第0列 数据；
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
            //2.遍历稀疏数组
        for (int i = 1; i < array2.length; i++){
          array3[array2[i][0]][array2[i][1]] = array2[i][2];  // 稀疏数组 第i行的 0 1 2 下标的值 对应 还原数组的 下标和值
        }
            //3.打印还原数组
        System.out.println("还原过后的数组为");
        for (int[] arrays : array3){
            for (int array : arrays){
                System.out.print(array + " ");
            }
            System.out.println();
        }