Java学习笔记之Java API

4.Java API

API

=================================

  * Application Programming Interface

    应用编程接口

  * 一切可以调用的东西

java.lang 包

=================================

  * lang - language

  * 语言包

  * 自动导入，不需要导入

      String

      System

java.lang.Object

======================================

java.lang.String

java.lang.StringBuilder

java.lang.StringBuffer

正则表达式

java.util.regex.Pattern

java.util.regex.Matcher

======================================

基本类型包装类

java.lang.Number

java.math.BigDecimal

java.math.Integer

java.text.DecimalFormat

java.lang.Math

======================================

java.util.Date

java.text.SimpleDateFormat

java.util.Calendar

java.util.GregorianCalendar

======================================

java.lang.Object

===========================================

  * java中所有类的顶层父类

  * 一个类，如果不继承其他类，

    默认继承 Object

        class A /*extends Object*/ {

        }

  方法

  --------------------------------------

    toString()

        获得对象的字符串表示

        Object 类中默认实现是：

            "tarena.day1201.Student@6a17e3"

            "类型@内存地址"

        如果需要，可以在子类中重写 toString()

    equals(Object obj)

        当前对象与参数对象 obj 比较是否相等

        Object 中默认比较对象的内存地址

            this == obj

        如果需要，可以在子类中重写 equals()

    hashCode()

        获得对象的哈希值（int整数）

        Object中默认实现是：

            用内存地址作为哈希值

        如果需要，可以在子类中重写 hashCode()，

        使用属性来计算产生哈希值

        作为键，放入哈希表时，才需要重写

java.lang.String

=======================================

  * 是封装 char[] 的对象

  * 字符串字面值

      *)第一次使用一个字面值时，

        在“字符串常量池”中新建对象

      *)再次使用相同字面值

        从“常量池”获取存在的对象

  * 字符串不可变

      String s1 = "abc";

      String s2 = "def";

      String s3 = "ghi";

      String s4 = s1 + s2 + s3;

      *)字符串加号连接效率低

           每次执行加号连接运算，

           都会创建一个新的字符串对象

  创建对象

  ----------------------------------

    1.char[] a = {'a','b','c'};

      String s = new String(a);

    2.第一种方式的语法简化：

        String s = "abc";

  方法

  -------------------------------------

    charAt(int index)

        s = "abc";       

        char c = s.charAt(2);

    toUpperCase()

        s = s.toUpperCase()

        print(s);

    toLowerCase()

    length()

    compareTo(String anotherString)

    compareToIgnoreCase(String str) 忽略大小写

        与另一字符串按编码表顺序比较大小

        当前字符串大，返回正数

        当前字符串小，返回负数

        大小相同，返回0

    startsWith(String s) 

        s = "http://........"

        boolean b = s.startsWith("http://")

    endsWith(String suffix)

        是否以指定的子串开头或结尾

    equals(Object anObject)

    equalsIgnoreCase(String anotherString) 忽略大小写

        比较字符串内容是否相同

    indexOf(String s)

        s = "abc abc abc";

        int index = s.lastIndexOf("xxxx");

    indexOf(String s, int fromIndex) 从指定位置向后寻找

        获得指定子串的位置，不存在，返回 -1

    lastIndexOf(String s)

        从后向前寻找子串的位置

    replace(char oldChar, char newChar)

        将指定的字符替换为新的字符

        s = "abc abc abc";

        s = s.replace('a', '-');

        System.out.println(s);

    substring(int a) 从 a 位置直到结束

        s = "abcdefg";

        Strring s2 = s.substring(3, 5);

        System.out.println(s2);

    substring(int a, int b)

        获得 [a, b) 位置范围的子串

    trim()

        去除两端空白字符

        s = "   a  bc   ";

        s = s.trim();

        System.out.println(s);

    getBytes()          将 unicode 转为默认编码格式的字节数组

    getBytes(字符编码)  将 unicode 转为指定编码格式的字节数组

    String.valueOf(数据)

        将任何数据转为字符串

    正则表达式相关方法

    ----------------------------------

        matches(正则表达式)

            判断当前字符串，能否与正则表达式匹配

        replaceAll(正则表达式, 子串)

            将找到的匹配子串，替换为新的子串

        split(正则表达式)

            用匹配的子串，拆分字符串

            "abc,def,ghi,jkl"

