本文共 6585 字，大约阅读时间需要 21 分钟。

程序的执行结构：

顺序结构

分支结构

循环结构

分支流程控制：

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工具类

转载地址：https://blog.csdn.net/m0_56433040/article/details/117380827 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！