Java回顧--jdk jre jvm的簡單概念和三個常見排序算法

一、JRE、JDK、JVM：

　　JVM：　Java Virtual Machine，Java虛擬機，是Java可以跨平臺的核心所在，它只認識 .class文件，且同一段Java代碼在編譯後生成的.class文件都是同樣的，jvm識別.class文件中的字節碼指令並調用操做系統上的API（應用程序接口）完成動做，所以，編譯一次，到處運行。

　　JRE:　　Java Runtime Environment，Java運行時環境。它主要包含jvm 的標準實現和 Java 的一些基本類庫。

　　JDK：　Java Development Kit，Java 開發工具包。JDK是提供給Java開發人員使用的，其中包含了java的開發工具，也包括了JRE。因此安裝了JDK，就不用在單獨安裝JRE了。其中的開發工具：編譯工具，打包工具等。

　　三者之間的關係：使用JDK開發完成的java程序，經過編譯工具把.java文件編譯成.class文件，JVM先識別.class文件再調用API完成指令，在JRE（Java運行環境）運行，輸出結果。

二、八大基礎數據類型：

數據類型	佔用空間（字節數）	默認值
byte	1	(byte)0
short	2	(short)0
char	2	\u0000(null)
int	4	0
float	4	0.0f
double	8	0.0d
long	8	0L
boolean	-	false

 

 

 

 

　　

 

 

 

 

 三、冒泡排序、選擇排序、快速排序：

　　一、冒泡排序:

 1 public class BubbleSort{
 2       public  void  bubbleSort (Intrger[] arr) {
 3            for (int i=0; i < n; i++ ) {
 4                for (int j = 0; j < n- i - 1) {
 5                     if (arr [ j ] > arr[ j+1]) {
 6                          int temp=arr [ j ];
 7                          arr[ j ]=arr[ j+1 ];
 8                          arr[ j+1 ]=temp;
 9                     }
10                 }
11            } 
12       }          
13 }

　　

　　二、選擇排序：

　　

public class SelectionSort {
 
    public static void SelectSort(int[] arr){
        for(int i=0; i<arr.length-1; i++) {
            int index = i;
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            if(arr[index]!=arr[i]) {
                int temp=arr[index];
                arr[index]=arr[i];
                arr[i]=temp;
            }
        }
    }
   
}

 

　　三、快速排序：

　　

public class QuickSort {

    //對外開放調用的方法
    public static <T extends Comparable<? super T>> void sort(T[] arr) {
        sort(arr, 0, arr.length - 1);
    }
    
    private static <T extends Comparable<? super T>> void sort(T[] arr, int left, int right) {
        if (left >= right) return;
        int p = partition(arr, left, right);
        sort(arr, left, p - 1);
        sort(arr, p + 1, right);
    }

    //核心方法
    private static <T extends Comparable<? super T>> int partition(T[] arr, int left, int right) {
        T base = arr[left];  //從數組中選擇的基準值
        int j = left;
        for (int i = left + 1; i <= right; i++) {
            if (base.compareTo(arr[i]) > 0) {
                j++;
                swap(arr, j, i);
            }
        }
        swap(arr, left, j);
        return j;
        //返回一躺排序後基準值的下角標
    }

    private static void swap(Object[] arr, int i, int j) {
        if (i != j) {
            Object temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    private static void printArr(Object[] arr) {
        for (Object o : arr) {
            System.out.print(o);
            System.out.print("\t");
        }
        System.out.println();
    }

    public static void main(String args[]) {
        Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
        printArr(arr);
        //3  5  1  7  2  9  8  0  4  6
        sort(arr);
        printArr(arr);
        //0  1  2  3  4  5  6  7  8  9
    }

}

 

　　

 

四、二分（折半）查找法：找到指定數字的索引

　　要求：必須是順序存儲結構，必須按關鍵字有序排列。

 1 public static int dichotomy (int find ,int[] arr){ //find 爲數組中要查找的數
 2     if(null == arr || arr.length < 0){
 3         return -1;
 4     }
 5     int minIndex = 0;
 6     int maxIndex = arr.length - 1;
 7     int middleIndex = (minIndex + maxIndex)/2;
 8     while(minIndex <= maxIndex){
 9         if(find > arr[middleIndex]){
10             minIndex = middleIndex + 1;
11         }else if(find < arr[middleIndex]){
12             minIndex = middleIndex - 1;
13         }else{
14             return middleIndex;
15         }
16         middleIndex = (minIndex + maxIndex)/2;
17     }
　　　　return -1;    //目標未找到返回-1
18 }