07 Object类，Scanner，Arrays类，String类，StringBuffer类，包装类

Object类的概述：
* A:Object类概述
    * 类层次结构的根类
    * 所有类都直接或者间接的继承自该类
* B:构造方法
    * public Object()
    * 子类的构造方法默认访问的是父类的无参构造方法

Object类的hashCode()方法

* public int hashCode()
    * a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
    * b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同

。

public class Demo_HashCode {
    public static void main(String[] args) {
        Object object1 = new Object();
        int hashCode = object1.hashCode();

        System.out.println(hashCode);
    }
}

Object类的getClass()方法
    * public final Class getClass()
    * a:返回此 Object 的运行时类。
    * b:可以通过Class类中的一个方法，获取对象的真实类的全名称。    
        * public String getName()

public class Demo_GetClass {

    public static void main(String[] args) {
        Person person = new Person();

        Class class1 = person.getClass();  // 获取该对象的字节码文件
        String name = class1.getName();  // 获取名称
        System.out.println(name); // com.fly.bean.Person

    }

}

Object类的toString()方法
    * public String toString()
    * a:返回该对象的字符串表示。
*
        
        public Stirng toString() {
            return name + "," + age;
        }
    * b:它的值等于：
        * getClass().getName() + "@" + Integer.toHexString(hashCode())
    * c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。

public class Demo_ToString {
    public static void main(String[] args) {
        /**
         *   public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode

());
             }
         */
        Person person = new Person("张三",18);
//        String string = person.toString();
//        System.out.println(string); // com.fly.bean.Person@15db9742

        System.out.println(person.toString());
        System.out.println(person); // 如果直接打印对象的引用，会默认调用toString方

法
    }
}

Object类的equals()方法
    * a:指示其他某个对象是否与此对象“相等”。
    * b:默认情况下比较的是对象的引用是否相同。
    * c:由于比较对象的引用没有意义，一般建议重写该方法。

public class Demo_Equals {
    public static void main(String[] args) {
        /*
           public boolean equals(Object obj) {
                return (this == obj);
           }
        Object中的equals方法是比较对象的地址值
        开发中通常比较的是对象的属性值，相同属性是同一个对象
         * */
        Person person1 = new Person("张三",10);
        Person person2 = new Person("李四",11);
        Person person3 = new Person("李四",11);

        boolean b = person1.equals(person2);  // 比较两个对象是否相等
        System.out.println(b); //false

        System.out.println(person2.equals(person3)); //true // 重写之后比较的是对象

的属性值
    }
}

==号和equals方法的区别
    ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是

值,引用数据类型比较的是地址值
    equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重

写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是

对象中的属性
Scanner：

import java.util.Scanner;

public class Demo1_Scanner {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        int i = scanner.nextInt();
//        System.out.println(i);  //输入不是int类型 会抛出 InputMismatchException
        if (scanner.hasNextInt()) {
            int i = scanner.nextInt();
            System.out.println(i);
        }else {
            System.out.println("你输入的类型有误");
        }
    }

}

import java.util.Scanner;

public class Demo2_Scanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        System.out.println(string);  // 以\r\n作为结束标志
    }
}

public class Demo1_String {

    public static void main(String[] args) {
        String string = "abc"; // 字符串字面值"abc"也可以看成是一个字符串对象
        string = "def"; // 字符串是常量，一旦被赋值，就不能被改变
                        // 此时的"abc" 已经变为垃圾值
        System.out.println(string);

            // 常见的构造方法
        String string2 = new String(); // 空构造
        System.out.println(string2);

        byte[] bytes = {97,98,99};
        String string3 = new String(bytes); // 把字节数组转成字符串
        System.out.println(string3); // abc

        String string4 = new String(bytes, 1, 2); // 把字节数组的一部分转成字符串,

                              // String(byte[] bytes,int

index,int length)
        System.out.println(string4); // bc

        char[] value = {'a','b','c'};
        String string5 = new String(value); // 把字符数组转成字符串
        System.out.println(string5);  // abc

    }

}

String类的常见面试题：

