数组排序与基本类型包装类

数组排序与基本类型包装类

一、排序

1、冒泡排序

元素两两比较，把最大的元素往后放，经过一轮排序 ，最大的元素，就出现在了最后面。
public class Mytest3 {
    public static void main(String[] args) {
        int[] arr = {1,43,23, 2,54, 3};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j< arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

}

2、选择排序

选择排序：每一次拿一个元素，和他后面的每一个元素，挨个比较，小的往前放，经过一轮比较，最小的元素就会出现在最前。如此往复，经过几轮数组就排序好了
public class Demo3 {
    public static void main(String[] args) {
        int []arr={5,7,2,22,43,55,32,1};
        for (int index = 0; index < arr.length - 1; index++) {
            for (int i = index+1; i < arr.length; i++) {
                if (arr[index]>arr[i]){
                    int a=arr[i];
                    arr[i]=arr[index];
                    arr[index]=a;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

3、快速排序

    1. 将基准数挖出形成第一个坑。
    2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    4.再重复执行2，3两步骤。
public class Dmeo5{
    public static void main(String[] args) {
        int []arr={2,3,5,23,15,1,54,43};
        Quick.quick(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}
class Quick{
    public static void quick(int []arr,int start,int end){
        if (start<end) {
            int index = getIndex(arr, start, end);
            quick(arr, start, index - 1);
            quick(arr, index + 1, end);
        }
    }
    private static int getIndex(int[] arr, int start, int end) {
        int i=start;
        int j=end;
        int a=arr[i];
        while (i<j&&arr[j]>=a){
            j--;
        }
        if (i<j){
            arr[i]=arr[j];
        }
        while (i<j&&arr[i]<a){
            i++;
        }
        if (i<j){
            arr[j]=arr[i];
            j--;
        }
        arr[i]=a;
        return i;
    }
}

4、插入排序

直接插入排序：从1索引处开始，把后面的每一个元素，插入到之前的一个有序序列，使之仍保持有序。
public class Demo6 {
    public static void main(String[] args) {
        int []arr={6,4,2,86,44,23,12,42};
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
               if (arr[j]<arr[j-1]) {
                   int t = arr[j];
                   arr[j] = arr[j - 1];
                   arr[j - 1] = t;
               }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

二、二分查找

二分查找：前提是数组元素有序，原理：每次拿你找的这个元素，先从中间位置找.
public class Demo4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int index=getIndex(arr,3);
        System.out.println(index);
    }
    private static int getIndex(int[] arr, int i) {
        int min=0;
        int max=arr.length-1;
        int mid=(min+max)/2;
        while (min<=max){
            if (i<arr[mid]){
                max=arr[mid]-1;
            }else if (i>arr[mid]){
               min=arr[mid]+1;
            }else {
                return  mid;
            }
            mid=(min+max)/2;
        }
        return -1;
    }
}

三、基本类型包装类

基本类型包装类的概述:

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

常用的操作之一：用于基本数据类型与字符串之间的转换。

基本数据类型与包装类的对应关系:

byte → Byte

short → Short

int → Integer

long → Long

float → Float

double → Double

char → Character

boolean→ Boolean


下面简单说说Integer类的概述:

Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

Integer构造方法:



public Integer(int value)

构造一个新分配的 Integer 对象，它表示指定的 int 值。

public Integer(String s)

构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。


String和int类型的相互转换

1）int -- String
a:和""进行拼接
b:public static String valueOf(int i
c；tostring方法；
d:int--Integer--String。
2）String -- int
a:String -- Integer -- int
b:public static int parseInt(String s)

JDK5的新特性自动装箱和拆箱
自动装箱：
把基本类型转换为包装类类型
自动拆箱：
把包装类类型转换为基本类型

注意:在使用时，Integer  x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。