Java Day_6(陣列，JVM記憶體，遞迴演算法(冒泡，快排))

weixin_47469183發表於2020-12-06

Java Day_6(陣列，JVM記憶體，遞迴演算法(冒泡，快排))

陣列

1.定義：

* 陣列是儲存相同型別的多個元素的連續空間

2.分類：

 * 型別：基本型別陣列	 ;   引用型別陣列
 * 維度：一維；二維；三維…

3.特點：

*  	陣列所儲存的元素的型別必須是同種型別
*  	陣列的長度是有限的 是固定的  一旦宣告 則不能修改
*  陣列的 空間是連續的

4.陣列的宣告和初始化：

public static void main(String[] args) {
    //宣告陣列  資料型別[]   陣列的名稱（識別符號） = new 資料型別[陣列的長度];;
    //        資料型別[]  陣列的名稱  = {陣列中的元素，元素和元素之間使用逗號分割}
    //陣列的動態初始化
    //此時  該陣列只是分配了空間
    int[]  arr1 = new int[5];// 宣告瞭一個長度為5的整型陣列  陣列的名稱為arr1
    //陣列中元素的引用
    System.out.println(arr1[0]);
    System.out.println(arr1[1]);
    System.out.println(arr1[2]);
    System.out.println(arr1[3]);
    System.out.println(arr1[4]);
}

陣列中的元素的操作是通過索引/角標來完成索引或角標是從0開始的

5.陣列的元素的初始化：

 *  靜態初始化：

public static void main(String[] args) {	
	int[] arr1 = new int[5];
    // 陣列的靜態初始化方式1   在陣列宣告的同時 就初始化了陣列
    int[] arr2 = {10,20,30,40,22,36};
    // 陣列的靜態初始化方式2
    int[] arr3 = new int[]{21,11,31,41,51};
}

6.陣列的預設值：

陣列元素型別	元素預設初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或寫為:’\u0000’(表現為空)
boolean	false
引用型別	null

7.陣列的常用操作：

陣列的遍歷：

public static void main(String[] args) {
    int[] arr = new int[]{32,12,42,53,65};
    //使用普通for迴圈 + 陣列的 length屬性
    for (int i= 0 ; i < arr.length;i++){
        if(i % 2 != 0){
            System.out.println(arr[i]);
        }
    }
    System.out.println("----------------------------");
    // 使用增強for迴圈  （foreach） 從jdk1.5.開始引入
    // int  表示遍歷的目標資料為int型別   j 表示遍歷得到的 每一個元素的 暫存區域  arr  表示待遍歷的物件容器/集合
    for(int j : arr){
        System.out.println(j);
    }
    /*
    這兩種迴圈的區別：
        普通for迴圈可以精確的去控制 每一個元素
        增強for沒法去精確的控制每一個元素  只能遍歷所有元素
     */
}

陣列的拷貝：

public class ArrayDemo_04 {
    public static void main(String[] args) {
        int[] arr1 = {56,65,69,68,58,24,35};
        //將arr1中的元素拷貝到另一個陣列中
        // 1 建立 一個新的陣列
        int[] arr2 = new int[arr1.length];
        for(int i = 0 ; i < arr1.length;i++){
            arr2[i] = arr1[i];
        }
        for (int j: arr2) {
            System.out.println(j);
        }
        // 將arr1 中的 元素逆序拷貝到arr3中
        System.out.println("-----------------------------");
        //1 建立一個 新的陣列
        int[] arr3 = new  int[arr1.length];
        for (int i = 0,j= arr2.length -1  ; i < arr1.length && j >= 0;i++,j--){
            arr3[j] = arr1[i];
        }
        for (int j: arr3) {
            System.out.println(j);
        }
    }
}

陣列中獲取最值：

// 獲取陣列中元素的最大值
public static void main(String[] args) {
    int [] arr = new int[]{65,89,69,68,32,57};
    // 1 設定一個變數
    // 2 假設陣列中的第一元素為 最大者
    //3 將最大的元素儲存在變數中
    //4 使用當前的最大元素 依次和後邊的 元素進行比較  如果後邊的元素比他大 則替換 否則就繼續比較
    int  maxEle;
    maxEle = arr[0];
    for (int i = 1 ; i < arr.length;i++){
        if(maxEle < arr[i]){
            maxEle = arr[i];
        }
    }
    System.out.println(maxEle);
}