* 1.判断定义为String类型的s1和s2是否相等
    * String s1 = "abc";
    * String s2 = "abc";
    * System.out.println(s1 == s2);     // true
    * System.out.println(s1.equals(s2)); // true
* 2.下面这句话在内存中创建了几个对象?  2个，一个在常量池，一个在堆内存中
    * String s1 = new String("abc");
* 3.判断定义为String类型的s1和s2是否相等
    * String s1 = new String("abc");
    * String s2 = "abc";
    * System.out.println(s1 == s2);    //false    ,地址不相同
    * System.out.println(s1.equals(s2)); //true
* 4.判断定义为String类型的s1和s2是否相等
    * String s1 = "a" + "b" + "c";
    * String s2 = "abc";
    * System.out.println(s1 == s2);    // true,java的常量优化机制
    * System.out.println(s1.equals(s2));// true
* 5.判断定义为String类型的s1和s2是否相等
    * String s1 = "ab";
    * String s2 = "abc";   // 常量池
    * String s3 = s1 + "c"; // 指向堆内存的toString中
    * System.out.println(s3 == s2); //false
    * System.out.println(s3.equals(s2)); // true

String类的判断功能：

    * boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
    * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    * boolean contains(String str):判断大字符串中是否包含小字符串
    * boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
    * boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
    * boolean isEmpty():判断字符串是否为空。

"" 与null：

        /*
         *  ""是字符串常量，同时时一个String类的对象
         *  null是空常量，不能调用任何方法，否则或出现空指针异常，可以给任意的引用

数据类型赋值
         * */
        String string = "";
        String string2 = null;

        System.out.println(string.isEmpty()); // true
    //    System.out.println(string2.isEmpty()); // NullPointerException

String类的获取功能：

/*String类的获取功能
    * int length():获取字符串的长度。
    * char charAt(int index):获取指定索引位置的字符
    * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
    * int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
    * int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现

处的索引。
    * int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一

次出现处的索引。
    * lastIndexOf
    * String substring(int start):从指定位置开始截取字符串,默认到末尾。
    * String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。顾头

不顾尾*/

public class Demo2_StringMethod {

    public static void main(String[] args) {
        // 获取字符串的长度
        String string = "fly";
        System.out.println(string.length()); //
        String string2 = "飞?";
        System.out.println(string2.length()); // 2
        // 获取指定索引位置的字符
        char c = string2.charAt(0);
        System.out.println(c); //飞
        //返回指定字符在此字符串中第一次出现处的索引,找不到返回-1
        int i = string.indexOf('l');
        System.out.println(i); //

    }

}

String的转换功能：
    * byte[] getBytes():把字符串转换为字节数组。
    * char[] toCharArray():把字符串转换为字符数组。
    * static String valueOf(char[] chs):把字符数组转成字符串。
    * static String valueOf(int i):把int类型的数据转成字符串。
        * 注意：String类的valueOf方法可以把任意类型的数据转成字符串

* String toLowerCase():把字符串转成小写。(了解)
    * String toUpperCase():把字符串转成大写。
    * String concat(String str):把字符串拼接。
    // gbk码表，一个中文代表两个字节，第一个字节肯定是负数

String类的其他功能
* A:String的替换功能   找不到不替换
    * String replace(char old,char new)
    * String replace(String old,String new)
* B:String的去除字符串两空格及案例演示
    * String trim()
* C:String的按字典顺序比较两个字符串
    * int compareTo(String str) 比较的是Unicode码表
    * int compareToIgnoreCase(String str) 不区分大小写

import java.util.Scanner;

public class Test2 {

    public static void main(String[] args) {
        /*
         * 输入的字符串反转
         * */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String string = scanner.nextLine();

        String s = "";
        char[] c = string.toCharArray(); // 将字符串转换为字符数组
        for (int i = c.length-1; i >= 0; i--) {
            s =s + c[i];
        }
        System.out.println(s);
    }

}

public class Demo1_StringBuffer {