提问：
1. 请解释String类的不变性
String的不变性表现为对象被创建之后，对象不可以发生变化。
例如存在String str = "hello"，则"hello"不可以发生变化，注意：变量的引用依然可以指向其他位置，例如str = "morning"。
String的不变性是因为String数据的本质是数组，而数组的长度是不可变的。

2. 请解释String类如何判断是否相同或者相等
==表示是同一个对象，用于判断栈内存中的内容是否相等，即在内存中是同一个数据。
字符串常量池：用于存储字符串常量，在常量池中的字符串具有唯一性。
关于String类型的数据需要判断是否相同，应该使用String类的equals()方法进行判断，equlas()方法的判断标准是String的每一个字符是否相同，即内容相同的字符串的判断结果为true，内容不同则结果为false。
【测试题】
  String str1 = "hello";
  String str2 = "hello";
  String str3 = new String("hello");
  String str4 = new String("hello");
  String str5 = "he" + "llo"; // 常量+常量->常量
  String str6 = "he";
          str6 = str6 + "llo"; // 变量+常量->变量

  str1 == str2  T
  str1 == str3  F
  str1 == str4  F
  str1 == str5  T
  str1 == str6  F
String类型的数据在运算时的效率极低，在对性能有一定要求的情况下，应该使用StringBuffer或者StringBuilder进行运算。

java.lang.StringBuilder

java.lang.StringBuffer

====================================

  * 可变的字符序列

  * 封装 char[] 数组

  * 提供一组方法，可以对内部字符进行修改

  * 常用来代替字符串，做高效率地连接运算

        sb.append(字符串)

  * StringBuilder   线程不安全，效率更高

    StringBuffer    线程安全

  创建对象

  -------------------------------

    1.StringBuilder sb = new StringBuilder();

        空串

    2.StringBuilder sb = new StringBuilder("abc");

        abc

  方法

  -------------------------------------

    append()

        在字符序列末尾，追加字符

        高效的字符串连接

    delete(int start, int end)

        删除 [start, end)

    deleteCharAt(int index)

        删除单个字符

    insert(int index, 子串)

        在 index 位置，插入一个子串

    replace(int start, int end, String str)

        将 [start, end) 替换为指定字符串 str

    reverse()

        翻转

    setCharAt(int index, char ch)

        将 index 位置替换为字符 ch

    toString()

        转为 String 类型

正则表达式 Regex

========================================

  * 正确格式的字符串规则

  * 百度“正则表达式大全”

  正则表达式          匹配的字符串

  --------------      -------------------------

  k                   k

  abc                 abc

  [abc]               a,b,c

  [a-z]               a,z,g,r

  [a-zA-Z_0-9]        a,z,A,Z,0,3,9,_

  [\u4e00-\u9fa5]     中文范围

  [abc][0-9]          a0,a1,b2,b3,c9,c5

  \d                  数字[0-9]

  \D                  排除数字[^0-9]

  \w                  单词字符[a-zA-Z_0-9]

  \W                  排除单词字符

  \s                  空白字符

  \S                  排除空白字符

  .                   匹配任意字符

  [abc]?              0个或1个

                      a,b,,c

  [abc]*              0个到多个

                      a,,aaa,abc,cba,abccbabcbaccabcacabaccbcbcacbc

  [abc]+              1个到多个

                      a,b,abcabcccbaccbac

  [abc]+[0-9]         a9,abc9,aabababa6

  [abc]{3}            3个

                      aaa,bbb,abc,cba,cca,ccb

  [abc]{3,5}          3个到5个

                      abc,abca,abcab

  [abc]{3,}           3个到多个

                      abc,abca,abcabcabcabc

  |                   或

  [abc]+|\d+          a,abc,9,96875

