数组排序，包装类

1.数组排序
1.冒泡排序

//冒泡排序
public class Test {
    public static void main(String[] args) {
//        数组排序：将数组中杂乱无章的序列，按照一定的方法进行排序
//        排序方法：冒泡排序，选择排序，插入排序，快速排序，归并排序，基数排序，堆排序等。


//        冒泡排序：将数组中的元素两两排序，大的往后放，经过一轮比较后，最大的元素，就出现在了最后面
//        冒泡排序规律：五个数比较了四轮，第一轮比较了四次
//        第二轮比较了三次
//        第三轮比较了二次
//        第四轮比较了一次
   int[] arr={32,4,77,51,5151};
        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;
                }
            }
        }

        System.out.println();

    }
}

2.选择排序，根据理解手打排序

//选择排序
public class Test01 {
    public static void main(String[] args) {
//选择排序：从索引处为0的位置开始，依次跟他后面的元素挨个比较，小的元素往前放，经过一段时间比较后，最小的元素就出现在了最前面
        int[] arr = {213, 312, 135, 123, 112, 21, 214, 12,65,235,23,6,6,61,61,612,343,46,2,25,35,325,2,235,25};
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = j; i < arr.length-1; i++) {
                if (arr[j] > arr[i+1]) {
                    int t = arr[i+1];
                    arr[i+1] = arr[j];
                    arr[j] = t;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            int t= arr[i];
            System.out.print(t+"  ");
        }
        System.out.println(arr.length);
    }
}

3.直接插入排序

//直接插入排序
public class Test2 {
    public static void main(String[] args) {
//        每次拿后面的元素插入到之前的有序序列当中，使之仍保持有序，就是说给了一个数组，认定这个数组的第一个元素肯定是有序的，因为
//        只有一个元素嘛~，然后将第二个元素放进去与第一个元素比，第二个元素小的话就跟第一个元素换个儿，然后在将第三个元素拿进去比，
//        如果3元素比2元素小，，换个，但是吧，你不知道3元素比不比1元素小，所以还要在进行比一次，如果小，在换个儿，不小了这个元素就加进来
//        了，这轮就结束了，在进行下一轮循环，以此类推
        int[] arr={2,4,145,1,15,12,51,512,511,521,541,531,51,3};
        for (int i = 1; i < arr.length; i++) {
            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));
    }
}

4.数组中查找元素得方法：二分法查找元素

public class Test {
    //    基本查找
    public static void main(String[] args) {
        int[] arr = {2, 3, 12, 421, 41, 4, 124, 214, 42};
//    查找元素中的元素值所代表的索引:
//    1.基本查找方法：从头遍历到尾
        System.out.println(findIndex(arr, 124));
//        2.二分法查索引（前提是数组有序）
        int[] arr1={1,2,32,45,67,84,123,455,578,3788};
        System.out.println(getIndex(arr1, 788));

    }
//二分法查找方法：(这里可以用for循环，也可以用while循环，其实while循环更方便)
    private static int getIndex(int[] arr0, int i) {
        int first=0;
        int last=arr0.length;
        int middle=(first+last)/2;//这里记住了，如果有变量a，变量b，且c与变量a，b有关系，a，b进了一个更小的{}范围，
//        但是c没进去，则{}里面的变化会改变最终a，b的值，不改变c的值，即使在{}外边c与ab有关系，也不改变c的值，c的值还是最开始
//        的定义值，除非你把c放进{}去，才会最终改变c的值，否则无论ab怎么变化，都不改变c的值，c还是最开始的值，记住就行
//        一句话总结，abc必须全进{}里面，最终值才改变，否则只要有没进去的，就是最开始的值，即使abc直接有关系也不会影响没进去的
//        这个值,记住就行
//        ===============(如果{}外面的c和ab的关系式子与里面的不一样,最终输出的为{}里面的c与ab关系的那个值)
        for (int i1 = 0; i1 < arr0.length; i1++) {
            if (i>arr0[middle]&&first<=last){
                first=middle+1;
            }else if (i<arr0[middle]&&first<=last){
                last=middle-1;
            }else if (i==arr0[middle]&&first<=last){
                return middle;
            }
            middle=(first+last)/2;//这的关系式与{}外面的不一样,以里面的为准,最终输出也是输出这的,类似多态的子类,记住就行
            //感觉就好像{}外面的变量进去了里面就好像多态一样,变量也可以这样去理解,先这么记
        }
        System.out.println(first);
        System.out.println(last);
        System.out.println(middle);
        return -1;
    }


    //基本查找方法
    private static int findIndex(int[] arr, int i) {
        for (int i1 = 0; i1 < arr.length; i1++) {
            if (i == arr[i1]) {
                return i1;

            }

        }
        return -1;
    }
}

2.包装类
1.包装类概述

//包装类的方法全部都是静态的
public class Test {
    public static void main(String[] args) {
//        Java为了我们方便操作这些基本类型,针对这些基本类型,Java对应的提供其包装类型
//        包装类,引用类型
//        除了int类型对应的是Integer包装类和char对应的是Character包装类,其余的都是类型和包装类是一样的单词



    }
}

public class Test1 {
    public static void main(String[] args) {
//        Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
//        将int类型的10进制转换为对应的2,8,16进制
        int a=10;
        String s = Integer.toBinaryString(a);//返回String类型的字符串//2进制
        String s1 = Integer.toHexString(a);//16进制
        String s2 = Integer.toOctalString(a);//8进制
        int maxValue = Integer.MAX_VALUE;//MAX_VALUE为静态常量,表示int类型的所取的最大值
        int minValue = Integer.MIN_VALUE;//MIN_VALUE,代表int类型的最小取值

    }
}