JVM記憶體

在這裡插入圖片描述

區域名稱	作用
程式計數器（暫存器）	給CPU使用，和我們開發無關。
本地方法棧	JVM在使用作業系統功能的時候使用，和我們開發無關。
方法區	儲存可以執行的class檔案。
堆記憶體	儲存物件或者陣列，new來建立的，都儲存在堆記憶體。當申請不到空間時會丟擲OutOfMemoryError
虛擬機器棧	棧裡面是一個一個“棧幀”，每個棧幀對應一次方法呼叫。棧幀中存放了區域性變數表（基本資料型別變數和物件引用）、運算元棧、方法出口等資訊。當棧呼叫深度大於JVM所允許的範圍，會丟擲StackOverflowError的錯誤。

基本型別的記憶體分析:
在這裡插入圖片描述

陣列的記憶體分析:
在這裡插入圖片描述

在使用陣列時要注意防止產生：陣列下標越界和空指標異常

遞迴演算法：

public class Factorial {
    //遞迴的使用  計算1--5的和

    public static void main(String[] args) {
        int num = 5;
        int s = sum(500);
        System.out.println(s);
    }
	//方法的 宣告  int/void 為方法的 返回值型別  如果方法不返回任何結果 則為void
	// sum 為方法 的 名稱 只需要遵循小駝峰命名法的識別符號都可以
	// (int num) 方法的引數  需要傳遞給方法的資料   
	// 一個程式的 入口 為main方法  所以其他方法要執行  必須在main方法中明確的呼叫
	// 方法的呼叫  通過方法名呼叫  同時需要根據方法的宣告 傳入方法所需的引數
	    
    public static int sum(int num) {
        if(num == 1){
           return   1;
        }else{
           return num + sum(--num);
        }
    }
}

階乘

public class Factroial_1 {
    // 求一個數的階乘
    public static void main(String[] args) {
        long result = cheng(10);
        System.out.println(result);
    }
    public static  long  cheng(int num){
        if(num == 1){
           return  1;//此處就是遞迴演算法的出口
        }else{
            return  num * cheng(--num);//遞迴
        }
    }
}

常見的排序演算法：

 1. 選擇排序：
	  直接選擇排序、 堆排序
 2. 交換排序
	  氣泡排序、 快速排序
 3.插入排序
	  直接插入排序、 折半插入排序、 Shell排序
 4.歸併排序
 5.桶式排序
 6.基數排序

輸入（ Input）	有0個或多個輸入資料，這些輸入必須有清楚的描述和定義
輸出（ Output）	至少有1個或多個輸出結果，不可以沒有輸出結果
有窮性（有限性， Finiteness）	演算法在有限的步驟之後會自動結束而不會無限迴圈，並且每一個步驟可以在可接受的時間內完成
確定性（明確性， Definiteness）	演算法中的每一步都有確定的含義，不會出現二義性
可行性（有效性，Effectiveness）	演算法的每一步都是清楚且可行的，能讓使用者用紙筆計算而求出答案

演算法講解：https://visualgo.net/zh/sorting

氣泡排序：

原理：

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
針對所有的元素重複以上的步驟，除了最後一個。
持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {58,63,35,39,27,32,98,5,68};
        for(int x = arr.length - 1 ; x >= 0 ;x--){
            for(int i = 0 ; i < x ; i++){
                if(arr[i] > arr[i + 1]){// 元素兩兩比較  如果前者大於後者 則交換兩個元素的 位置
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1 ] = temp;
                }
            }
        }
        // 進行陣列的遍歷
        for (int j  : arr){
            System.out.println(j);
        }
    }
}

快速排序：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {58,63,35,39,27,32,98,5,68};
        quick(arr);
        for(int x : arr){
            System.out.println(x);
        }
    }
    //快速排序的入口  該方法針對 陣列排序 所以需要你傳遞給該方法一個陣列
    public static void  quick(int[] arr){
        if(arr  == null || arr.length ==0 || arr.length == 1){
            return;
        }else{
            sort(arr,0,arr.length -1);
        }

    }
    // 快速排序的核心演算法
    public static void sort(int[] arr,int left,int right){
        int len  = arr.length;
        if(left > right){
            return;
        }
        int base = arr[left];
        int i = left;
        int j = right;
        while(i != j ){
            // 從左開始  依次使用左邊的元素和基準元素進行比較 直到找到比基準元素大的元素
            while(arr[i] < base && i < j){
                i++;
            }
            // 從右邊開始  依次使用右邊的元素和基準元素進行比較 直到找到比基準元素小的 元素
            while(arr[j] > base && i < j){
                j--;
            }
            if(i < j ){
                int temp = arr[i];
                arr[i]= arr[j];
                arr[j] = temp;
            }
        }
        sort(arr,left,i -1);
        sort(arr,i + 1 , right);

    }

