方法、数组

方法

是语句的集合，在一起执行一个功能
它是解决一类问题的步骤的有序集合
包含于类或对象中
在程序中创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是实现某一个功能的语句块的集合。设计时，最好保持方法的原子性。就是一个方法只完程一个功能，有利于后期的扩展。

定义和调用

java的方法类似于其他语言的函数，用来完程特定功能的代码片段。语法如下：

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

方法包含一个方法头，和一个方法体，
修饰符是可选的马，告诉编译器如何调用该方法，定义方法的访问类型，
返回值类型是方法可能有返回值，
方法名是方法的实际名称，方法名和参数表共同构成方法签名
参数类型是参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型、顺序和参数的个数，参数时可选的，方法一不包含任何参数
方法体是包含具体的语句，定义该方法的功能

方法的调用

对象名.方法名（实参列表）
java支持两种调用方法的方式，根据方法是否返回值来选择，
当方法返回一个的时候，方法调用通常被当作一个值
当方法返回值是void，方法调用一定是一个语句。

重载

是在一个类中，有相同的函数名称，但是形参把不同的函数

方法的重载规则

方法名称必须相同
参数列表必须不同（个数或者类型不同、参数排列顺序不同）
方法的返回类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载

实际理论

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

命令行传参

希望运行一个程序时候再传递给它消息，这时候要靠传递命令行参数给main()函数实现

可变参数

jdk1.5开始，java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号(…)
一个方法只能执行一个可变参数，必须时方法的最后一个参数，任何普通的参数必须在他之前声明

递归

自己调用自己就是递归
利用递归可以用简单的程序来解决一些复杂的问题，通常把一个大型复杂的问题层层转化为一个与原问题相似规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算机，大大减少了程序的代码量，递归的功能在于用有限的语句来定义对象的无限集合。
容易出现栈溢出异常。

分别两个部分：

递归头：什么时候不调用自身方法，如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法

数组

是相同数据类型的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
其中每个数据称作一个数组元素，每个数组元素可以通过一个下标访问

数组声明创建

语法：

dataType arrayFerVar 
dataType arrayFerVar[]

使用new操作符来创建数组
dataType[] arrayFerVar = new dataType[arraySize]

数组元素是通过索引来范根的，数组索引从0开始
获取数组的长度：arrays.length

数组的特点：
长度是固定的，数组一旦被创建，大小就是不可改变的
元素必须是相同类型，不允许出现混合类型
数组元素可以是任意类型，包括引用类型和基本类型
数组变量属引用类型，数组可以看成是在堆中，数组无论保存原始类型还是其他对象类型，数组对象本身就是在堆中的

Java内存分析

Java内存：
堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型（会包含这个基本数据的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区：可以被所有的线程共享
包含了所有的class和static变量

数组的初始化

静态初始化、动态初始化、数组的默认初始化
数组是引用类型，元素相当于类的实例变量，数组一经分配空间，其中的每个元素也被按照变量同样的方法被隐式初始化

数组的边界

数组是从0开始，所以区间是：[0,length-1];
ArrayIndexOutOfBoundsException：数组下标越界异常

数组是相同数据类型（数据类型可以是任意类型）的有序集合
数组也是对象，数组元素相当于对象的成员变量
数组的长度是确定的，不可变的。若越界，则报ArrayIndexOutOfBounds

数组使用

for-each循环、数组作方法入参、 数组作返回值

package com.ty.Array;

public class Demo03 {
   public static void main(String[] args) {
       int[] array = {1,2,3,4,5};
       for (int x : array) { //for-each没有下标
           System.out.println(x);
       }
       arr();
       System.out.println("-------反转操作--------");
       int[] ints = reverse(array);
       for (int n :
               ints) {
           System.out.print(n+" ");
       }
   }

   public static void arr(){
       int[] array = {1,2,3,4,5};
       for (int i = 0; i < array.length; i++) {
           System.out.print("array: "+array[i]+" ");
       }
   }

   //反转数组 1 2 3 4 5 ==> 5 4 3 2 1
   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[?] = arrays[i]
           result[j] = arrays[i];
       }
       return result;
   }

}

多维数组