2.Integer得构造方法：

//Integer的构造方法
public class Test2 {
    public static void main(String[] args) {
//        构造方法一:
//        将基本类型构造成一个包装类型
        int a = 100;
        Integer integer = new Integer(a);
        System.out.println(integer);//重写了toString
//        构造方法二:\
//        字符串也可以放到构造方法里面,变成了包装类型
        String s = "123";//字符串里面一定要写对应的基本类型值(字面上一定对应一个有效数字)
        Integer integer1 = new Integer(s);
        System.out.println(integer1);
//        如果你传的字符串里面除了基本类型数值(有效数字),还有别的东西,那会出一个异常
//        例:
//        Integer a123 = new Integer("a123");
//        System.out.println(a123);//有异常
    }
}

3.Integer和String类型互换：

/int类型和String类型的相互转换（不光是int类型，其余的类型也都是这些方法和String类型进行相互转换）
public class Test3 {
    public static void main(String[] args) {
//        int到String类型:
//        方法一:
        int a=100;
        String s=a+"";//拼串
        System.out.println(s);
//        方法二:valueOf
        String s1 = String.valueOf(a);
        System.out.println(s1);
//        方式三:
        Integer integer = new Integer(a);
        System.out.println(integer);
//        ====================================================================================
//        String类型转换为int类型
//        方式一:构造方法(先包装,在调方法)
        String s3="100";
        Integer integer1 = new Integer(s3);
        int i = integer1.intValue();
        System.out.println(i);
//        方式二:Integer的静态方法
        int i1 = Integer.parseInt("123");//传parseInt的方法的参数,字面上必须是有效数字,如果不是,会报异常
        System.out.println(i1);
        System.out.println("=========================================");
        long r=100000l;
        long l = Long.parseLong("2000L");//除了int外，其余基本类型也有这些方法,当然，用这些的前提条件也一样
        System.out.println(l);
        Boolean.parseBoolean("truedasdasdsad");//只有boolean类型这样，如果boolean类型的字符串类型是胡写的，不是严格按照
//        前提条件写的，最后输出的是false，不会报异常，记住就行

    }
}

4.自动拆装箱

//自动拆装箱
public class Test {
    public static void main(String[] args) {
//        自动装箱:将一个基本数据类型,自动转换成它所对应的包装类型
//        自动拆箱:将一个包装类型自动转换成一个基本数据类型
//        自动装箱示范:
        int a=10;
        Integer i=a;//直接赋值过来,其实他是内部进行了操作,这个叫自动装箱
//        自动拆箱示范:
        Integer s = new Integer(20);

   int r=s+2;//内部完成,将引用类型s自动转换成基本类型
        System.out.println(r);
//        =========================手动装箱,手动拆箱老师讲完了,但是我觉得没必要去在看,因为这个没用过
        int aa=100;
        Integer integer = Integer.valueOf(a);//这里是手动装箱，
    }
}

//所有的包装类都是重写了equals的方法
//对于自动装箱的时候对应的值是-128到127的时候的分析，这个时候会调静态代码块儿中初始化的那256个对象中的一个
public class Test1 {
    public static void main(String[] args) {
         Integer i=100;//自动装箱,右边为int类型,赋值给左边,要进行自动装箱
        i+=200;//先自动拆箱变为基本类型,然后在自动装箱(右边为int 赋值给Integer)变为Integer
        Integer[] a={31,21,341,2,41,4,1244,2,new Integer(23)};//这里面就进行了自动装箱(基本类型是)
        int[] aa={new Integer(25),423,new Integer(23141)};//这里面的引用变量就是自动拆箱,右边赋左边,记住了,根据
//        右边赋左边去判断自动拆装箱
        Integer i1=128;
        Integer i2=128;//这里是自动装箱，用这个的时候直接内部自动调用引用.valueOf()方法，这个方法里面是返回一个根据装箱初始化的
//        值对应的对象，在-128到127之间的是会返回初始化里面的对象，只要在这个范围内的时候，就直接返回这里面的对象，超过这个值，才会返回
//        一个new的对象，即一个新的对象
        System.out.println(i1==i2);//false
        System.out.println(i1.equals(i2));//true
        Integer i3=127;
        Integer i4=127;
        System.out.println(i3 = i4);//true（范围是在-128-127之间）
        System.out.println(i3.equals(i4));//true
//        在Integer类里面，有一个静态的内部类，叫IntegerCache，它有一个静态代码块儿，当Integer类一加载，静态的内部类IntegerCache
//        也加载（这里要注意，内部类中要是有静态的内部类的话，一加载外部类，就相当于加载了这个类了，加载这个类，静态的内部类就会首先加载），
// 静态代码块儿也会加载，静态代码块儿里面有一个 Inteher类型的Cache数组，这个数组里面就会放一些提前创建好的Integer对象
//        当我们采用这种方式定义一个Integer对象时，如果这个值在-128-127之间的时候，他会从Cache数组中返回一个对象给你，这里要注意
//        这个Cache的数组是静态的，所以在静态代码块儿里面直接用他是没有问题的，跟静态代码块儿一起来的,带静态得就相当于是同一时间段全部都存在了
//        但是Static静态代码块儿和Static静态常量有着先后顺序，记住了
//        静态代码块儿里面的东西都要是静态的

    }
}