    public static void main(String[] args) {
        /*
         * StringBuffer的构造方法的使用
         * */
        StringBuffer sb =  new StringBuffer();
        System.err.println(sb.length()); //0  容器的字符个数，实际值
        System.out.println(sb.capacity()); //16 容器的初始容量，理论值

        StringBuffer sb2 = new StringBuffer(10);
        System.out.println(sb2.length()); //
        System.out.println(sb2.capacity()); //

        StringBuffer sb3 = new StringBuffer("fly");
        System.out.println(sb3.length()); //
        System.out.println(sb3.capacity()); //19  16+3
    }

public class Demo2_StringBuffer {

    public static void main(String[] args) {
        StringBuffer sBuffer = new StringBuffer();// StringBuffer是字符串缓冲区，

new在堆内存创建一个对象
        StringBuffer sb = sBuffer.append(true);  // 不会创建对象，在不断向原缓冲区

添加字符
        StringBuffer sb2 = sBuffer.append("fly");
        StringBuffer sb3 = sBuffer.append(123);

        System.out.println(sb); // truefly123  StringBuffer类重写了toString方法
        System.out.println(sb2); // truefly123
        System.out.println(sb3); // truefly123
    }

}

public class Demo3_StringBuffer {
    public static void main(String[] args) {
//        sbDelete(); // 删除功能
/*        StringBuffer sbBuffer = new StringBuffer("hello");
        sbBuffer.replace(0, sbBuffer.length(), "hi");
        System.out.println(sbBuffer); //hi

        sbBuffer.reverse(); // 反转
        System.out.println(sbBuffer); //ih
*/
        StringBuffer sBuffer2 = new StringBuffer("hello world");
//        String str = sBuffer2.substring(6);   // 截取
//        System.out.println(str);  // world

        String str2 = sBuffer2.substring(0, 5);
        System.out.println(str2); // hello

    }

    private static void sbDelete() {
        StringBuffer  sBuffer = new StringBuffer();
//        sBuffer.deleteCharAt(5);
//        System.out.println(sBuffer); // StringIndexOutOfBoundsException 删除不存在

的
        sBuffer.append("fly");
//        sBuffer.deleteCharAt(2);
//        System.out.println(sBuffer); // fl

        sBuffer.delete(0, sBuffer.length()); // 清空缓冲区
        System.out.println(sBuffer);
    }
}

public class Demo4_StringBuffer {

    public static void main(String[] args) {
        // String转为StringBuffer
        StringBuffer sBuffer = new StringBuffer("fly");
        System.out.println(sBuffer);

        StringBuffer sBuffer2 = new StringBuffer();
        sBuffer2.append("fly");
        System.out.println(sBuffer2);
        // StringBuffer转为String
        StringBuffer builder = new StringBuffer("fly");
        String string = new String(builder);
        System.out.println(string);

        String string2 = builder.toString();
        System.out.println(string2);

        String string3 = builder.substring(0, builder.length());
        System.out.println(string3);
    }

}

StringBuffer与StringBuilder
每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无

需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了

一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，

因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

public class Demo5_StringBuffer {

    public static void main(String[] args) {
        String string = "hello";
        System.out.println(string); // hello
        change(string);
        System.out.println(string); // hello

        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("hello");
        System.out.println(stringBuffer); //hello
        change(stringBuffer);
        System.out.println(stringBuffer); //helloworld
    }

    private static void change(StringBuffer stringBuffer) {
        stringBuffer.append("world");
    }

    private static void change(String string) {
        string += "world"; // String类虽然是引用数据类型，但当作参数传递时和基本数

据类型是一样的
    }

}

排序：

public class Demo1_Array {

    public static void main(String[] args) {
        int[] arr = {23,69,70,57,15};

//        bubbleSort(arr);
        selectSort(arr);
        stringPrint(arr);
    }
    // 冒泡排序
    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;
                }
            }
        }
    }
    //选择排序
    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;
                }
            }
        }
    }

    public static void stringPrint(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

}

二分查找：

public class Demo2_Array {

    public static void main(String[] args) {
        // 二分查找
        // 前提必须是有序的
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 55)); //
        System.out.println(getIndex(arr, 88)); //-1
    }
    public static int getIndex(int[] arr,int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;

        while(arr[mid] != value) {
            if(arr[mid] > value) {
                max = mid - 1;
            }else if(arr[mid] < value) {
                min = mid + 1;
            }
            mid = (min + max) / 2;
            if(min > max) {
                return -1;
            }
        }
        return mid;
    }

}

