Java基础

程序的执行结构：

顺序结构

分支结构

循环结构

分支流程控制：

if

switch

循环

for循环和while循环的区别

当我们想使用i时，并且已知循环此数时，使用for循环，当我们仅仅是想利用循环判断结束或是不知道循环次数时，使用while循环

do-while和while的区别

do-while不管条件一定先执行一次，但while是先判断条件是否成立再决定执行与否

continue：

作用范围仅限于循环中，表示立即结束本次循环开始下一次循环

break：

作用范围为：循环和switch分支结构中。在循环当中，break表示跳出当前循环，在分支结构中，break表示跳出当前分支

Lable标签：

给循环命名，使用break，continue可以跳出指定的循环

方法

方法的优势：

1.提高代码的复用性

2.使程序的结构变得简单清晰

3.有利于程序的的维护修改

4.提高开发效率

方法的命名规则：

1.方法名见名知意

2.驼峰命名法

方法的声明：

方法的五个要素：访问修饰符，返回值，方法名，参数，方法体

修饰符有四种：public,protected,private,default

返回值：返回值的类型与方法体的类型息息相关

方法名：遵循见名知意，驼峰命名的规则

参数：方法里面的参数是形式参数，就像局部变量，仅限于方法内部使用

方法体：方法的核心，方法的功能全靠方法来实现

方法的调用：

方法名（参数），这里的参数是实际参数，必须和形式参数一一对应

完整的方法必须有方法的声明和方法的调用

方法的返回值：

方法调用处的实际参数在内部传给方法声明处的形参，然后形参在方法内部进行计算，结果通过return返回给返回数据类型处的位置，最后再返回给方法调用处

return的作用：

1.将方法体的运算结果返回

2.结束当前方法

Java的内存分配：

java当中的内存分为堆（heap），栈（stack），方法区，本地方法区，寄存器

堆：存储着实体，例如，对象，数组，或其他引用型数据，堆中数据不会立即释放，而是等待着java中的垃圾回收机制回收

栈：先进后出，里面存储着方法和基本类型数据，用完就立马释放

方法区：存储着程序的.class文件

本地方法区：存放在由外界引入的c,c++等

寄存器：分为代码寄存器和数据寄存器

方法重载：

同一个类中，方法名字相同，参数列表不同，就叫方法重载

参数列表的不同包括，参数个数不同，参数数据类型不同，参数顺序不同

重载的优点：

简化了开发和调用的压力，开发者不必为功能相似的诸多方法思索大量方法名，调用者不必记忆功能相似但方法名不同的诸多方法

递归：

在自己的方法体内，调用方法自己，实现某些循环的功能。

数组

定义：

1.数组是一个数据容器，可以存储基本数据类型的数据，也可以存储引用数据类型的数据

2.数组的长度是不可变的，数组的内存空间是连续的。数组一旦实例化完成，长度就不能再改变

基本数据类型和引用数据类型的比较

1.对于基本数据类型，会直接在栈中的方法区中开辟一块空间存储当前变量，将要存储的数据直接放在这块空间里

2.引用数据类型里面存储的是地址，这个地址是十六进制的数

数组的声明和实例化

/*
方式一：
先将数组声明并实例化，不赋值
此时数组中的元素是默认的5个0
*/
int[] array = new int[5];

/*
方式二：
先将数组声明，实例化，并赋值
*/
int[] array = new int[5]{1,2,3,4,5};

/*
将方式二简化
*/
int[] array = {1,2,3,4,5};

补充：

数组在实例化时，需要使用new关键字（以后但凡遇到了new，都表示在堆上开辟了空间），数组其实是在堆上开辟的连续的空间，例如new int[5]，就是在堆上开辟了5个连续的4字节空间，然后将堆上的内存地址，赋值给栈上的变量array引用

数组的下标：

下标是数组中的元素在数组中存储的位置索引，下标从0开始，一直到数组.length-1

典型异常：ArrayIndexOutOfBoundsException

数组遍历：

for（下标遍历法）

 for (int i = 0; i < array.length; i++) {
       System.out.println(array[i]);
    }

foreach（增强版for循环）

for (int newArray:array) {
        System.out.println(newArray);
      }

二者区别：

1.如果需要在遍历的同时，获取到数组中的元素下标，需要使用下标遍历法

2.如果需要在遍历的同时，修改数组中的元素，需要使用下标遍历法

3.如果仅仅是想要获得数组中的每一个元素，不需要使用下标，也不需要修改数组中的元素，使用foreach，这种遍历方式的效率比下标遍历法高

经典排序算法

冒泡排序：

/*
总共遍历n-1趟，每一趟挨个比较前后两个元素，每一趟可以让最大值到达数列末尾
*/
public static void bubbleSort(int[] array){
    //总共遍历n-1趟
    for(int i = 0;i < array.length-1;i++){
        //挨个比较前后两个元素
        for(int j = 1;j < array.length-i;j++){
            if(array[j] < array[j-1]){
                array[j] = array[j] ^ array[j-1];
                array[j-1] = array[j] ^ array[j-1];
                array[j] = array[j] ^ array[j-1];
            }
        }
    }
}

