方法及数组

方法

Java方法是语句的集合，他们在一起执行一个功能

方法是解决一类问题的步骤的有序组合

方法包含于类或对象中

方法在程序中被创建，在其他地方被引用

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

方法的定义

方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

修饰符 方法返回值类型 方法名(形参列表){
方法体;
return 方法返回值;
}

方法的调用方式

对象名.方法名(实参列表)

方法的作用

提高代码的复用性

方法的重载

重载就是在一个类中有相同的函数名称但形参不同的函数

注意本质：重载的方法，实际是完全不同的方法，只是名称相同而已！

方法重载的规则：

1.方法名称必须相同

2.参数列表必须不同（个数不同，或类型不同，参数排列顺序不同）

3.方法的返回类型可以相同也可以不同

4.返回类型不同不足以成为方法的重载

注意：形参列表不同指的是什么？

（1）个数不同
add() add(int num1) add(int num1,int num2)
（2）顺序不同
add(int num1,double num2) add(double num1,int num2)
（3）类型不同
add(int num1) add(double num1)

(1)add(int a) 和 add(int b) 不构成,相当于方法的重复定义
(2)public static int add(int a) 和 public static void add(int b) 不构成

递归：

A方法调用A方法就是自己调用自己

利用递归可以用简单的程序解决一些复杂的问题，通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解减少程序的代码量，递归的能力在于用有限的语句来定义对象的无限集合

递归包括两部分

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

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

数组

数组的定义

数组是相同类型数据的有序集合

数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成

其中，每一个数据称作一个数组元素，每个元素可以用一个下标来访问

数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束
5.数组变量属于引用类型，数组也是对象。

数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的

Java内存分析

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

数组的初始化方式总共有三种：

静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};

new int[3]{12,23,45}; 错误
int[] arr ;
arr = {12,23,45}; 错误

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;

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

int[] arr = new int[3]; 数组有默认的初始化值

多维数组

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

二维数组：int a[][] [] []=new int[2] [5];

其可以看作是一个两行五列的数组

Arrays类

import java.util.Arrays;
public class demo2{
    public static void main(String[] args){
        //给定一个数组：
        int[] arr = {1,2,5,9,3,8};
        //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
        System.out.println(Arrays.toString(arr));

        //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
        //这个方法的使用前提：一定要查看的是一个有序的数组：
        //sort：排序 -->升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.binarySearch(arr,4));

        int[] arr2 = {1,2,5,9,3,8};
        //copyOf:完成数组的复制：
        int[] newArr = Arrays.copyOf(arr2,4);
        System.out.println(Arrays.toString(newArr));

        //copyOfRange:区间复制：
        int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
        System.out.println(Arrays.toString(newArr2));

        //equals:比较两个数组的值是否一样：
        int[] arr3 = {1,2,5,9,3,8};
        int[] arr4 = {1,2,5,9,3,8};
        System.out.println(Arrays.equals(arr3,arr4));//true
        System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false

        //fill：数组的填充：
        int[] arr5 = {1,2,5,9,3,8};
        Arrays.fill(arr5,10);
        System.out.println(Arrays.toString(arr5));
    }
}

增强for循环

public class demo2{
        public static void main(String[] args){
                //定义一个二维数组：
                int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
                
                int[] a1 = {1,2,3};
                arr[0] = a1;
                
                arr[1] = new int[]{4,5,6,7};
                
                arr[2] = new int[]{9,10};
                
                //读取6这个元素：
                //System.out.println(arr[1][2]);
                
                //对二维数组遍历：
                //方式1：外层普通for循环+内层普通for循环：
                for(int i=0;i<arr.length;i++){
                        for(int j=0;j<arr[i].length;j++){
                                System.out.print(arr[i][j]+"\t");
                        }
                        System.out.println();
                }
                
                //方式2：外层普通for循环+内层增强for循环：
                for(int i=0;i<arr.length;i++){
                        for(int num:arr[i]){
                                System.out.print(num+"\t");
                        }
                        System.out.println();
                }
                
                //方式3：外层增强for循环+内层增强for循环：
                for(int[] a:arr){
                        for(int num:a){
                                System.out.print(num+"\t");
                        }
                        System.out.println();
                }
                
                //方式4：外层增强for循环+内层普通for循环：
                for(int[] a:arr){
                        for(int i=0;i<a.length;i++){
                                System.out.print(a[i]+"\t");
                        }
                        System.out.println();
                }
        }
}

冒泡排序

冒泡的代码相当简单，两层循环，外层冒泡轮数，里层依次比较

我们看到内嵌循环，应该就可以得出这个算法的时间复杂度为O(n2)。

import java.util.Arrays;
public class demo2 {
    public static void main(String[] args) {
        int[] a ={1,55,33,47,50,67,89,90,56,43};
        int[] sort = sort(a);//调用完我们写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));
    }
/**冒泡排序
    比较数组中两个相邻的元素，如果前者比后者大我们就交换他们的位置
 每一次比较都会出现一个最大一个最小
 下一轮则可以少排一次序
 依次循环直到结束
 * @return
 */
public static int[] sort(int[] array){
    //定义临时变量
    int temp=0;
    //外层循环，判断我们这个要走多少次
    for (int i = 0; i < array.length-1; i++) {
        //内层循环，比较数组中两个相邻的元素，如果前者比后者大我们就交换他们的位置
        for (int j = 0; j < array.length-1-i; j++) {
            if (array[j+1]<array[j]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
        }
    return array;
}
}