java.util.regex.Pattern

java.util.regex.Matcher

=============================================

  * Pattern 封装正则表达式

  * Matcher 封装正则表达式，和要匹配的字符串

  创建对象

  ------------------------------------

    Pattern p = Pattern.compile(正则表达式);

    Matcher m = p.matcher(要匹配的字符串);

  Matcher 方法

  ------------------------------------

    find()

      查找下一段匹配的子串

      返回 boolean 值，表示是否找到

    find(int fromIndex)

      从指定位置向后找

    group()

      获取刚刚找到的子串

    start()

    end()

      获取刚刚找到的子串的起始位置和结束位置

基本类型包装类

==========================================

  * 将基本类型值，

    封装成引用类型对象

  byte      Byte

  short     Short

  int       Integer

  long      Long

  float     Float

  double    Double

  char      Character

  boolean   Boolean

  java.lang.Number

  -------------------------------------

    *) 数字包装类的抽象父类

    *) 子类：

         Byte

         Short

         Integer

         Long

         Float

         Double

         BigDecimal

         BigInteger

    方法：

    ----------------------------

      *)取出封装的基本类型值，并可以转型

        byteValue()

        shortValue()

        intValue()

        longValue()

        floatValue()

        doubleValue()

  java.lang.Integer

  ------------------------------------------

    创建对象

    ---------------------------------

      1.Integer i = new Integer(10);

      2.Integer i = Integer.valueOf(10);

          Integer内部存在 -128 到 127

          范围的缓存的 Integer 对象，

          指定范围内的值，直接获取已经存在的对象

    方法

    ---------------------------------

      *)从 Number 继承的6个取值方法

      *)将字符串解析成 int 类型

          Integer.parseInt("255")          255

          Integer.parseInt("11111111",2)   255

          Integer.parseInt("377",8)        255

          Integer.parseInt("ff",16)        255

      *)进制转换

          Integer.toBinaryString(255)   "11111111"

          Integer.toOctalString(255)    "377"

          Integer.toHexString(255)      "ff"

  java.lang.Double

  ----------------------------------------

    创建对象

    ----------------------------------

      1.Double d = new Double(3.14);

      2.Double d = Double.valueOf(3.14); 

          与 new 相同

    方法

    ----------------------------------

      *) 从 Number 继承的 6 个取值方法

      *) 字符串转 double

           Double.parseDouble("3.14")

            *)Long.parseLong()

              Boolean.parseBoolean()

              Short.parseShort()

              ...

      *) 对特殊值进行检查的方法

           Infinity  无穷大

           NaN       Not a Number

           Double.isInfinite(double d)

              检查参数是否是无穷大值

           Double.isNaN(double d)

              检查参数是否是NaN

  自动装箱

  自动拆箱

  ------------------------------------

    *)自动装箱

        Integer a = 34;

        编译成：

        Integer a = Integer.valueOf(34);

    *)自动拆箱

        int i = a;

        编译成：

        int i = a.intValue();

        a = a + 1;

        编译成：

        a = Integer.valueOf(a.intValue() + 1);

        *) 自动拆箱，要当心 null 值

java.math.BigDecimal

java.math.BigInteger

============================================

  * BigDecimal 做精确的浮点数运算

  * BigInteger 做超出长整形范围的整数运算

  * 是 Number 的子类

  创建 BigDecimal 对象

  -----------------------------------------

    BigDecimal bd = BigDecimal.valueOf(2)

  BigDecimal 方法

  -----------------------------------------

    *) 从 Number 继承的6个取值方法

    *) 四则运算方法

        add(BigDecimal bd)

        subtract(BigDecimal bd)

        multiply(BigDecimal bd)

        divide(BigDecimal bd)

        divide(BigDecimal bd, 保留位数, 舍入方式)

            可以避免无限循环小数出错

    *) 舍入运算

        setScale(保留位数, 舍入方式)

            执行舍入运算，

            舍入结果被封装在新建的对象中

            BigDecimal bd = BigDecimal.valueOf(42365.345346345);

            bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP)

            double d = bd.doubleValue();

    *) 获取 BigInteger 中的超大整数

          toString() 作为字符串获取

