【JavaSE入门系列】第09章_精通常用的Java类

完整版见 https://jadyer.github.io/

第09章精通常用的Java类——v512工作室   _{编辑：玄玉}

---

Clone()	String类	StringBuffer类	封装类	Locale类	DateFormat类	Random类
Equals()	ToString()	StringBuilder类	Date类	Calendar类	SimpleDateFormat类	BigInteger/BigDecimal类
Finalize()	HashCode()	StringTokenizer类	Math类	TimeZone类	GregorianCalendar类	NumberFormat/DecimalFormat类

---

Object类
概述：java.lang.Object类是所有Java类的最高层次父类，或者说是超类。所有对象(包括数组)都实现这个类的方法
            该类提供了面向对象编程技术的基本机制。即Object类定义的所有的方法都被其它类所共享
方法：hashCode()    toString()    equals()    finalize()    clone()    wait()    notify()/notifyAll()

 

 

 

HashCode()
功能：返回当前对象的一个十六进制的数字，用于区别不同的对象。每个对象的hashCode值都是不同的
举例：public class TestHashCode{public static void main(String[] args){
                        Person p1=new Person(18);//哈希码就是调用hashCode()返回的十六进制的值
                        Person p2=new Person(18); //类Person中虽然没有直接定义hashCode()方法，但它实际上是从Object继承过来的
                        int handle1=p1.hashCode(); //调用对象p1的hashCode()方法，返回十六进制整数并赋给handle1
                        System.out.println(handle1);//handle1在输出时是以十进制形式输出的
                        System.out.println(Integer.toHexString(handle1));//Integer.toHexString()把一个十进制的数转化成十六进制的字符串的形式
                        System.out.println(p1);//输出p1所属类型加上@再加上p1的hashCode()值
                        System.out.println(p2.hashCode());}}
输出：12677476   //同一个程序里每个对象的哈希码都是不确定的
             c17164     //换成另一台机器的话，它的哈希码可能又会不同
             Person@c17164
             33263331

 

 

 

ToString()
格式：public String toString(){...}
             以字符串形式返回当前对象的有关信息。在Object原始定义中，返回的是对象所属类型加上@再加上对象哈希码
说明：可以根据需要在用户定义类型中重写toString()方法
             在进行String与其它类型数据的连接操作时，自动调用toString()方法，基本类型数据转换为String类型时，调用了对应封装类的toString()方法
             当使用System.out.println()直接输出引用类型变量时，println()方法默认会先自动调用该对象的toString()方法，再将所返回的字符串信息输出
             也就是说System.out.println(p1)等价于System.out.println(p1.toString())      //直接输出这个对象和调用它的toString()再输出都是一样的效果
             在上面hashCode()例子中输出p1的时候，由于p1的toString()方法没有在Person中被重写，所以它会自动调用从Object继承过来的toString()

 

 

 

Equals()
格式：public boolean equals(Object obj){...}
             用于比较引用类型数据的等价性。基本类型比较值。引用类型比较引用，即地址值
区别：==可以比较引用类型及基本类型。而equals()只能比较引用类型。因为它是定义在Object中的方法，所以只有引用类型对象才能使用该方法
             可以根据需要，在用户定义的类中重写其equals()方法，以改变等价性评价标准。相对引用类型而言==的标准始终是比较引用值
特例：对File、String、Date及封装类等类型来说，比较的是类型及对象的内容而不考虑引用的是否为同一实例
             也就是说，对于这几个类型的数据，它不再比较引用类型的地址值，而是比较对象的内容
             从Object继承过来的equals()方法都已经被这几个类重写了，即使用这些类中重新设置的比较原则
例一：int i=5;  int j=5;  System.out.println(i==j);    //由于i和j是基本类型，直接比较二者的值，返回true    //但若写成i.equals(j)则编译报错
             Person p1=new Person();Person p2=new Person();
             System.out.println(p1==p2);    //由于p1和p2是引用类型对象，故比较二者的引用值。而二者均有各自的地址值，结果当然输出false
             System.out.println(p1.equals(p2));    //输出false。由于Person没有重写equals()，所以仍使用Object继承的equals()方法，比较的仍是引用值
例二：String s1=new String("abc");String s2=new String("abc");//生成两个String类型的对象
             System.out.println(s1==s2);    //这里s1和s2的引用值肯定不相同，所以这里输出false
             System.out.println(s1.equals(s2));    //类String的equals()方法已经被重写了，比较的是内容，故输出true
