Java 冒泡排序 二分查找 包装类 自动装箱

13.01_冒泡排序

  A：原理
  		相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。

public class MyTest2 {
    public static void main(String[] args) {
        //数组的排序：通过对数组元素的比较替换移动位置等等，是一个无序序
        //列，变成一个有序序列。
        int[] arr = {24, 69, 80, 57, 13};
        //冒泡排序：元素两两比较，把最大的元素往后放，经过一轮排序 ，最大
        //的元素，就出现在了最后面。
        //ctrl+alt+M 抽取方法
        //tuiDao(arr);
        //第一轮：比四次
        for(int j = 0;j < arr.length - 1;j++){
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }
    }
    private static void tuiDao(int[] arr){
        //第一轮：比4次
        for (int i = 0; i < arr.length - 1; i++) {
            if(arr[i] > arr[i+1]){
                int t = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第二轮：比3次
        for (int i = 0; i < arr.length - 1 - 1; i++) {
            if(arr[i] > arr[i+1]){
                int t = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第三轮：比2次
        for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第三轮：比1次
        for (int i = 0; i < arr.length - 1 - 1 - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.02_选择排序

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

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

    private static void tuiDao(int[] arr) {
        //第一轮：从0索引处开始
        int index = 0;
        for (int i = 0 + 1; i < arr.length; i++) {
            if(arr[index] > arr[i]){
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第二轮：从1索引处开始
        index = 1;
        for (int i = 0 + index + 1; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第三轮：从2索引处开始
        index = 2;
        for (int i = 0 + index + 1; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第4轮：从3索引处开始
        index = 3;
        for (int i = 0 + index + 1; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.03_插入排序

  A：原理
  		 从1索引处开始，把后面的每一个元素，插入到之前的一个有序序列，使之
  		 仍保持有序。

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 4, 3, 5, 7, 6, 8, 11, 10, 13, 12};
        //直接插入排序：从1索引处开始，把后面的每一个元素，插入到之前的一个有序序列，使之仍保持有序。
        // [9]  1, 2, 4, 3, 5, 7, 6, 8, 11, 10, 13, 12
        // [1,9] 2, 4, 3, 5, 7, 6, 8, 11, 10, 13, 12
        // [1,2,9] 4, 3, 5, 7, 6, 8, 11, 10, 13, 12
        // [1,2,4,9] 3, 5, 7, 6, 8, 11, 10, 13, 12
        // [1, 2, 3,4, 0] 9,5, 7, 6, 8, 11, 10, 13, 12

        //外层循环控制轮次
        for (int i = 0; i < arr.length; i++) {
            //当前元素 arr[i]  他前面的元素是 arr[i-1]
            //当前元素小于前面的元素，就进行交换。
            int j = i;
            while(j > 0 && arr[j] < arr[j-1]){
                int t = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.04_快速排序

public class QuickSortUtils {
    public static void quickSort(int[] arr, int start, int end) {
        //快速排序
        //挖坑填数，得到基准数所在的索引位置，以这个位置分成了左右两区，然
        //后我对左右两区进行递归调用
        if(start < end){
            //获取分成左右两区基准数所在的索引位置
            int index = getIndex(arr, start, end);  //挖坑填数
            //对左区进行递归
            quickSort(arr, start, index - 1);
            //对右区进行递归
            quickSort(arr, index + 1, end);
        }
    }

    //挖坑填数
    /*
    *   挖坑填数
               1. 将基准数挖出形成第一个坑。
               2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
               3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑
                 中。
               4.再重复执行2，3两步骤。
    * */

    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义基准数
        int x = arr[i];
        //重复2,3步骤
        while(i < j){
            //2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while(i < j && arr[j] >= x){
                j--;    //让索引往后退,找到了这个元素所在额位置
            }
            if (i < j) {
                arr[i] = arr[j];
                i++; //找到之后让i顺便递增一下
            }
            //3. 由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] < x) {
                i++;
            }
            //找到后也挖出此数填到前一个坑中。
            if (i < j) {
                arr[j] = arr[i];
                //顺便让j再减一下
                j--;
            }
        }
        //i=j
        // arr[j]=x;
        //把基准数填到最后一个坑中
        arr[i] = x;
        return i; //返回基准数所在的索引位置。
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 4, 3, 5, 7, 6, 8, 11, 10, 13, 12};
        QuickSortUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

13.05_基本查找和二分查找

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 5, 4, 3, 5, 7, 100};
        //基本查找：从头开始往后找
        int index = getIndex(arr,99);
        System.out.println(index);
    }

    private static int getIndex(int[] arr, int ele) {
        for(int i = 0; i < arr.length;i++){
            if(ele==arr[i]){
                return i;
            }
        }
        return -1;  //我们喜欢用-1 表示没有找到
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,4,4,6,7,8,9,10};
        //二分查找：前提是数组元素有序，原理：每次拿你找的这个元素，先从中
        //间位置找
        int index = getIndex(arr,4);
        int i = binarySearch0(arr,0,arr.length,4);
    }

    private static int getIndex(int[] arr, int ele) {
        //定义三个索引
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centerIndex = (minIndex + maxIndex)/2;
        //查找
        while(minIndex <= maxIndex){
            if(ele < arr[centerIndex]){
                maxIndex = centerIndex - 1;
            }else if(ele > arr[centerIndex]){
                minIndex = centerIndex + 1;
            }else{
                return centerIndex;
            }
            //再次计算中间索引
            centerIndex = (minIndex + maxIndex)/2;
        }
        return -1;
    }

    private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex;    //最小索引
        int high = toIndex - 1; //最大索引
        while(low <= high){
            int mid = (low + high)>>>1;    //计算中间索引
            //获取中间索引对应的元素
            int midVal = a[mid];
            if (midVal < key) {
                low = mid + 1;
            } else if (midVal > key) {
                high = mid - 1;
            } else {
                return mid; // key found
            }
        }
        return -1;  // key not found.
    }
}

13.06_Arrays类的概述和方法使用

  A：Arrays类概述
  		   针对数组进行操作的工具类。
  		   提供了排序，查找等功能。

1.toString()

public class MyTest2 {
    public static void main(String[] args) {
        //Java中给我们提供了已给Arrays工具类，专门针对数组，提供了一下方法

        int[] arr={1, 2, 3}; //[1,2,3]
        //arr = null;
        String s = Arrays.toString(arr);    //把数组中的元素，拼接成一个
        									//漂亮的字符串返回。
        System.out.println(s);
    }
}

2.sort()

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 4, 3, 5, 7, 6, 8, 11, 10, 13, 12, 100, -1, -2, 0, 6, 9, 5000};
        //Arrays.sort(arr);
        Arrays.sort(arr,0,5);   //你指定一段范围的元素，进行排序。
        System.out.println(Arrays.toString(arr));
    }
}

3.二分查找

public class MyTest2 {
    public static void main(String[] args) {
        //二分查找：前提是数组元素必须有序
        int[] arr = {1, 2, 3, 4, 4, 4, 6, 7, 8, 9, 10};
        int i = Arrays.binarySearch(arr,4);
        System.out.println(i);
    }
}

4.equals()

public class MyTest4 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        int[] arr2 = {1, 2, 3, 4};
        //比较两个数组的元素是否一致。
        boolean b = Arrays.equals(arr, arr2);
        System.out.println(b);
    }

5.copyOf()

public class MyTest2 {
    public static void main(String[] args) {
        //static int[] copyOf( int[] original, int newLength)复制旧数组
        //中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制
        //旧数组
        int[] arr = {1, 2, 3, 4, 5, 6, 8, 9};
        //从旧数组0索引处开始拷贝5个元素，到一个新数组中
        int[] newArr = Arrays.copyOf(arr,5);
        System.out.println(Arrays.toString(newArr));

        //根据起始索引和终止索引，从旧数组中拷贝一部分元素，到一个新数组中，
        //含头不含尾。
        int[] range = Arrays.copyOfRange(arr,2,5);
        System.out.println(Arrays.toString(range));
    }
}

13.07_基本包装类的概述

  A：为什么会有基本类型包装类
  			为了对基本类型进行更多的操作，更方便的操作，java就针对每一种基
  			本数据类型提供了对应的类类型。
  B：常用操作：		常用的操作之一：用于基本数据类型与字符串之间的转换。
  C：基本类型和包装类的对应：
  			byte				Byte
  			short				Short
  			int					Integer
  			long				Long
  			float				Floa
  			double				Double
  			char				Character
  			boolean				Boolean

public class MyTest2 {
    public static void main(String[] args) {
        /* A:
        需求:
        a:
        将100转换成二进制, 八进制, 十六进制
        b:
        判断一个数是否在int的范围内*/
        //Java为了我们更加方便的对基本数据类型来操作，给我们提供了基本类型
        //所对应的包装类型。

        int num = 100;
        String s = Integer.toBinaryString(num);    //转换成二进制
        System.out.println(s);
        String s1 = Integer.toOctalString(num);    //转换成八进制
        System.out.println(s1);
        String s2 = Integer.toHexString(num);      //转换成十六进制
        System.out.println(s2);

        int maxValue = Integer.MAX_VALUE;
        int minValue = Integer.MIN_VALUE;
        System.out.println(maxValue);
        System.out.println(minValue);
    }
}

13.08_Integer类的概述和构造方法

  A：Integer类概述
  			Integer类在对象中包装了一个基本类型int的值，
  			该类提供了多个方法，能在int类型和String类型之间相互转换，
  			还提供了处理int类型时非常有用的其他一些常量和方法
  B：构造方法
  			public Integer(int value)
  			public Integer(String s)		//要个一个字面上是数字的字符
  											//串，如果不是就会报错

public class MyTest2 {
    public static void main(String[] args) {
        //构造方法摘要
        //Integer(int value)
        //构造一个新分配的 Integer 对象，它表示指定的 int 值。
        //Integer(String s)
        //构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 
        //值。
        int num = 100;
        Integer integer = new Integer(num);
        //NumberFormatException: 数字格式化异常

        //要的是字面上是一个有效数字的字符串。
        Integer integer1 = new Integer("20");
    }
}

13.09_String和int类型的相互转换

  A：int —— String
  		   a：和""进行拼接
  		   b：public static String valueOf(int i)
  		   c：int —— Integer —— String
  		   d：public static String toString(int i)
  B：String —— int
  		   a：String —— Integer ——intValue();
  		   b：public static int parseInt(String s)

public class MyTest2 {
    public static void main(String[] args) {
        //String和int类型的相互转换
        //int---String
        int num = 100;
        String str = num + "";    //"100"
        String s = String.valueOf(num);    //"100"
        //方式3：
        Integer integer = new Integer(num);
        String s1 = integer.toString();

        //String---int  "666" -----  666
        String ss="666";
        //NumberFormatException
        int i = Integer.parseInt(ss);   //这个字符串，字面上一定是个数字
        System.out.println(i);

        Integer integer1 = new Integer(ss);
        int i1 = integer1.intValue();
        System.out.println(i1);
    }
}

13.10_JDK5的新特征自动装箱和拆箱

  A：JDK5的新特征：
  		   自动装箱：把基本类型转换为包装类类型
  		   自动拆箱：把包装类类型转换为基本类型
  B：注意事项：
  		   在使用时，Integer x = null;	代码就会出现NullPointerException。
  		   建议先判断是否为null，然后再使用

public class MyTest2 {
    public static void main(String[] args) {
        //JDK1.5 新加的特性
        //自动装箱:将一个基本数据类型，自动转换成他所对应的包装类型
        //自动拆箱:将一个包装类型，自动转换成他所对应的基本类型。

        int num = 100;
        //Integer integer = new Integer(num);
        Integer integer = num;
        Integer aa = 20;

        Integer integer2 = new Integer(num);
        int b = integer2;   //自动拆箱
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        Integer ii = 100;   //自动装箱
        ii+= 20;    //自动拆箱，自动装箱

        //手动拆装箱。
        int num = 100;
        //手动装箱 valueOf(num)
        Integer integer = Integer.valueOf(num);

        //手动拆箱 intValue()
        int i = integer.intValue();
        System.out.println(i);
        int b = 20 + i;
        System.out.println(b);
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);   //false
        //Integer类也重写了父类equals()方法，比较的是包装的值是否等
        System.out.println(i1.equals(i2));     //true
        System.out.println("===================");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);   //false
        System.out.println(i3.equals(i4));  //true
        System.out.println("===================");

        //自动装箱
        Integer i5 = 128;   //new Integer(128)
        Integer i6 = 128;   //new Integer(128)
        System.out.println(i5 == i6); // false
        System.out.println(i5.equals(i6)); //true
        System.out.println("===================");

        //自动装箱
        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);   //true
        System.out.println(i7.equals(i8));  //true
    }
}

   注意：
   		1.由于我们要经常使用Integer类，所以他会提前为int型创建-128~127一
   		  共256个对象，如果在自动装箱的时候给局部变量的int型值是在上面的范
   		  围之中，就会直接将之前创建好的对象的地址值赋给等号左边的局部变量。
   		  所以(i7 == i8)，但是(i5 !== i6)