多维数组可以看成是数组的数组。比如二维数组就是一个特殊的一维数组。每一个元素都是一个一维数组
二维数组：int a[][] = new int[2][2]

        int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
        for (int[] n : arrays) {
            for (int j = 0; j < n.length; j++) {
                System.out.print(n[j]+" ");
            }
        }
       

Arrays数组

数组的工具类java.util.Arrays
由于数组对象本身没有什么方法可以调用，但提供一个Arrays类，可以对数组进行基本操作
arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

常用功能：
数组赋值：fill()
数组排序：sort() 升序
比较数组：通过equals方法比较元素值是否相等
查找数组元素：通过binarySearch()方法能对排序好的数组进行二分查找操作

冒泡排序
是八大排序中最出名的一个，冒泡的代码相当简单，两层循环，外层冒泡轮数，内层依次比较。
看到嵌套循环，可以立马得出算法的时间复杂度O(n2)

package com.ty.Array;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        /**
         * 冒泡排序
         * 1，比较两个数组中，两个相邻的元素，如果第一个数比第二个数大，交换位置
         * 2.每次比较都会产生一个最大值或者最小值
         * 3.下一轮则可以少一次排序
         * 4。依次循环，直到结束
         * */
        int[] arr = {3,2,4,1,7,5};
        System.out.println(Arrays.toString(bubbling(arr)));
    }

    public static int[] bubbling(int[] arrays){
        int temp = 0;

        //通过flag标识位减少没有意义的判断
        boolean flag = true;

        //外层循环判断多少次循环
        for (int i = 0; i < arrays.length - 1; i++) {
            //内层循环判断大小
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j+1] < arrays[j]){
                    temp = arrays[j+1];
                    arrays[j+1] = arrays[j];
                    arrays[j] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return arrays;
    }
}

稀疏数组

需求：编写五子棋游戏中，有存盘退出和续上盘的功能
问题：棋盘上可看作二维数组的很多没有子的地方默认值为0，记录很多0都是没有意义的数据，如何解决
解决方法：稀疏数组
当一个数组中大部分元素是0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
处理方法：1.记录数组共有几行几列，有多少个不同值，2.把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模，
比如：左边是原数组，右边是稀疏数组

package com.ty.Array;

public class Demo07 {
    public static void main(String[] args) {
        //稀疏数组
        int[][] arrays = new int[11][11];
        arrays[1][2] = 9;
        arrays[2][2] = 1;
        arrays[4][10] = 22;
        for (int i = 0; i < arrays.length; i++) {
            for (int x : arrays[i]) {
                System.out.print(x + "\t");
            }
            System.out.println();
        }

        System.out.println("-------------------------");
        //判断数组中有多少个不是0的数
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            for (int n:arrays[i]) {
                if (n != 0){
                    sum++;
                }
            }
        }
        System.out.println("sum = "+ sum);

        System.out.println("------------------------");
        // 创建稀疏数组 sum+1 是有多少个值 3 代表行 列 值
        int[][] arr = new int[sum+1][3];
        arr[0][0] = 11;
        arr[0][1] = 11;
        arr[0][2] = sum;

        //遍历二维数组，将非0的值遍历出来
        int count = 0; //计数的作用
        for (int i = 0; i < arrays.length; i++) { //i = 1 因为第0行是头部，不用写进去
            for (int j = 0; j < arrays[i].length; j++) {
                if (arrays[i][j] != 0){
                    count++;
                    arr[count][0] = i;
                    arr[count][1] = j;
                    arr[count][2] = arrays[i][j];
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i][0]+"\t" +arr[i][1]+"\t"+arr[i][2]);
        }

        System.out.println("========================================");
        //还原稀疏数组arr
        //1.读取稀疏数组
        int[][] arr2 = new int[arr[0][0]][arr[0][1]];
        //2.给其中的数组做还原他的值
        for (int i = 1; i < arr.length; i++) {
            arr2[arr[i][0]][arr[i][1]] = arr[i][2]; //让i是从上往下的第几行有数据，0 是行 1是列 2是值
        }

        for (int[] num : arr2) {
            for (int n : num) {
                System.out.print(n+"\t");
            }
            System.out.println();
        }
    }
}