JavaSE高级应用编程——工具类

一、Java API
1、Java API简介

 1. API (Application Programming Interface) 应用程序接口
 2. Java中的API，就是JDK提供的各种功能的Java类
 3. JDK帮助文档
     JAVA_API_CN.chm
 4. java.lang
    Java语言包(包含String、Math、System等类)，任何类中，该包中的类都会被自动导入
 5. java.util
    包含一些实用的工具类（ 包含 list, calendar, date等类）
 6. java.awt
    图形用户界面包。
 7. java.io
    提供多种输入/输出功能的类。
 8. java.net
    提供网络应用功能的类

2、Object介绍及方法

 1. Object类是所有类的超类， Object是Java语言中唯一一个没有父类的类。
 2.一个类可以不是Object类的直接子类，但一定是Object类的子类，Java中的每一个类都是从Object扩展来的。
 3.在Object类中定义的方法，在所有类中都可以使用。
 4.public boolean equals(Object obj)
         比较两个对象引用的值是否相等（比较哈希地址）
 5.public int hashCode()
        返回十进制整数，唯一标识一个对象
 6.public String toString()
        返回 类名@hashcode

3、Object 类常用方法

    public boolean equals(Object obj)： 
        比较两个对象引用的值是否相等（比较地址）。
        指出调用该方法的对象是否与obj对象相等。即地址是否相等。
    public int hashCode()：
        该方法返回对象的哈希码，哈希码是一个代表对象的十六进制整数，比作对象的身份证号。
        在程序运行期间，每次调用同一个对象的hashCode()返回的哈希码必定相同，但是多次执行同一个程序，程序的一次执行和下一次执行期间同一个对象的哈希码不一定相同。
        实际上默认的哈希码是将对象的内存地址通过某种转换得到的，所以不同对象会有不同的哈希码。
    public String toString()：
        返回 类名@hashcode ；
        事实上返回这样的字符串没有什么实际的意义。
        一般子类都会覆盖该方法，让它返回有意义的文本。

4、equals() 与 ==

理解equals()方法和==运算符的区别是非常重要的。
    默认情况下（即没有被重写时）equals()只能比较引用类型，"=="既能比较引用类型又能比较基本类型。
    equals()方法从Object类继承，即比较对象引用的值
    一般都被子类方法覆盖，不再比较引用的值
"=="运算符:
    比较基本数据类型：相当于算术等号
    比较引用数据类型：比较引用的值，不能被覆盖。

5、包装类

Everything is object.
    Java编程语言不把基本数据类型看作对象。Java 编程语言提供包装类来将基本数据类型看作对象。
    在功能上包装类能够完成数据类型之间（除boolean）的相互转换，尤其是基本数据类型和String类型的转换。
    包装类中包含了对应基本数据类型的值，封装了String和基本数据类型之间相互转换的方法，还有一些处理这些基本数据类型时非常有用的属性和方法
包装类简介
    基本数据类型不是对象层次结构的组成部分。有时需要像处理对象一样处理这些基本数据类型，可通过相应的“包装类”来将其“包装”。

基本数据类型转换为包装类
     int  i = 500;
     Integer it = new Integer(i);
字符串转换为包装类
    String str = "500";
    Tnteger it = new Integer(str);
字符串通过包装类的valueOf(String s)转换为包装类
    String sInt = “500”;
    Integer wInt = Integer.valueOf(sInt);
注意：字符串不能通过以上两种方式转换为Character

包装类通过xxxValue()方法转换为基本数据类型
    Integer wInt = new Integer(500);
    int pInt = wInt.intValue();

6、自动装箱和自动拆箱

    在进行基本数据类型和对应的包装类型转换时，系统将自动进行
    JDK自5.0版本后引入
    方便程序的编入 

二、字符串类

    字符串是我们在编程中最常使用的一种数据类型，它的表现形式可以分为两种：String类型和StringBuffer.
    它不属于8种基本的数据类型，而是一种引用类型。
    String对象代表一组不可改变的Unicode字符序列，对它的任何修改实际上又产生一个新的字符串，String类对象的内容一旦被初始化就不能再改变。
    StringBufferr对象代表一组可以改变的Unicde字符序列。
    同时，String类是final类型的类。
String的创建：有两种方式:
    静态方式（常用）。像是给变量直接赋值一样来使用。
    如：
        String s1 =“abc”; 
        String s2 =“abc”;
    动态方式。动态的内存分配，使用new运算符。
        String s3= new String(“abc”); 
        String s4= new String(“abc”);
     那么这两种方式创建的字符串是同一个字符串对象嘛？不，是有区别的。
     在于：
         使用静态方式创建的字符串，在方法区的常量池中只会产生唯一一个字符串对象，使用该方式产生同样一个字符串时，内存中不再开辟另外一块空间，而是两个引用变量指向同一个字符串对象。
         使用动态方式创建的字符串，在堆内存中会产生出不同的对象。