java.text.DecimalFormat

============================================

  * 数字格式工具

  * 数字 --> 格式字符串

        63434647.7 --> "￥63,434,647.7000"

  * 格式字符串 --> 数字

  创建对象

  ----------------------------------

    DecimalFormat f =

      new DecimalFormat(格式字符);

    格式字符:

        "\u00A4###,###.000"

        参考 DecimalFormat API文档

  方法

  ---------------------------------------

    format(数字)

      格式化

      数字格式化成字符串

    parse(格式字符串)

      解析

      字符串解析成数字

      返回 Number 类型对象

    applyPattern(格式字符)

      修改格式

java.util.Date

=======================================

  * 封装一个毫秒值，表示一个时间点

      毫秒值：1970-1-1 0点开始的毫秒值

  创建对象

  ----------------------------------

    1.Date d = new Date();

        封装系统当前时间毫秒值

    2.Date d = new Date(600000000000L);

        封装指定的毫秒值

  方法

  ----------------------------------

    getTime()

    setTime(long t)

      存取内部封装的毫秒值

    compareTo(Date d)

      当前日期大，返回正数

      当前日期小，返回负数

      相同，返回0

java.text.SimpleDateFormat

===========================================

  * 日期格式工具

  * Date对象 --> 格式字符串

  * 格式字符串 --> Date对象

  创建对象

  -----------------------------------

    SimpleDateFormat f =

      new SimpleDateFormat(格式字符);

      格式：

          "yyyy-MM-dd HH:mm:ss"

          "dd/MM/yyyy"

          "yy/M/d H:m"

          "yy年M月d日 H:m"

          格式参考 SimpleDateFormat 文档

  方法

  ----------------------------------

    format(Date对象)

      格式化

      Date 对象格式化成字符串

    parse(日期格式字符串)

      解析

      字符串解析成 Date 对象

    applyPattern(格式)

      修改格式

java.util.Calendar

============================================

  * 日历的抽象父类

  * 封装一个毫秒值，表示一个时间点

  * 提供一组时间运算方法

  创建对象

  --------------------------------------

    1.Calendar c = new GregorianCalendar();

    2.Calendar c = Calendar.getInstance();

        如果在泰国或日本，可能会创建当地历法；

        其他地区，都是 GregorianCalendar

  方法

  --------------------------------------------

      get(字段)

          获得日期中指定字段的值，例如：

          c.get(Calendar.YEAR)

          c.get(Calendar.HOUR_OF_DAY)

      set(字段, 值)

          修改指定字段的值

      set(int year, int month, int date, int hourOfDay, int minute, int second) 

          设置年月日时分秒

      add(int field, int amount)

          在指定字段上加一个值

          c.add(Calendar.YEAR, 10)

      compareTo(Calendar anotherCalendar)

          与另一个时间比较大小

          当前Calendar实例大，返回正数

          当前Calendar实例小，返回负数

          相同大小，返回0

      getActualMaximum(int field)

          获得指定字段实际最大值，

          用来获得月中的最大天数

      setFirstDayOfWeek()

      getFirstDayOfWeek()

          周中的第一天是周几

          星期日 - 1

          星期一 - 2

          星期二 - 3

          星期三 - 4

          星期四 - 5

          星期五 - 6

          星期六 - 7

      getTime()

          获得表示相同时间的 Date 类型实例

      setTime(Date date)

          将时间设置为指定 Date 实例所表示的时间

      getTimeInMillis()

      setTimeInMillis(long millis)

          毫秒值存取方法

java.util.GregorianCalendar

============================================

  * Calendar 子类

  * 罗马历，即公历，阳历