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 }