String类的构造方法
    初始化一个新创建的 String 对象，它表示一个空字符序列。
        String 变量名 = new String () ;
    初始化一个新创建的 String 对象，表示一个与该参数相同的字符序列;
        String 变量名 = new String (String value) ;
    分配一个新的字符串，它包含当前包含在字符串缓冲区参数中的字符序列。
        String 变量名 = new String (StringBuffer buf) ;
    字符串文字常量本身是一个String对象
         String 变量名 = “hello” ;
    初始化一个新创建的 String 对象，通过使用指定的charset 解码指定的 byte 数组
        String 变量名 = new String(byte[] bytes, String charsetName);
    初始化一个新创建的 String 对象，通过使用指定的 charset解码指定的 byte 子数组，构造一个新的 String
        String 变量名 = new String(byte[] bytes, int offset, int length, Charset charset);

String类构造方法
    String s = new String() 
        初始化一个新创建的String对象，表示一个空字符串（“ ”）；
        注意空字符串与null的区别：空字符串表示String对象的内容为空，而null表示String类的变量不指向任何的String 对象。
    String( String original) 
        创建一个String对象，并用original为该对象初始化。
    String( char chars[ ]) 
        使用一个字符数组创建一个String对象。
    String( char chars[ ], int startIndex, int numChars) 
        使用一个字符数组创建一个String对象,startIndex表示数组的偏移量，numChars表示由多少个字符创建。参数偏移量可以省略。
    String( byte asciiChars[ ]) 
        使用一个字节数组创建一个String对象。
    String( byte asciiChars[ ], int startIndex, int numChars) 
        同上。
    String(StringBuffer buffer) 
    使用StringBufffer对象中的内容为该对象初始化。

    任何一个String对象在创建之后都不能对它的内容作出任何改变（immutable）
    连接、获得子串和改变大小写等操作，如果返回值同原字符串不同，实际上是产生了一个新的String对象
    在程序的任何地方，相同的字符串字面常量都是同一个对象
    String类重置了equals方法，用于比较两个字符串的内容

String类常用方法

定义并初始化两个字符串
        String str1 = "This is a Object";
        String str2 = "Me too";

判断两个字符串对象的内容是否相等
    System.out.println(str1.equals(str2));

比较两个字符串的内容是否相等，忽略大小写
    String str3 = "me too";
    System.out.println(str2.equalsIgnoreCase(str3));

将String对象中的所有字符都转换为大写
    System.out.println(str2.toUpperCase());

将String对象中的所有字符都转换为小写
    System.out.println(str2.toLowerCase());

返回指定索引处的 char 值
    System.out.println(str1.charAt(2));

返回一个新字符串，该字符串是从begin开始的字符串的内容
    System.out.println(str1.substring(4));

返回一个新字符串，该字符串是从begin开始到end-1结束的字符串的内容
    System.out.println(str1.substring(4,7));

返回指定字符在此字符串中第一次/最后一次出现处的索引。
    System.out.println(str2.indexOf('o'));
    System.out.println(str2.lastIndexOf('o'));

从指定的索引开始搜索，返回在此字符串中第一次/最后一次出现指定字符处的索引
    System.out.println(str2.indexOf('o', 3));
    System.out.println(str2.lastIndexOf('o', 5));

返回新的字符串，忽略前导空白和尾部空白
    System.out.println(("  This is A Test  ").trim());

返回此字符串的长度
    System.out.println(str1.length());

将指定字符串连接到此字符串的结尾
    System.out.println(str1.concat(str2));

使用平台的默认字符集将此 String 编码为 byte序列，并将结果存储到一个新的 byte 数组中
        byte[] b = str1.getBytes();
        for(int i = 0;i<b.length;i++){
            System.out.print(b[i]+" ");
        }

根据给定正则表达式的匹配拆分此字符串。
    String[] str = str1.split(" ");
    for(int i = 0;i<str.length;i++){
        System.out.print(str[i]+"\t ");
    }

测试此字符串是否以指定的前缀开始/结束
    System.out.println(str1.startsWith("This"));
    System.out.println(str1.endsWith("This"));

三、StringBuffer类

    StringBuffer类用于内容可以改变的字符串
    可以使用StringBuffer来对字符串的内容进行动态操作，不会产生额外的对象 

