Java基础之Arrays，System，StringBuffer，Integer

Arrays工具类

Arrays是针对数组操作的工具类，里面的方法全是静态函数

public static String toString(Object[] arr);     //把数组转换成字符串

public static void sort(int[] arr);     //对数组进行排序

public static void binarySearch(int[] arr, int value);     //二分查找

               int [] arr = {12,24,35,46,75,169};

               System. out .println(Arrays. binarySearch(arr, 25));     //-3

               //如果没有找到，应该返回该数在数组中的位置，取反（从1开始数）

---

System

系统类，提供了静态变量和方法供我们使用

成员函数

     public static void exit(int value);     //退出JVM，非0表示异常退出

     public static long currentTimeMillis();     

                                        //返回当前系统时间的毫秒值和1970-1-1午夜之间的时间差

           //用于运行程序的时间计算

            long start = System. currentTimeMillis();

            for ( int x = 1; x <= 1000; x++)

           {

                System. out .println(x);

           }

            long finish = System. currentTimeMillis();

           System. out .println( "=============================" );

           System. out .print(finish - start);

           

            //用于返回1970-01-01到现在的毫秒

            long l = System. currentTimeMillis();

           System. out .println(l);

     public static void arraycopy(parameter1,2,3,4,5);

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

            int [] arr2 = {5,6,7,8,9};

            //参数1：复制哪个数组里面的内容

            //参数2: 从下标几复制到最后

            //参数3：替换到哪个数组里面

            //参数4：替换到这个数组的哪个位置

            //参数5：替换几个

           System. arraycopy(arr1, 2, arr2, 2, 3);

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

---

StringBuffer

      字符个数可以发生改变的字符串类。字符串缓冲区类。String一旦声明就不可以被改变，而StringBuffer是字符串常量池，原理是：StringBuffer采用的是缓冲区机制，一开始，首先开辟一块空间，然后随着数据的增多还可以继续开辟空间，随着数据的增多，它也会不断的增加空间的大小，最主要的是一直在操作用一个对象

      构造函数

          StringBuffer();  默认创建一个带16字节的字符串常量池

          StringBuffer(int capacity);     指定创建一个固定大小的字符串常量池

          StringBuffer(String str);     

               创建字符串常量池的时候，默认就有初始值，也可以用作String --> StringBuffer

               容量的话就是16 + str的长度

      成员函数

          public int length();      获取长度

          public int capacity();     获取容量

          添加功能

               public StringBuffer append(Object o);     //追加任意元素

               public StringBuffer insert(int offset, Object o);

                                   //在指定下标索引位置直接插入指定任意数据,从0开始数jkjjugh

          删除功能

              public deleteCharAt(int index);     //删除指定位置的字符

              public delete(int start, int end); 

                                    //删除指定位置到结束位置之间的字符(含头不含尾)                                                                                                          

          替换功能

              public StringBuffer replace(int start, int end, String str);

  

          截取功能

               public String substring(int start);

               public String substring(int start, int end);

          反转功能

               public StringBuffer reverse();

---

Integer

      原来没有封装类之前，只能声明并使用一些简单的对基本数据类型的操作。Integer类在对象中包装了一个基本类型的int的值-包装类，每一种基本数据类型都对应着一个对象。为了方便我们使用更过的功能。每一个基本数据类型都对应着包装类

     byte     --     Byte

     short     --     Short

     int     --     Integer

     long     --     Long

     double     --     Double

     float     --     Float

     char     --     Character

     boolean     --     Boolean

这里主要是Integer，其余的用法请参照API

构造函数

        Integer(int value);     //将int类型转换为Integer类型

     Integer(String s);     //将String类型转换为Integer类型，前提是字符串只能是数字

进制的转换（静态函数）

          public static String toBinaryString(int i); //转换成二进制

     public static String toHexString(int i);     //转换成八进制

     public static String toOctalString(int i);     //转换成十六进制

int --> String

     int num = 100;

     |--String s1 = num + "";

     |--String s2 = String.valueOf(num);

     |--int -->Integer（引用类型就可以toString()了，而Integer正好复写了toString()）--> String

         Integer i = new Integer(num);

        System. out.println(i.toString());

    |--public static String toString(int i);

     String s = Integer.toString(num);

String --> int

   String s = "100";

   |--public int intValue();

      Integer i = new Integer(s);

      int num = i.intValue():

   |--public static int parseInt(String str);

      int num = Integer.parseInt(s);

Integer新特性 -- JDK5

      自动装箱：也就是把基本类型直接赋值给引用类型

     Integer i = 100;     //默认相当于new Integer(100)；

      自动拆箱：也就是把引用类型直接拆成基本类型

      i = i + 200; 

     /*

          数据参与运算，要求类型一致。

          拆箱：  i + 200 = i.intValue() + 200

          装箱：i（对象） = 300 （基本数据类型值）

          其实：i = new Integer(i.intValue() + 200);

     */

开发原则：只要是对象，就做非Null判断

      NullPointerException

            Integer i = null ;

            i += 100;

            System. out .println(i);

面试题：

            Integer i1 = new Integer(127);

            Integer i2 = new Integer(127);

            System. out .println(i1 == i2); //false，比较地址

            System. out .println(i1.equals(i2)); //true，复写了equals函数，值一样

           

            Integer i3 = new Integer(128);

            Integer i4 = new Integer(128);

            System. out .println(i3 == i4); //false，比较地址

            System. out .println(i3.equals(i4)); //true，复写了equals函数，值一样

           

            Integer i5 = 128;

            Integer i6 = 128;

            System. out .println(i5 == i6); 

            //false,如果超出了byte范围，就自动装箱相当于new，如果要是没超出就同步指向byte缓冲区

            System. out .println(i5.equals(i6)); //true，简单到不行

           

            Integer i7 = 127;

            Integer i8 = 127;

            System. out .println(i7 == i8); //true，没有超出byte范围，那么就同步指向字符串常量池

            System. out .println(i7.equals(i8)); //true，简单到不行