选择排序：

/*
总共需要n-1趟排序过程，每次排序都可以选择最小的值放到对应的位置上
*/
public static void selectionSort(int[] array){
    //总共遍历n-1次
    for(int i = 0;i < array.length -1;i++){
        int minIndex = i;
        for(int j = i+1;j < array.length;j++){
            if(array[minIndex] > array[j]){
                minIndex = j;
            }
        }
        //判断是否需要交换两值
        if(minIndex != i){
            array[minIndex] = array[minIndex] ^ array[i];
            array[i] = array[minIndex] ^ array[i];
            array[minIndex] = array[minIndex] ^ array[i];
        }   
    } 
}

插入排序：

/*
需要n-1趟遍历，每次确定一个元素的位置
*/
public static void insertionSort(int[] array){
    int j ;
    for(int i = 1;i < array.length;i++){
        //记录要插入的元素
        int temp = array[i] ;
        //通过循环，为temp寻找正确的位置
        for(j = i;j > 0 && temp < array[j-1];j--){
            array[j] = array[j-1];
        }
        array[j] = temp;
    }   
}

快速排序：

/*
快速排序：核心在于确定基准元素的位置，然后进行递归
*/
public static void quickSort(int[] array,int low,int high){
    if(low < high){
        int midle = getBasic(array,low,high);
        quickSort(array,low,midle-1);
        quickSort(array,midle+1,high);
    }
}
public static int getBasic(int[] array,int low,int high){
    //由于输入数组是无序的，所以为了简便，选取第一个元素作为基准元素
    int temp = array[low];
    while(low < high){
        //先从最右侧开始判断
        while(low < high && array[high] > temp){
            high--;
        }
        array[low] = array[high];
        //再判断左侧
        while(low < high && array[low] < temp){
            low++;
        }
        array[high] = array[low];
    }
    array[low] = temp;
    return low;
}

归并排序：

/*
归并排序的核心在于归并：采用分而治之的思想，先分再治
*/
public static void mergeSort(int[] array,int low,int high){
    if(low < high){
        int center = (low + high) / 2;
        //将一个数组分成两个半数组
        mergeSort(array,low,center);
        mergeSort(array,center+1,high);
        //将两个半数组进行归并
        merge(array,low,center,high);
    }
}
//归并
public static void merge(int[] array,int low,int center,int high){
    //定义两个变量，记录两个半数组的起始位置
    int start1 = low;
    int start2 = center + 1;
    //定义一个辅助数组，存储两个数组归并后的结果
    int[] newArray = new int[array.length];
    //用来记录辅助数组的起始位置
    int temp = low;
    //现在准备将两个数组里的元素挨个放到辅助数组里
    while(start1 <= center && start2 <= high){
        if(array[start1] < array[start2]){
            newArray[temp++] = array[start1++];
        }else{
            newArray[temp++] = array[start2++];
        }
    }
        //将某一个数组里的剩余元素全部放到辅助数组里
        while(start1 <= center){
            newArray[temp++] = array[start1++];
        }
        while(start2 <= high){
            newArray[temp++] = array[start2++];
        }
        //元素全部放到辅助数组里后，再将辅助数组里的数放到原数组里
        while(low <= high){
            array[low] = newArray[low++];
        }   
}

数组查询

遍历查询

二分查询

/*
想要对数组进行二分查询，就必须先对数组进行排序
*/
public static int binarySearch(int[] array,int num){
    //先对数组进行排序
    quickSort(array,0,array.length-1);
    //记录数组的起始位置和结束位置
    int low = 0;
    int high = array.length - 1;
    while(low <= high){
        int mid = (low + high)/2;
        if(array[mid] > num){
            high = mid - 1;
        }else if(array[mid] < num){
            low = mid + 1;
        }else{
            return mid;
        }
    }
    return -1;
}

/*
采用快速排序算法对数组进行排序
*/
public static void quickSort(int[] array,int low,int high){
    if(low < high){
        int mid = getBasic(array,low,high);
        quickSort(array,low,mid-1);
        quickSort(array,mid+1,high);
    }
}
public static int getBasic(int[] array,int low,int high){
    int temp = array[low];
    while(low < high){
        while(low < high && array[high] > temp){
            high--;
        }
        array[low] = array[high];
        while(low < high && array[low] < temp){
            low++;
        }
        array[high] = array[low];
    }
   	array[low] = temp;
    return low;
}

可变长参数

数据类型… 数组名

1.可变长参数必须放到形参列表的最后位置，且只能有一个

2.给可变长参数传值的实参可以直接写，个数不限制，内部会自动将他们放到可变长数组中

3.当具有可变长参数的方法与固定参数方法是重载关系时，固定参数的调用顺序优先于可变长参数。如果出现两个方法都有可变长参数时，那么这两个方法都不能使用

二维数组

数据类型[][] [] [] = new 数据类型[3] [5];

二维数组，第一位=维数组存的是第二维数组的地址，第二维数组就是普通的一维数组

Arrays工具类