StringBuffer对象的创建
    构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
        StringBuffer 变量名 = new StringBuffer () ;
    构造一个不带字符，但具有指定初始容量的字符串缓冲区。
        StringBuffer 变量名 = new StringBuffer (int capacity ) ;
    构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
        StringBuffer 变量名 = new StringBuffer (String value) ;

StringBuffer类常用方法

    StringBuffer strb = new StringBuffer("1234");
    System.out.println(strb.capacity());

返回长度（字符数）
    System.out.println(strb.length());

将此字符序列用其反转形式取代
    System.out.println(strb.reverse());

将给定索引处的字符设置为 ch 
    strb.setCharAt(2, 'h');
    System.out.println(strb);

返回此序列中指定索引处的 char 值
    System.out.println(strb.charAt(2));

将StringBuffer对象转换成相应的String
    System.out.println(strb.toString());

其他方法：

四、StringBuilder类

    StringBuilder类是一个可变的字符序列。
    JDK自从5.0版本后引入。
    StringBuilder类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候 。

StringBuilder对象的创建
    构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
        StringBuilder 变量名 = new StringBuilder () ;
    构造一个不带任何字符的字符串生成器，其初始容量由 capacity参数指定。
        StringBuilder 变量名 = new StringBuilder (int capacity ) ;
    构造一个字符串生成器，并初始化为指定的字符串内容
        StringBuilder 变量名 = new StringBuilder(String str) ;

常用方法

String类与StringBuilder类的比较

Java中定义了String与StringBuffer两个类来封装对字符串的各种操作
    String类与StringBuffer类都被放到了java.lang包中
    两者的主要区别在于
        String类对象中的内容初始化不可以改变
        StringBuffer类对象中的内容可以改变

StringBuffer类与StringBuilder类的比较

StringBuffer和StringBuilder都是长度可变的字符串。
    两者的操作基本相同。
    两者的主要区别在于
    StringBuffer类是线程安全的；
    StringBuilder类是线程不安全的。
    StringBuffer在JDK1.0中就有，而StringBuilder是在JDK5.0后才出现的。
    StringBuilder的一些方法实现要比StringBuffer快些。

五、Math类

    Math类提供了大量用于数学运算的方法
    Math类是final类，因此不能从Math类继承
    Math类中的方法都是static方法，因此不必创建Math类的对象就可以直接使用该类的方法

Math类中常用方法

//      返回参数绝对值
        System.out.println(Math.abs(0));

//      向上取整
        System.out.println(Math.ceil(4.55));
        System.out.println(Math.ceil(-4.55));

//      向下取整
        System.out.println(Math.floor(3.22));
        System.out.println(Math.floor(-3.22));

//      比较大小，返回大的数
        System.out.println(Math.max(4, -2));

//      比较大小，返回小的数
        System.out.println(Math.min(4, -2));

//      产生0-1之间的随机数
        System.out.println(Math.random());

//      四舍五入
        System.out.println(Math.round(0.22));
        System.out.println(Math.round(0.52));

//      返回指定弧度的三角函数值
        System.out.println(Math.sin(Math.PI*0.25));

//      返回所给值的平方根
        System.out.println(Math.sqrt(9));

六、日期类

Date  类
    java.util.Date。
    Date 类表示指定的时间信息，可以精确到毫秒。
    不支持国际化。
    该类的许多方法已过时。
    获取当前系统时间：
        new Date();

Date类常用方法

//      获取当前系统时间
        System.out.println(date);

//      测试此日期是否在指定日期之后
        System.out.println(date.after(date1));

//      测试此日期是否在指定日期之前
        System.out.println(date.before(date1));

//      比较两个日期的顺序。
        System.out.println(date1.compareTo(date));

//      比较两个日期的相等性。
        System.out.println(date.equals(date1));

七、Calendar 类

    java.util.Calendar。
        java.util.GregorianCalendar
    常用的日期处理的对象。可以设置自己的时区和国际化格式。
    是一个抽象类。
    Calendar 抽象类定义了足够的方法，让我们能够表述日历的规则 。
    获取Calendar对象的实例
        Calendar c = Calendar.getInstance();

    获取Calendar对象的实例：
        Calendar c = Calendar.getInstance();
    设置Calendar实例所表示的时间：
        c.set(2011,6,16);
    获取指定的时间属性
        c.get(Calendar.YEAR);

八、SimpleDateFormat 类

    java.text.SimpleDateFormat 。
    一个以与语言环境相关的方式来格式化和分析日期的具体类。是抽象类java.text.DateFormat类的子类。
    SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式 。

    获取SimpleDateFormat的实例
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    将日期格式成指定的字符串
        sdf.format(new Date());
    将格式化的字符串转换成日期对象
        sdf.parse(“2011-07-16”);