补充：若换种方式生成String对象，如：String s1="abc";String s2="abc";此时运行程序会输出两个true。即这种情况下二者地址值也是相同的
             明明是两个不同的对象，为什么它们的地址值反倒是相同的呢？这实际上是由自身类特殊性所决定的
             String类的对象是经常用到的，因为在一个程序里，肯定会使用到String类对象，这样String类生成的对象就会特别多
             于是在JVM内部为了能重复的使用String类的对象，它就专门有一片内存空间缓冲已存在的字符串对象
             当使用String s1="abc"方式设定一个字符串对象内容时，这个对象就会放到缓冲池里面，即字符串缓冲池
             将来在创建一个字符串对象，如果跟之前的那个字符串对象内容一样。系统就不会创建对象，而是把缓冲池已有对象的地址值赋给待创建的对象
             所以在执行完String s1="abc"后，对象s1的内容即字符序列abc的值是保存在了字符串缓冲池当中
             当下一次又以这种方式生成对象s2时，如果s2内容跟之前的s1内容一样，系统就会检查到缓冲池里有代表内容abc的一个对象
             于是把s1的地址值赋给了s2。而之前String s1=new String("abc")方式生成的对象是不会放在缓冲池当中的，这时s1和s2就是两个不同的对象
             所以，若把生产方式改为String s1="abc";String s2 = new String("abc");那么最后还是会输出false和true。因为这时s1和s2的引用值仍然不同

 

 

 

Finalize()
格式：protected void finalize() throws Throwable{...}
             Java运行时环境中的垃圾收集器在销毁一个对象之前，会自动调用该对象的finalize()方法，然后才释放对象的内存空间
用涂：在子类中重写，以加入所需的逻辑代码来配置系统资源或执行其它清除操作。它在实际开发中很少被重写，因为重写的意义并不是很大
举例：public Person(){ System.out.println("创建Person对象，name:" + name);}
             public void finalize(){ System.out.println("销毁Person对象，name:" + name);}
             for(int i=0;i<5;i++){ Person p=new Person();}
             运行时看到5个对象都是创建，没有没销毁的。这是因为我们无法控制垃圾回收器指定销毁某个对象
             只有销毁这个Person对象时，才会调用它的finalize()方法。为了看看效果，我们可以增加循环次数，同时让它创建一些垃圾对象
             这样有时就会导致内存空间不足，导致一些Person对象就会被回收了。于是就再增加一个内部循环，代码如下
             for(int i=0;i<10;i++){ Person p=new Person(); for(int j=0;j<1000;j++){ String[] test={"Asdf","Billy","Kessy"};}}
             于是重新运行后会发现有的对象被销毁了。尽管可能有的对象已经没用，但它可能也没有被直接销毁
             这时因为一个对象的销毁是由JVM决定的，我们不能干预也不能控制。所以finalize()方法对于平时开发用处不大

 

 

 

Clone()
格式：protected native Object clone() throws CloneNotSupportedException;
             用于对象的拷贝。可以细分为浅度拷贝和深度拷贝
补充：要进行克隆的对象所属的类必须实现java.lang.Cloneable接口。即这个类必须是可被克隆的才能完成克隆
             使用clone()方法首先需要在这个类中对clone()进行重写，然后这个类的对象才可以调用clone()方法
举例：详细例子见源代码。克隆后的引用类型对象的属性的值相同，但地址值是不同的

 

 

 

String类
类型概述：java.lang.String类对象表示不可修改的Unicode编码字符串。即字符串序列的内容是不能修改的
方法使用：构造方法
                     连接和转换及截断：concat()    replace()    substring()    toLowerCase()    toUpperCase()    trim()
                     检索和查找功能：charAt()    startsWith()    indexOf()    lastIndexOf()    length()
                     内容比较：equals()    equalsIgnoreCase()    compareTo()
Split()：从JDK1.4开始，Sun公司推荐开发者使用一种新的字符串分解方式
               String类的split()方法是分解字符串的新方法
举例：  public class TestStringSplit{public static void main(String args[]){
                           String s = "阳光:沙滩:海浪:仙人掌";String[] results = s.split(":");
                           for(String each: results) {System.out.println(each);}}}

 

 

 

StringBuffer类
类型概述：java.lang.StringBuffer类对象保存可修改的Unicode字符序列。Buffer即缓冲的意思。
                     也就是说在执行大的字符串操作时，尽量先把String类型对象转化成StringBuffer类型，然后在进行字符串的操作
                     因为StringBuffer效率更高。StringBuffer相当于String的亲兄弟，二者间可以非常方便的互相转化
