Day08

Day08 数组的冒泡排序

        每排一趟确定一个位置

        public static void main(String [] args)

        {

                int [] a = {5,4,3,2,1};

                for(int i = 0; i < a.length-1;i++)

                {

                        for(int j=0;j < a.length-i-1;j++)

                        {

                                if(a[j]>a[j+1])

                                {

                                        int t = a[j];

                                        a[j] = a[j+1];

                                        a[j+1] = t；

                                }

                        }

                        System.out.println(Arrays.toString(a));

                }

    }

API

        API指的是java中所提供的类，接口；

        API指的是官方给出的类，接口的说明文档。

基本数据类型包装类

        8种基本数据类型 byte short int long double char boolean 是关键字声明的，不是面向对象的。

        Java是面向对象的语言，所以Java为每一种基本类型创造了一个包装类。这些包装类中包含了一个基本类型，还有一些 *** 作的方法。

                  基本数据类型                                           包装类

                        byte                                                   Byte

                        short                                                 Short

                        char                                                  Char

                        int                                                    Integer

                        long                                                  Long

                        float                                                   Float

                        double                                              Double

                        boolean                                           Boolean

例子：int--->Integer(包装类)

        Integer a = new Integer(10);

        System.out.println(a.intValue());//引用面向对象的思想

        System.out.println(Integer.MAX_VALUE);//int的最大值2147483647

        // public static final int MAX_VALUE = 0x7fffffff;16进制

        System.out.println(Integer.BYTES）;//4个字节

        System.out.println(Integer.SIZE);//32位

        System.out.println(Integer.MIN_VALUE);//int的最小值 -2147483648

        // public static final int MIN_VALUE = 0x80000000;8进制

包装类的用途：

        1）作为和基本数据类型对应的类型存在

        2）包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的 *** 作方法。 *** 作方法以数据类型转换为主，其他方法理解较为简单。

        Integer b = new Integer(“10”);//将String类型转换为int类型

        String s = “10a”；

        Integer b = new Integer(s);//出错，s必须是数不能带字母

compare：

        System.out.println(Integer.compare(10,12));//前小后大-1 相等0 前大后小1

        System.out.println(b.compareTo(12)）;//-1

        System.out.println(Integer.max(10,12));//12

        System.out.println(Integer.toBinaryString(2)）;//10 2进制

        System.out.println(Integer.toOctalString(8)）;//10 8进制

        System.out.println(Integer.toHexString(16)）;//10 16进制

        int a = 10;//基本类型

        Integer b = new Integer(a);//把基本类型包装成引用类型

        int c = b.intValue();//取出包装类型中的基本类型 包装类型转为基本类型

        Integer d = Integer.valueof(c);//把一个基本类型转为包装类型

        int e = Integer.parseInt("10");//把String转为基本类型

        System.out.println(d.toString()）;

自动装箱和拆箱

        

        int x =10;

        Integer y = x;

        

        Integer a = new Integer(10);

        int b = a；//默认调用intValue()

        Integer.valueof(x);

        //自动装箱时默认调用valueof() 里面缓存了 -128~+127对象在这个区间之内不重写创建对象，直接获取，超过就创建对象，m，n两个就不相等

        Integer m =127;

        Integer n = 127;

        System.out.println(m == n);//true

        Integer m =new Integer(127);

        Integer n = new Integer(127);

        System.out.println(m == n);//false 地址不同

        

object类

        toString():

        public String toString()

        {

                return(getClass().getname() + "@" + Integer.toHexString(hascode());

        }

        //如果我们的类重写了object中的toString（），那么就会调用我们自己的。

equals():

        Car c1 = new Car(100,"宝马"); Car c2 = new Car(100,"宝马");

                 

        System.out.println(c1.equals(c2));//false 重写之后就会true

        System.out.println(c1==c2);//false

        

        String s1 = new String("abc"); String s2 = new String("abc");         System.out.println(s1.equals(s2));//true

Arrays类

        java.util.Arrays

        int [] a = {1,2,3,4,5};

        int [] b = {1,2,3,4,6};

         System.out.println(a==b);//false

        System.out.println(Arrays.equals(a,b));//equals() 大家公认的是比较内容

sort()

        int [] a = {3,4,2,1,5};

        Arrays.sort(a);

        Arrays.sort(a,0,5);//0是下界，5是上界

        //二分查找 数组必须是有序的

        System.out.println(Arrays.binarySearch(a,1));

        System.out.println(Arrays.toString(a));