java常用基本类库String、包装类、异常总结

String类的概述和使用(掌握)
    (1)多个字符组成的一串数据。
        其实它可以和字符数组进行相互转换。
    (2)构造方法：
        A:public String()
        B:public String(byte[] bytes)
        C:public String(byte[] bytes,int offset,int length)
        D:public String(char[] value)
        E:public String(char[] value,int offset,int count)
        F:public String(String original)
        下面的这一个虽然不是构造方法，但是结果也是一个字符串对象
        G:String s = "hello";
    (3)字符串的特点
        A:字符串一旦被赋值，就不能改变。
            注意：这里指的是字符串的内容不能改变，而不是引用不能改变。
        B:字面值作为字符串对象和通过构造方法创建对象的不同
            String s = new String("hello");和String s = "hello"的区别?
    (4)字符串的面试题(看程序写结果)
        A:==和equals()
            String s1 = new String("hello");
            String s2 = new String("hello");
            System.out.println(s1 == s2);// false
            System.out.println(s1.equals(s2));// true

            String s3 = new String("hello");
            String s4 = "hello";
            System.out.println(s3 == s4);// false
            System.out.println(s3.equals(s4));// true

            String s5 = "hello";
            String s6 = "hello";
            System.out.println(s5 == s6);// true
            System.out.println(s5.equals(s6));// true
        B:字符串的拼接
            String s1 = "hello";
            String s2 = "world";
            String s3 = "helloworld";
            System.out.println(s3 == s1 + s2);// false
            System.out.println(s3.equals((s1 + s2)));// true

            System.out.println(s3 == "hello" + "world");// 应该是true
            System.out.println(s3.equals("hello" + "world"));// true
    (5)字符串的功能
        A:判断功能

         boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
         boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
         boolean contains(String str):判断大字符串中是否包含小字符串
         boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
         boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
         boolean isEmpty():判断字符串是否为空。
        B:获取功能
            int length():获取字符串的长度
            char charAt(int index):返回字符串中给定索引处的字符
            int indexOf(int ch):返回指定字符在此字符串中第一次出现的索引
            int indexOf(String str):返回指定字符串在此字符串中第一次出现的索引
            String substring(int start):截取字符串。返回从指定位置开始截取后的字符串。
            String substring(int start,int end)截取字符串。返回从指定位置开始到指定位置
            结束截取后的字符串。
            lastIndexOf:最后一次出现的位置。
        C:转换功能
            byte[] getBytes():转为byte类型数组
            char[] toCharArray()转为char类型数组
            String toLowerCase()：把字符串变成小写
            String toUpperCase():把字符串变成大写
            String replace(char oldChar,char newChar)：用新的字符去替换指定的旧字符
            String replace(String oldStr,String newStr)：用新的字符串去替换指定的
            旧字符串
            String[] split(String regex)：切割功能，注意正则表达式（以后讲）。
            把字符串用“,”分割

            String trim()：去除字符串两端空格

            String是不可变的，因此上面的操作都是生成新的字符串对象子串，要用返回值去取
            新的字符串。

---------------------------------------------------------
StringBuffer字符串缓冲区(掌握)
    构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
    特点：
        1：可以对字符串内容进行修改。
        2：是一个容器。
        3：是可变长度的。
        4：缓冲区中可以存储任意类型的数据。
        5：最终需要变成字符串。

        容器通常具备一些固定的方法：
        1，添加。
            StringBuffer append(data):在缓冲区中追加数据。追加到尾部。
            StringBuffer insert(index,data):在指定位置插入数据。
        2，删除。
            StringBuffer delete(start,end);删除从start至end-1范围的元素
            StringBuffer deleteCharAt(index);删除指定位置的元素
        //sb.delete(0,sb.length());//清空缓冲区。
        3，修改。
            StringBuffer replace(start,end,string);将start至end-1替换成string
            void setCharAt(index,char);替换指定位置的字符
            void setLength(len);将原字符串置为指定长度的字符串
        4，查找。（查不到返回-1）
            int indexOf(string); 返回指定子字符串在此字符串中第一次出现处的索引。
            int indexOf(string,int fromIndex);从指定位置开始查找字符串
            int lastIndexOf(string); 返回指定子字符串在此字符串中最右边出现处的索引。
            int lastIndexOf(string,int fromIndex); 从指定的索引开始反向搜索
        5，获取子串。
            string substring(start); 返回start到结尾的子串
            string substring(start,end); 返回start至end-1的子串
        6，反转。
            StringBuffer reverse();字符串反转
StringBuilder
        JDK1.5出现StringBuiler；构造一个其中不带字符的字符串生成器，
        初始容量为 16 个字符。
        该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程
        使用的时候（这种情况很普遍）。     
        方法和StringBuffer一样；

        StringBuffer 和 StringBuilder 的区别：
            StringBuffer线程安全。
            StringBuilder线程不安全。
            单线程操作，使用StringBuilder 效率高。
            多线程操作，使用StringBuffer 安全。

    //常用方法操作
    StringBuilder sb = new StringBuilder("abcdefg");
        sb.append("ak");  //abcdefgak
        sb.insert(1,"et");//aetbcdefg
        sb.deleteCharAt(2);//abdefg
        sb.delete(2,4);//abefg
        sb.setLength(4);//abcd
        sb.setCharAt(0,'k');//kbcdefg
        sb.replace(0,2,"hhhh");//hhhhcdefg

    //想要使用缓冲区，先要建立对象。
        StringBuffer sb = new StringBuffer();       
        sb.append(12).append("haha");//对象方法调用链。
        String s = "abc"+4+'q';
            s = new StringBuffer().append("abc").append(4).append('q').toString();