构造方法：StringBuffer()    StringBuffer(int capacity)    StringBuffer(String initialString)
功能方法：append()    insert()    reverse()    setCharAt()

 

 

 

StringBuilder类
类型概述：java.lang.StringBuilder类是JDK5.0以后新引入的。该类能够提供与StringBuffer相同的功能
二者区别：StringBuffer类是线程安全的。而StringBuilder则不是，即不保证其对象的同步性，在多线程环境中是不安全的
                     在非多线程环境下，StringBuilder性能要比StringBuffer好一些
                     所以在非多线程中推荐使用StringBuilder类，在多线程中推荐使用StringBuffer类

 

 

 

StringTokenizer类
类型概述：java.util.StringTokenizer类的功能是将当前字符串按照默认或指定的分隔符分解为多个片段
构造方法：public StringTokenizer(String str)
                     public StringTokenizer(String str,String delim)
                     public StringTokenizer(String str,String delim,boolean returnDelims)
功能方法：public boolean hasMoreTokens()    //判断当前分隔之后，是否还有其余的字符串
                     public String nextToken(String delim)    //获取分隔之后的下一个字符串

 

 

 

封装类
概述：针对八种基本数据类型定义的相应的引用类型。使用封装类就可以把基本类型数据转化成对象
举例：Integer t1=new Integer(314);    //Integer是int的封装类，调用构造方法就可以把整数314变成了引用类型
             Integer t2=new Integer("314");    //还可以把字符串314所代表的数字转化成一个引用类型
             int i=t1.intValue();    //调用intValue()得到t1和t2所代表的最初的基本类型的值。即返回封装类所封装的基本类型的数值
             System.out.println(i);    //输出整数314
             System.out.println(t1==t2);    //二者地址值是不同的，故输出false
             System.out.println(t1.equals(t2));    //因为Integer是封装类，封装类比较的是内容。二者的内容都代表的是314，故输出true
             System.out.println(t1.toString());    //把t1转化成字符串输出，故输出字符串314
             System.out.println(Integer.toBinaryString(27));    //把27转化成二进制，故输出11011
             System.out.println(Integer.toOctalString(27));    //把27转化成八进制，故输出33
             System.out.println(Integer.toHexString(27));    //把27转化成十六进制，故输出1b
             i=Integer.parseInt("500");    //调用Integer的静态方法parseInt()自动获取字符串中所表示的整数值
             System.out.println(i);}}    //所以输出500
自动封装和拆封：Integer t1=new Integer(3);int i=t1;;    //这时就已经自动拆封了：把t1的值赋给int型的i，然后i=3
                                  int j=4;Integer t2=j;;    //实际上是把j自动封装。因为j是基本类型，这里直接就可以自动封装成Integer类型，再赋给t2
                                  System.out.println(i);System.out.println(t2.toString());m1(20);;    //输出3。4。25
                                  public static void m1(Integer it){;    //m1()接收Integer类型的引用变量it，然后让it+5并赋给k。这里就会进行拆封
                                  int k=it+5;;    //这里会自动把it转换成它所表示的int型的值，然后与5相加。等价于k=it.intValue()+5;
                                  System.out.println(k);}};    //这里是把Integer类型拆回原来的int类型

 

 

 

Date类
类型概述：java.util.Date类用于表示特定的时间点，精确到毫秒。但不支持日期的国际化和分时区显示
构造方法：public Date()    //创建代表当前时间的Date类型对象
                     public Date(long date)    //创建代表指定时间的Date类型对象
                     Date是这么约定的：long型数表示的是自1970年1月1日0时0分0秒开始经历了指定毫秒数之后的具体时间
                     比如Date d2=new Date(2000)：就是指从70年1月1日0时0分0秒开始经历2000毫秒之后的具体时间
功能方法：public int compareTo(Date anotherDate)    //完成两个日期的比较
                     public boolean equals(Object obj)    //也是进行比较
                     public long getTime()    //获得当前对象所表示的时间的整数。即获得该时间与1970年1月1日0时0分0秒间的毫秒数
                     public String toString()    //把Date类型转化成字符串
用法举例：详细例子见源代码

 

 

 