Arrays类的使用：

import java.util.Arrays;

public class Demo3_Arrays {
    // Arrays类的使用
    public static void main(String[] args) {
        int[] arr = {33,22,55,11,44};
        // 数组转字符串
        System.out.println(Arrays.toString(arr)); //[33, 22, 55, 11, 44]

        // 排序
        // 底层用的快速排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [11, 22, 33, 44, 55]

        int[] arr2 = {11,22,33,44,55,66,77};
        // 二分查找
        // 有序的，不能有相同的
        System.out.println(Arrays.binarySearch(arr2, 22)); //
        System.out.println(Arrays.binarySearch(arr2, 77)); //
        System.out.println(Arrays.binarySearch(arr2, 12)); //-2
        System.out.println(Arrays.binarySearch(arr2, 99)); //-8 找不到返回  应在的

位置负数后-1
    }
}

/*基本类型和包装类的对应：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean*/

public class Demo1_Integer {

    public static void main(String[] args) {
        // 进制
        System.out.println(Integer.toBinaryString(60)); //
        System.out.println(Integer.toOctalString(60)); //
        System.out.println(Integer.toHexString(60)); //3c
        //int 类型能够表示的最大值,最小值
        System.out.println(Integer.MAX_VALUE); //
        System.out.println(Integer.MIN_VALUE); // -2147483648
        //数字
        Integer integer = new Integer(100);
        System.out.println(integer); //100
        //数字字符串
        Integer integer2 = new Integer("100");
        System.out.println(integer2); //100

        // int--String
        int i = 100;
        String string = i + "";  // 方式1   //推荐
        String string2 = String.valueOf(i);  // 方式2     //推荐
        Integer integer3 = new Integer(i);  // 方式3
        String string3 = integer3.toString();
        String string4 = Integer.toString(i); // 方式4

        // String--int
        String string5 = "200";
        Integer integer4 = Integer.parseInt(string5); // 方式1   //推荐
        Integer integer5 = new Integer(string5); // 方式2
        int i5 = integer5.intValue();

        // parseXX方法
        // Character没有，字符串到字符的转换通过toCharArray()就可以把字符串转换为字

符数组

    }

}

public class Demo4_JDK5 {

    /**
     * * A:JDK5的新特性
            * 自动装箱：把基本类型转换为包装类类型
            * 自动拆箱：把包装类类型转换为基本类型
        * B:案例演示
            * JDK5的新特性自动装箱和拆箱

            * Integer ii = 100;
            * ii += 200;
        * C:注意事项
            * 在使用时，Integer  x = null;代码就会出现NullPointerException。
            * 建议先判断是否为null，然后再使用。
     */
    public static void main(String[] args) {
//        int x = 100;
//        Integer i1 = new Integer(x);            //将基本数据类型包装成对象,

装箱
//
//        int y = i1.intValue();                    //将对象转换为基本

数据类型,拆箱

        Integer i2 = 100;                        //自动装箱,

把基本数据类型转换成对象
        int z = i2 + 200;                        //自动拆箱,

把对象转换为基本数据类型
        System.out.println(z); //

        Integer i3 = null;
//        int a = i3 + 100;                        //底层用i3

调用intValue,但是i3是null,null调用方法就会出现
//        System.out.println(a);                    //空指针异常

java.lang.NullPointerException
    }

}

public class Demo5_Integer {

    public static void main(String[] args) {
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);                //false
        System.out.println(i1.equals(i2));            //true
        System.out.println("-----------");

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

        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);                //true
        System.out.println(i5.equals(i6));            //true
        System.out.println("-----------");

        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);               // false
        System.out.println(i7.equals(i8));            //true

        /*
         * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,

而是从常量池中获取
         * 如果超过了byte取值范围就会再新创建对象
         *
         * public static Integer valueOf(int i) {
                assert IntegerCache.high >= 127;  // 断言
                if (i >= IntegerCache.low && i <= IntegerCache.high)            

//i>= -128 && i <= 127
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }
         */
    }

}