javase学习第12天(数组排序及元素查找）

数组排序元素查找

对数组排序最常用的是冒泡排序和选择排序：冒泡排序是每次将最大值都放在当前下标范围的最大下标处；选择排序就是每次都从前往后依次拿一个元素和其后面的所有元素比，来确定当前位置的元素。

冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现了最大索引出（也可根据要求把最小值放最后），第二次比较后，最大值放在了倒数第二的位置，一直到第二个元素确定了，整个数组的顺序也就确定了：

class Bubble{
    public static void main(String[]args){
        
    int [] arr={23,34,12,24,67,45,90};
    System.out.println("排序前");
    printArr(arr);
    System.out.println("排序后");
    sort(arr);
    printArr(arr);
    
    }
    //冒泡排序
    public static void sort(int[]arr){
        // for(int i=0;i<arr.length-1;i++){
            // for(int j=0;j<arr.length-1-i;j++){
        for(int i=arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){        
                if(arr[j]<arr[j+1]){
                    int tem=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tem;
                }
            
            }
        }
    }
    //打印数组
    public static void printArr(int [] arr){
            System.out.print("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
            System.out.print(arr[arr.length-1]+"]");
            }
            else{
            System.out.print(arr[i]+",");
            }
        }
        System.out.println();
    }
}

 

选择排序

从0索引开始，依次后后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处；

class Com{
    public static void main(String[]args){
        
    int [] arr={23,34,12,24,67,45,90};
    System.out.println("排序前");
    printArr(arr);
    System.out.println("排序后");
    printSele(arr);
    printArr(arr);
    
    }
    //冒泡排序
    public static void sort(int[]arr){
        // for(int i=0;i<arr.length-1;i++){
            // for(int j=0;j<arr.length-1-i;j++){
        for(int i=arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){        
                if(arr[j]<arr[j+1]){
                    int tem=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tem;
                }
            
            }
        }
    }
    //选择排序
    public static void printSele(int []arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int tem=arr[i];
                    arr[i]=arr[j];
                    arr[j]=tem;
                }
            }
        }
    }
    //打印数组结果
    public static void printArr(int [] arr){
            System.out.print("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
            System.out.print(arr[arr.length-1]+"]");
            }
            else{
            System.out.print(arr[i]+",");
            }
        }
        System.out.println();
    }
}

 

二分查找（折半查找）

二分查找的前提是数组已经是有序的了：

/**
二分查找
*/
class Sort{
    public static void main(String[]args){
        int [] arr={33,44,35,36,53,43,77,66,52};
        int[] arr0=ArrSort(arr);
        for(int i:arr0){
            System.out.print(i+"--");
        }
        System.out.println();
        System.out.println("-----------");
        int num=43;
        int max=arr.length;
        int min=0;
        int index=-1;
        while(min<=max){
            int mid=(min+max)/2;
            if(arr0[mid]==num){
                index=mid;
                break;
            }
            else if(arr0[mid]>num){
                max=mid-1;
            }
            else{
                min=mid+1;
            }
        }
        System.out.println(index);
    }
    
    public static int[] ArrSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int tem =arr[i];
                    arr[i]=arr[j];
                    arr[j]=tem;
                }
            }
        }
        return arr;
    }
}

Arrays类

主要有以下静态方法：

1、public static String toString(int[] a)：将数组转换成字符串

2、public static void sort(int[] a)：对一个int数组进行升序排序ascending

3、public static int binarySearch(int[] a,int key)：在数组中进行二分查找

基本类型包装类

byte --> :Byte

short -->:Short

int -->:Integer

long-->: Long

float -->:Float

double -->:Double

char -->:Character

boolean--> :Boolean

Integer类概述及其构造方法

Integer类在对象中包括了一个基本类型int的值；给类提供多个方法，能够在int类型和String类型之间互相转换。

1、public int intValue()：返回当前对象包装的基本数据类型的int值

2、public static int parseInt(String s)：将一个字符串转换成int值

3、public static String toString(int i)：将一个int值转换成字符串

4、public static Integer valueOf(int i)：用一个int值构建一个Integer对象

5、public static Integer valueOf(String s)：用一个字符串构建一个Integer对象

自动装箱

Integer x = new Integer(4);//可以直接写成 

Integer x = 4; //自动装箱。 

x = x + 5; //自动拆箱。通过intValue方法。

需要注意： 在使用时，Integer x = null;

上面的代码就会出现NullPointerException。