Calendar类
类型概述：抽象类java.util.Calendar类提供了常规的日期修改功能和国际化支持
主要方法：public static Calendar getInstance()    //获得当前Calendar实例。该类不能进行实例化
                     public int get(int field)    //获得指定时间域的值
                     public void set(int field,int value)    //设定指定时间域的值
                     public final void set(int year,int month,int date)    //设定一个Calendar的年月日
                     public final void set(int year,int month,int date,int hourOfDay,int minute,int second)
                     public abstract void add(int field,int amount)    //完成指定时间域上的值的增加
用法举例：详细例子见源代码

 

 

 

Locale类
类型概述：java.util.Locale类描述特定的地理、政治/文化上的地区，Locale对象主要封装了地区和语言种类两方面的信息
                     通常用于在国际化/本地化程序中以地区/语言相关的方式显示日期、数字或文本信息等
                     由于不同的国家与地区显示时间是有差别的。比如有的国家是年月日，有的是日月年，还有的国家是月日年
                     那么通过Locale类就可以区分出这些国家，并且可以区分出不同的语言种类
                     国家的代码的定义是有标准的，即ISO-3166标准：中国：CN。德国：DE。日本：GP。美国：US
主要方法：public Locale(String language)    //创建针对于特定语言的Locale对象
                     public Locale(String language,String country)    //创建针对于特定语言和特定国家的Locale对象
                     public static Locale getDefault()    //得到默认的Locale对象
                     public String getCountry()    //得到Locale对象所代表的国家
                     public String getLanguage()    //得到Locale对象所代表的语言
                     public final String getDisplayName()    //得到一个显示的名称
                     public static Locale[] getAvailableLocales()    //得到可以使用的所有的Locale对象，返回的是Locale类型的数组
用法举例：详细例子见源代码

 

 

 

TimeZone类
类型概述：java.util.TimeZone类描述时区信息。TimeZone被定义为抽象类
主要方法：public static TimeZone getDefault()    //调用TimeZone的静态方法getDefault以获得该类实例
                     public static TimeZone getTimeZone(String ID)    //传一个ID值调用它的getTimeZone()返回该ID值所对应的TimeZone对象
                     public static String[] getAvailableIDs()    //返回所有可使用的代表TimeZone的ID值
用法举例：详细例子见源代码

 

 

 

GregorianCalendar类
类型概述：java.util.GregorianCalendar是Calendar的子类，该类提供了世界上大多数国家/地区使用的标准日历系统，并增加判断闰年的功能
                     Calendar是抽象类，不能实例化，但我们可以实例化GregorianCalendar类。GregorianCalendar实现了Calendar中的抽象方法
                     Gregorian意为罗马，所以GregorianCalendar即意为罗马日历，我们大多数国家使用的都是罗马日历
主要方法：public GregorianCalendar() //通过调用该方法获得一个GregorianCalendar实例
                     public GregorianCalendar(TimeZone  zone)    //创建指定时区的一个GregorianCalendar实例
                     public GregorianCalendar(Locale  aLocale)    //获得指定的Locale对象的GregorianCalendar实例
                     public GregorianCalendar(TimeZone  zone,  Locale aLocale)    //获得即指定时区又指定Locale的GregorianCalendar实例
                     public GregorianCalendar(int year,  int month,  int dayOfMonth)    //获得指定年月日的一个GregorianCalendar实例
                     public GregorianCalendar(int year,  int month,  int dayOfMonth,  int hourOfDay,  int minute,  int second)
                     public boolean isLeapYear(int  year)    //判断通过参数传进来的年是否为闰年
用法举例：GregorianCalendar gg=new GregorianCalendar();    //创建的是一个表示当前时间的对象
                     System.out.println(gg.isLeapYear(2010));    //输出false。不是闰年则返回false，是闰年则返回true
                     GregorianCalendar类的其它的用法跟Calendar一样，这里不再赘述

 

 

 

DateFormat类
类型概述：java.text.DateFormat类提供了将日期/时间信息进行格式化处理的功能
                     DateFormat只能使用它设定好的：SHORT、MEDIUM、LONG、FULL对日期格式化
                     我们可以利用它的子类SimpleDateFormat来按照我们订制的格式输出时间和日期
主要方法：public static final DateFormatgetDateInstance()    //获得DateFormat类型的实例
                     public static final DateFormat getTimeInstance()    //获得DateFormat类型的实例
                     public static final DateFormat getDateTimeInstance()    //获得DateFormat类型的实例
                     public final String format(Date date)    //完成对一个日期对象的格式化
用法举例：详细例子见源代码

 

 

 