---------------------------------------------------------
包装类(掌握)
        基本数据类型对象包装类：是按照面向对象思想将基本数据类型封装成了对象。
        好处：
        1：可以通过对象中的属性和行为操作基本数据。
        2：可以实现基本数据类型和字符串之间的转换。

            关键字   对应的类名
            byte      Byte
            short     Short     paserShort(numstring);
            int       Integer   静态方法：parseInt(numstring)
            long      Long
            float     Float
            double    Double
            char      Character
            Boolean   Boolean

基本数据类型对象包装类：都有 XXX parseXXX 方法
只有一个类型没有parse方法：Character ；

Integer对象：
        数字格式的字符串转成基本数据类型的方法：
        1：将该字符串封装成了Integer对象，并调用对象的方法intValue();
        2：使用Integer.parseInt(numstring):不用建立对象，直接类名调用；

        将基本类型转成字符串的两种方式：
        1：Integer中的静态方法 String toString(int);
        2：int+"";

        将一个十进制整数转成其他进制：
            转成二进制：toBinaryString
            转成八进制：toOctalString
            转成十六进制：toHexString
            toString(int num,int radix);

        将其他进制转换十进制：
        parseInt(string,radix); //将给定的数转成指定的基数进制；

    在jdk1.5版本后，对基本数据类型对象包装类进行升级。
    在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样，进行运算。

        Integer i = new Integer(4); //1.5版本之前的写法；
        Integer i = 4; //自动装箱，1.5版本后的写法；
        i = i + 5;
        //i对象是不能直接和5相加的，其实底层先将i转成int类型，在和5相加。
        而转成int类型的操作是隐式的。自动拆箱：拆箱的原理就是i.intValue();
        i+5运算完是一个int整数。如何赋值给引用类型i呢？其实有对结果进行装箱。
    Integer c = 127;
        Integer d = 127;
        System.out.println(c = = d); //true
//在装箱时，如果数值在byte范围之内，那么数值相同，不会产生新的对象，也就是说多个数值
相同的引用指向的是同一个对象。
---------------------------------------------------------       
时间数据类型(掌握)

Date/DateFormat
    (1)Date是日期类，可以精确到毫秒。
        A:构造方法
            Date()
            Date(long time)
        B:成员方法
            getTime()
            setTime(long time)
        C:日期和毫秒值的相互转换
        案例：你来到这个世界多少天了?
    (2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，
    所以使用其子类SimpleDateFormat
        A:SimpleDateFormat(String pattern) 给定模式
            yyyy年MM月dd日 HH:mm:ss”、“yyyy-MM-dd”。
        B:日期和字符串的转换
            a:Date -- String
                format()
                    return new SimpleDateFormat(format).format(d);
            b:String -- Date
                parse()
                    return new SimpleDateFormat(format).parse(s);
        C:案例：获取当前时间
            Date now = new Date();
        SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd mm :ss");
            String s = date.format(now);

            制作了一个针对日期操作的工具类。

Calendar
    (1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
    (2)如何得到一个日历对象呢?
        Calendar rightNow = Calendar.getInstance();
        本质返回的是子类对象
    (3)成员方法
        A:根据日历字段得到对应的值
        B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
        C:设置日历对象的年月日

---------------------------------------------------------       
异常(掌握)：
        就是不正常。程序在运行时出现的不正常情况。其实就是程序中出现的问题。
这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问
题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些
信息进行封装。
        异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

        出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。
        而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，
        问题出现的位置，所以可以不断的向上抽取。形成了异常体系。 

        --------java.lang.Throwable：
        Throwable：可抛出的。 
            |--Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。
            |--Exception：异常，可以有针对性的处理方式

        在开发时，如果定义功能时，发现该功能会出现一些问题，应该将问题在定义功能时标示出来，
        这样调用者就可以在使用这个功能的时候，预先给出处理方式。

        如何标示呢？通过throws关键字完成，

        格式：throws 异常类名,异常类名...  throw new IllegalArgumentException("....")

        这样标示后，调用者，在使用该功能时，就必须要处理，否则编译失败。

        处理方式有两种：1、捕捉；2、抛出。
        对于捕捉：java有针对性的语句块进行处理。
        try {
            需要被检测的代码；
        }
        catch(异常类 变量名){
            异常处理代码；
        }
        fianlly{
            一定会执行的代码；
        }

catch (Exception e) { //e用于接收try检测到的异常对象。
    System.out.println("message:"+e.getMessage());//获取的是异常的信息。
    System.out.println("toString:"+e.toString());//获取的是异常的名字+异常的信息。
    e.printStackTrace();//打印异常在堆栈中信息；异常名称+异常信息+异常的位置。
}

    异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的
    catch处理代码块，这样的处理有针对性，抛几个就处理几个。

    特殊情况：try对应多个catch时，如果有父类的异常catch语句块，一定要放在下面。

    throw 和throws关键字的区别：
    throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。
    throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。
    通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定
    要声明，否则编译失败。但是也有特殊情况。

    自定义异常的步骤：
        1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。
        2：通过throw 或者throws进行操作。

    记住：finally很有用，主要用户关闭资源。无论是否发生异常，资源都必须进行关闭。
    System.exit(0); //退出jvm，只有这种情况finally不执行,否则一定会执行内部语句体。