[JAVA] Java 陣列、多維陣列，動態、靜態初始化，陣列JVM記憶體模型分析
2020-03-22
Java陣列JVM記憶體模型
Java陣列（基本+記憶體分析）
2020-07-25
Java陣列記憶體
java陣列記憶體的探究
2021-09-11
Java陣列記憶體
java陣列的記憶體分析
2021-01-01
Java陣列記憶體
Java的記憶體 -JVM 記憶體管理
2018-08-20
Java記憶體JVM
foreach迴圈和記憶體中的陣列
2017-08-07
記憶體陣列
java jvm 記憶體分配
2014-02-17
JavaJVM記憶體
小心遞迴中記憶體洩漏
2019-01-19
遞迴記憶體
JVM記憶體JAVA_OPTS
2021-02-06
JVM記憶體Java
JVM記憶體結構、Java記憶體模型和Java物件模型
2019-06-22
JVM記憶體Java模型物件
JVM 記憶體模型記憶體分配，JVM鎖
2016-05-20
JVM記憶體模型
常見的排序演算法：冒泡、快排、歸併
2024-04-20
排序演算法
Java記憶體管理 -JVM 垃圾回收
2018-08-27
Java記憶體JVM
如何遞迴實現陣列求和
2015-05-14
遞迴陣列
Java遞迴演算法
2023-11-27
Java遞迴演算法
JVM記憶體
2010-10-28
JVM記憶體
Java面試- JVM 記憶體模型講解
2019-10-22
Java面試JVM記憶體模型
JVM的藝術—JAVA記憶體模型
2020-12-17
JVMJava記憶體模型
JAVA物件在JVM中記憶體分配
2017-04-22
Java物件JVM記憶體
物件陣列的記憶體圖解
2017-04-22
物件陣列記憶體圖解
php對陣列進行全排列的非遞迴演算法
2017-11-07
PHP陣列遞迴演算法
一道遞迴陣列面試題
2020-08-02
遞迴陣列面試題
淺談JVM記憶體結構和 Java記憶體模型和 Java物件模型
2020-12-22
JVM記憶體Java模型物件
JVM(2)-Java記憶體區域與記憶體溢位異常
2019-03-22
JVMJava記憶體溢位
JVM記憶體分析
2018-05-27
JVM記憶體
JVM記憶體系列
2017-03-18
JVM記憶體
jvm記憶體區
2017-04-06
JVM記憶體
JVM記憶體分配
2015-04-03
JVM記憶體
jvm記憶體模型
2024-03-28
JVM記憶體模型
陣列在記憶體中的變化
2016-12-04
陣列記憶體
資料結構與演算法——歸併排序: 陣列&連結串列&遞迴&非遞迴解法全家桶
2020-12-19
資料結構演算法排序陣列遞迴
JVM(七):JVM記憶體結構
2019-07-02
JVM記憶體
遞迴求解陣列中的最大值
2016-04-14
遞迴陣列
php陣列轉xml的遞迴實現
2015-06-26
PHP陣列XML遞迴
楊輝三角與陣列遞迴累加
2016-06-01
陣列遞迴
JVM讀書筆記之java記憶體結構
2018-07-24
JVM筆記Java記憶體
JVM記憶體分配策略，及垃圾回收演算法
2019-09-11
JVM記憶體演算法
Java遞迴演算法的使用
2020-07-20
Java遞迴演算法

Java Day_6(陣列，JVM記憶體，遞迴演算法(冒泡，快排))

Java Day_6(陣列，JVM記憶體，遞迴演算法(冒泡，快排))

陣列

1.定義：

2.分類：

3.特點：

4.陣列的宣告和初始化：

5.陣列的元素的初始化：

6.陣列的預設值：

7.陣列的常用操作：

JVM記憶體

遞迴演算法：

常見的排序演算法：

氣泡排序：

快速排序：

相關文章