SimpleDateFormat类
类型概述：java.text.SimpleDateFormat类是DateFormat类的子类
                     允许用户自定义日期/时间信息的表现格式，并提供更灵活的Date<=>String信息转换和解析的功能
                     创建SimpleDateFormat实例时应指定所转换的字符串格式(模式串)，否则系统会缺省采用与所在语言环境相关的默认格式
用法举例：详细例子见源代码

 

 

 

Math类
概述：java.lang.Math类提供常用数学功能和数学常量。它提供的方法大多数都是静态方法，直接可以通过类的名字调用这些方法
功能：数学常量：PI=3.1415926      E：用于科学运算
             其它操作：random()：产生浮点的一个随机数，该数大于等于0.0且小于1.0
             三角函数：sin()    cos()    tan()    asin()    acos()    atan()    toDegrees()    toRadians()
             数据截断操作：ceil()    floor()    round()
             最大最小绝对值：max()    min()    abs()
             幂运算和对数运算：pow()    exp()    sqrt()    log()    log10()
举例：System.out.println(Math.sqrt(100));    //输出10.0。注意它返回的是浮点数//求100的平方根
             System.out.println(Math.round(100.08));    //输出100。//对100.08四舍五入
             System.out.println(Math.random());    //输出0.0085777655209125457

 

 

 

Random类
概述：java.util.Random类是基于线性同余算法的一种伪随机数序列生成器。有关伪随机数和线性同余算法的相关知识可以参见书中9.5.2小节
方法：public Random()    //生成Random类的一个实例：Random r=new Random()。这时r产生的随机数没有范围限制
             public Random(long seed)
             public int nextInt()    //产生一个随机整数
             public int nextInt(int n)    //产生一个不大于n的随机整数
             public float nextFloat()    //产生一个随机的float数
             public double nextDouble()    //产生一个随机的double数
             public boolean nextBoolean()    //产生一个布尔值
举例：Random r=new Random(10);    //指定产生的随机数在10的范围内
             System.out.println(r.nextInt());    //输出-1157793070
             System.out.println(r.nextDouble());    //输出0.4456342944175421
             System.out.println(r.nextFloat());    //输出0.41291267

 

 

 

BigInteger/BigDecimal类
java.math包中定义的BigInteger和BigDecimal类型可以分别提供任意长度和精度的整数和浮点数运算功能
BigInteger类主要方法：public BigInteger(String val)
                                             public static BigInteger valueOf(long val)
                                             public BigInteger add(BigInteger val)    //加法
                                             public BigInteger subtract(BigInteger val)    //减法
                                             public BigInteger multiply(BigInteger val)    //乘法
                                             public BigInteger divide(BigInteger val)    //除法
                                             public int compareTo(BigInteger val)
                                             public BigInteger remainder(BigInteger val)
                                             public BigInteger pow(int exponent)
                                             public String toString();    //BigDecimal类的用法跟BigInteger很接近
举例：BigInteger a=BigInteger.valueOf(43);    //valueOf()方法可以把整数变成BigInteger型，好让它参与后面的运算
             BigInteger b=new BigInteger("123456789000")    //直接调用BigInteger的构造方法来生成新的实例
             System.out.println(a.add(b));    //计算a加b的结果。最后将输出123456789043

 

 

 

NumberFormat/DecimalFormat类
概述：java.text.NumberFormat/DecimalFormat提供了将数字格式化为语言环境相关字符串以及逆向解析字符串为数字的功能
方法：public static final NumberFormat getInstance()
             public static NumberFormat getInstance(Locale inLocale)
             public final String format(double number)
             public static final NumberFormat getCurrencyInstance()
             public static NumberFormat getCurrencyInstance(Locale inLocale)
             public static final NumberFormat getPercentInstance()
             public static NumberFormat getPercentInstance(Locale inLocale)
举例：NumberFormat nf1=NumberFormat.getInstance();    //按默认格式输出
             System.out.println(nf1.format(123445.6453));    //输出123,445.645
             NumberFormat nf2=NumberFormat.getInstance(new Locale("zh","CN"));    //按中文的中国格式输出
             System.out.println(nf2.format(123445.6453));    //输出123,445.645
             NumberFormat nf3=NumberFormat.getInstance(new Locale("de","CH"));    //按瑞士格式输出
             System.out.println(nf3.format(123445.6453));    //输出123’445.645
             NumberFormat nf4=NumberFormat.getInstance(new Locale("de","GE"));    //按德国格式输出
             System.out.println(nf4.format(123445.6453));    //输出123.445,645