Java -方法

java方法是语句的集合 他们在一起执行一个功能
方法是解决一类问题的步骤的有序组合
方法包含于类或者对象中
方法在程序中被创建 在其他地方被引用
一个方法只完成一个功能

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

方法的调用
调用方法：对象名.方法名（实参列表）
java支持两种调用方法的方式，根据方法是否返回值来选择

值传递 使用两个不同的存储单元，执行中，形式参数值改变不会影响实际参数值
引用传递 实际为引用地址，实际参数和形式参数指向同一地址，执行中形式参数会影响实际参数


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

可变参数
JDK 1.5开始，Java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号
一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它之前声明

递归
自己调用自己的方法
少量的程序解决出过程需要的多次重复计算 减少代码量
递归结构包含两个部分：递归头-什么时候不调用自己的方法，没有头将陷入死循环 递归体-什么时候需要调用自身方法
递归适合小计算 如果计算量太大 容易死机

 

 

 

数组
数组是相同类型数据的有序集合 描述的是相同类型的若干数据按照一定的先后顺序排列组合而成 每一个数据称作一个元素 通过下标来访问
数组的声明创建
声明数组变量 dataType[] arrayRefVar;(首选)或 dataType arrayRefVar[]
创建数组 dataType[] arratRefVar = new dataType[arraySize] 元素通过索引访问 从0开始
数组长度 arrays.length

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

三种初始化 
静态初始化 （创建+赋值）
int[] a = {1,2,3};    Man[] mans = {new Man(1,1),new Man(2,2)};
动态初始化（包含默认初始化，未赋值前为0）
int[] a = new int[2];a[0] = 1;a[1] = 2;
数组的默认初始化  数组是引用类型，他的元素相当于类的实例变量 数组以经分配空间 其中的每个元素也被按照实例变量同样的方法被隐式初始化

数组的四个基本特点  
1、长度确定 数组一旦被确定 其大小不可以改变
2、元素必须是相同类型 不允许出现混合类型
3、数组中的元素可以是任何数据类型 包括基本类型和引用类型
4、数组变量属于引用类型 数组也可以看成是对象 数组中的每个元素相当于该对象的成员变量
数组本身就是对象 java中的对象是在堆中的 因此无论数组保存原始类型还是其他对象类型 数组对象本身是在堆中

数组边界   下标的合法区域：[0,length-1],如果越界就会报错  ArrayIndexOutOfBoundsException:数组下标越界

总结  
数组是相同数据类型（数据类型可以为任意类型）的有序集合

数组也是对象 数组元素相当于对象的成员变量
数组长度是确定的 越界报错ArrayIndexOutOfBoundsException

        int[] arrays = {11,2,14,56,32,56};
        //打印数据
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        //打印数组元素之和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum = sum + arrays[i];
        }
        System.out.println("sum"+sum);
        //打印最大元素的值
        int max = 0;
        for (int i = 0; i < arrays.length; i++) {
            if (max<arrays[i]){
                max = arrays[i];
            }
        }
        System.out.println("最大值为"+max);

 

int arrays[] = {1,2,3,4,5};
        //打印数组元素
        for (int array : arrays){
            System.out.println(array+"");
        }
        System.out.println();

        System.out.println("打印数组");
        printArray(arrays);

        System.out.println("反转数组");
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    public static int[] reverse(int[] arrays) {
        int[] reverse = new int[arrays.length];
        for (int i = 0, j = reverse.length-1;i < arrays.length; i++,j--) {
            reverse[j] = arrays[i];
        }
        return reverse;
    }

    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+"");
        }
    }

 多维数组

多维数组可以看成是数组的数组 例如二维数组 每一个元素就是一个数组
int a[][] =new int[2][4];两行四列的数组

int[][] array = {{1,2},{4,5},{9,10},{10,11}};
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"");
            }
        }

Arrays类

 

数组的工具类 java.uti.Arrays
Arrays类中的方法都是static修饰的静态方法 在使用时可以直接使用类名调用 不用使用对象来调用（可以使用对象来调用）
具有的功能
1、给数组赋值：通过fill方法
2、对数组进行排序：通过sort方法 升序
3、比较数据：通过equals方法比较数组中的元素值是否相等
4、查找数组元素：通过binarySearch方法对排序好的数组进行二分法查找

int[] a = {1,45,56,89,78,34,49,61};
        //打印元素
        System.out.println(Arrays.toString(a));
        //数组排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //数组填充
        Arrays.fill(a,7);
        System.out.println(Arrays.toString(a));
        //选择填充
        Arrays.fill(a,5,6,8);
        System.out.println(Arrays.toString(a));

运行结果

 

冒泡排序

 

冒泡的代码 两层循环 外层冒泡轮数 里层依次比较
嵌套循环的算法的时间复杂度为O（n2）

 public static void main(String[] args) {
        int[] a = {23,45,35,16,89,59,90,75};
        int[] dai = dai(a);
        System.out.println(Arrays.toString(a));
    }
public static int[] dai(int[] array) {
        int p = 0;
        boolean flag = false;
        for (int i = 0; i < array.length-1; i++) {//最大外循环
            for (int j = 0; j < array.length; j++) {//排序循环
                if (array[j+1]<array[j]){
                    p = array[j];
                    array[j] = array[j+1];
                    array[j+1] = p;
                    flag = true;
                }if (flag == false){//优化 提前结束
                    break;
                }
            }
        }
        return array;
    }

稀疏数组

需求 编写五子棋游戏中 有存盘退出或续上盘的功能
分析问题 该二维数组的很多值默认值为0 记录了很多没有意义的数据
解决 稀疏数组
当一个数组中大部分元素为0 或者为同一值得数组时 可以使用稀疏数组来保存该数组
处理方式 
1、记录数组一共有几行几例 有多少个不同值
2、把具有不同值得元素和行列值记录在一个小规模的数组中 从而缩小程序的规模

 public static void main(String[] args) {
        int[][] array1 = new int[11][11];//0代表空 1代表黑子 2代表白子
        array1[1][2] = 1;//给黑子定位
        array1[2][3] = 2;//给白子定位
        System.out.println("原始数据：");
        for (int[] ints : array1){
            for (int anInt : ints){
                System.out.print(anInt+"");
            }
            System.out.println();
        }
        System.out.println("======================================");
        //转换为稀疏数组保存
        //1、求和有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("稀疏数组：");
        //2、创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];//确定第一条稀疏数组的数据
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //3、将非零的值 存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.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("序 "+" 行 "+" 列 "+" 值 ");
        int xu = 0;
        for (int[] ints : array2) {
            System.out.print(xu + " ");
            for (int anInt : ints) {
                if (anInt < 10) {
                    System.out.print("  " + anInt + "  ");
                }else {
                    System.out.print("  " + anInt + "  ");
                }
                xu++;
                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");
            }
            */
            System.out.println("===============================");
            //转换成原始数据
            System.out.println("还原原始数组：");
            int[][] array3 = new int[array2[0][0]][array2[0][1]];//确认原始数组整体大小
            for (int i = 1; i < array2.length; i++) {
                array3[array2[i][0]][array2[i][1]]=array2[i][2];
            }
            for (int[] ints : array3){
                for (int anInt : ints){
                    System.out.print(anInt+" ");
                }
                System.out.println();
            }
        }