day12

1. 数组高级
   1.1 选择排序
   概述:从第一个位置元素到倒数第二个位置元素依次和后面的每个元素做比较,依次得到每个位置上的最值

 //选择排序
    public static void selectSort(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 temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

1.2 冒泡排序
概述:冒泡排序（Bubble Sort）,它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

//冒泡排序
    public static void bubbleSort(int[] arr) {
        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 temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

1.3 二分查找
也叫折半查找,前提是数组必须是有序的,每次找到数组的中间元素做比较.

//二分查找
    public static int binarySearch(int[] arr, int num) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        while (min <= max) {
            if (num > arr[mid]) {
                min = mid + 1;
            } else if (num < arr[mid]) {
                max = mid - 1;
            } else {
                return mid;
            }
            mid = (min + max) / 2;
        }
        return -1;
    }

import java.util.Arrays;
//快排
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {5, 1, 9, 7, 4, 6, 3, 10};
        QuickSort(arr, 0, 7);
        System.out.println(Arrays.toString(arr));
    }
    public static void QuickSort(int[] arr, int low, int high) {
        if (low > high) {
            return;
        }
        int i = low;
        int j = high;
        int base = arr[low];
        while (i < j) {
            while (arr[j] >= base&&i<j) {
                j--;
            }
            while (arr[i] <= base&&i<j) {
                i++;
            }
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        arr[low] = arr[i];
        arr[i] = base;
        QuickSort(arr, low, i - 1);
        QuickSort(arr, i + 1, high);
    }
}

3. 包装类
   3.1包装类:(引用数据类型,类)
   为每种基本数据类型都提供了对象的引用数据类型
   byte Byte
   short Short
   int Integer
   long Long
   float Float
   double Double
   char Character
   boolean Boolean

3.2
装箱: 把基本数据类型转成包装类
拆箱: 把包装类转成基本数据类型
//装箱
int a = 10;
Integer a2 = Integer.valueOf(a);
//拆箱
int a3 = a2.intValue();

3.3Integer
常用的基本进制转换
public static String toBinaryString(int i) 转成2进制的字符串
public static String toOctalString(int i) 转成8进制的字符串
public static String toHexString(int i) 转成16进制的字符串
十进制到其他进制
public static String toString(int i,int radix) radix: 转成几进制
其他进制到十进制
public static int parseInt(String s,int radix); s: 其他进制的字符串 radix: 该字符串对应的进制

public class IntegerDemo {
    public static void main(String[] args) {
        int i = 50;
        System.out.println(Integer.toBinaryString(i));
        System.out.println(Integer.toHexString(i));
        System.out.println(Integer.toOctalString(i));
        System.out.println(Integer.toString(i,30));
        System.out.println(Integer.parseInt("123",8));

3.4Character
public static boolean isUpperCase(char ch)
public static boolean isLowerCase(char ch)
public static boolean isDigit(char ch)
public static char toUpperCase(char ch)
public static char toLowerCase(char ch)

3.5Math
public static int abs(int a) 求绝对值
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static double pow(double a,double b) a的b次方
public static double random() 求随机数: [0-1)
public static int round(float a) 四舍五入取整
public static double sqrt(double a) 求算数平方根

public class MathDemo {
    public static void main(String[] args) {
        double i=17.9;
        System.out.println(Math.abs(i));
        System.out.println(Math.ceil(i));
        System.out.println(Math.floor(i));
        System.out.println(Math.pow(3,4));
        System.out.println(Math.sqrt(144));
        System.out.println((int)(Math.random()*100+1));

    }
}

3.6System
public static void gc()
public static void exit(int status)
public static long currentTimeMillis() 获取当前时间的毫秒值 1970年1月1日0:0:0
// 1. 监测方法的运行时间
// 2. 生成不重复的序列
使用毫秒值 + 随机数
使用纳秒值: System.nanoTime (只用来生成不重复的序列,不用来计算时间)
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
数组的拷贝:
src: 源数组 从哪里拷贝
srcPos: 源数组要拷贝的位置,从哪开始拷贝
dest: 目标数组,拷贝到哪里
destPos: 目标数组的位置
length: 拷贝的长度
final: 最终不变的
finalize: 用于垃圾回收
finally: try…catch…finally