Java常用类(Math, Object, String, Date, 包装类)

Object 类

大家都知道 Object 是所有类的父类，任何类都默认继承 Object 。

理论上 Object 类是所有类的父类，即直接或间接的继承 java.lang.Object 类。

由于所有的类都继承在 Object 类，因此省略了 extends Object 关键字。

该类中主要有以下方法 :

toString()

getClass()

equals()

clone()

fifinalize(

其中 toString(),getClass(),equals 是其中最重要的方法

注意： Object 类中的 getClass(),notify(),notifyAll(),wait() 等方法被定义为 fifinal 类型，因此不能重 写。

2 、 toString() 方法

public String toString () {

return getClass (). getName () + "@" + Integer . toHexString ( hashCode ());

}

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、 at 标记符 “@”

和此对象 哈希码 的无符号十六进制表示组成。

该方法用得比较多， 一般子类都有覆盖。

我们推荐在学习阶段所有有属性的类都加上 toString() 方法！

3 、 getClass() 方法

获取class对象,反射  不可重写，要调用的话，一般和 getName() 联合使用，如 getClass().getName()

4 、 fifinalize() 方法

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用

5 、 equals()方法         

Object 中的 equals 方法是直接判断 this 和 obj 本身的值是否相等，即用来判断调用 equals 的对象和形参

obj 所引用的对象是否是同一对象，

所谓同一对象就是指内存中同一块存储单元，如果 this 和 obj 指向的 hi 同一块内存对象，则返回 true, 如果

this 和 obj 指向的不是同一块内存，则返回 false 。

注意：即便是内容完全相等的两块不同的内存对象，也返回 false 。

如果是同一块内存，则 object 中的 equals 方法返回 true, 如果是不同的内存，则返回 false

如果希望不同内存但相同内容的两个对象 equals 时返回 true, 则我们需要重写父类的 equal 方法

String 类已经重写了 object 中的 equals 方法（这样就是比较内容是否相等了

== 号判断的是内存   

包装类

1 、包装类介绍

虽然 Java 语言是典型的面向对象编程语言，但其中的八种基本数据类型并不支持面向对象编程，基本类

型的数据不具备 “ 对象 ” 的特性 —— 不携带属性、没有方法可调用。 沿用它们只是为了迎合人类根深蒂固

的习惯，并的确能简单、有效地进行常规数据处理。

这种借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object 类的特性，要

转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的 toString() 即可，而基本数据

类型转换为 String 类型则要麻烦得多。为解决此类问题 ， Java 为每种基本数据类型分别设计了对应的

类，称之为包装类 (Wrapper Classes) ，也有教材称为外覆类或数据类型类。

 

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一

经创建，其内容（所封装的基本类型数据值）不可改变。

基本类型和对应的包装类可以相互装换：

由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；

包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int 。

2 、包装类的应用

【 1 、 实现 int 和 Integer 的相互转换】

可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。

【 2 、 将字符串转换为整数】

Integer 类有一个静态的 paseInt() 方法，可以将字符串转换为整数，语法为：

parseInt ( String s , int radix );

【 3 、将整数转换为字符串】

Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串。或者直接在整数后面加空字符串即

可！

3、自动拆箱和装箱        

 // 自动装箱拆箱功能
        Integer i = 1;
        int j = i;
        // 手动拆箱
        int x = i.intValue();
        System.out.println(j);

自动拆箱装箱是常用的一个功能，需要重点掌握。

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如： byte 、 int 、 long 、 double 等。然

而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问

题， Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类 （ Integer 、 Long 、 Byte 、 Double 、 Float 、 Short ） 都是 抽象类 Number 的子类

Random 类

Java 中存在着两种 Random 函数：

一、 java.lang.Math.Random;

调用这个 Math.Random() 函数能够返回带正号的 double 值，该值大于等于 0.0 且小于 1.0 ，即取值范围是

[0.0,1.0) 的左闭右开区间，返回值是一个伪随机选择的数，

二、 java.util.Random

下面是 Random() 的两种构造方法：

Random() ：创建一个新的随机数生成器。

Random(long seed) ：使用单个 long 种子创建一个新的随机数生成器。

你在创建一个 Random 对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，

和生成的随机数的区间没有任何关系。

【方法摘要】

1. protected int next(int bits) ：生成下一个伪随机数。

2. boolean nextBoolean() ：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的

boolean 值。

3. void nextBytes(byte[] bytes) ：生成随机字节并将其置于用户提供的 byte 数组中。

4. double nextDouble() ：返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间

均匀分布的 double 值。

5. flfloat nextFloat() ：返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分

布 flfloat 值。

6. double nextGaussian() ：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（ “ 正

态 ” ）分布的 double 值，其平均值是 0.0 标准差是 1.0 。

7. int nextInt() ：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

8. int nextInt(int n) ：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不

包括）之间均匀分布的 int 值。

9. long nextLong() ：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的

日期时间类

1 、 Date 类

java.util 包提供了 Date 类来封装当前的日期和时间。

Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象。

2 、 SimpleDateFormat

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。 SimpleDateFormat 允许

你选择任何用户自定义日期时间格式来运行。例如

 Date date = new Date();
        // 格式化时间
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(simpleDateFormat.format(date));

String 类

1 、 String 概述

在 API 中是这样描述：

String 类代表字符串。 Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 字符串是 常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的， 所以可以共享。

从源码看出 String 底层使用一个字符数组来维护的。

成员变量可以知道 String 类的值是 fifinal 类型的，不能被改变的，所以只要一个值改变就会生成一个新的 String类型对象，存储 String 数据也不一定从数组的第 0 个元素开始的，而是从 offffset 所指的元素开始。

2 、创建字符串对象方式

直接赋值方式创建对象是在方法区的常量池

String str = "hello" ; // 直接赋值的方式

通过构造方法创建字符串对象是在堆内存

String str = new String ( "hello" ); // 实例化的方式

1 内存图分析

 

可能这里还是不够明显，构造方法实例化方式的内存图： String str = new String("Hello");

首先：

 

【字符串常量池】

在字符串中，如果采用直接赋值的方式（ String str="Lance" ）进行对象的实例化，则会将匿名对象

“Lance” 放入对象池，每当下一次对不同的对象进行直接赋值的时候会直接利用池中原有的匿名对象，我 们可以用对象手工入池；

【两种实例化方式的区别】

1. 直接赋值（ String str = "hello" ）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。

2. 构造方法（ String str= new String("hello"); ） : 会开辟两块堆内存空间，其中一块堆内存会变成圾

被系统回收，而且不能够自动入池，需要通过 public String intern(); 方法进行手工入池。

3. 在开发的过程中不会采用构造方法进行字符串的实例化。

4 、 String 的不可变性

因为 String 太过常用， JAVA 类库的设计者在实现时做了个小小的变化，即采用了享元模式 , 每当生成一个 新内容的字符串时，他们都被添加到一个共享池中，当第二次再次生成同样内容的字符串实例时，就共享此对象，而不是创建一个新对象，但是这样的做法仅仅适合于通过= 符号进行的初始化。

需要说明一点的是，在 object 中， equals() 是用来比较内存地址的，但是 String 重写了 equals() 方

法，用来比较内容的，即使是不同地址，只要内容一致，也会返回 true ，这也就是为什么 a.equals(c) 返 回true 的原因了。

【 String 不可变的好处】

可以实现多个变量引用堆内存中的同一个字符串实例，避免创建的开销。

我们的程序中大量使用了 String 字符串，有可能是出于安全性考虑。

大家都知道 HashMap 中 key 为 String 类型，如果可变将变的多么可怕。

当我们在传参的时候，使用不可变类不需要去考虑谁可能会修改其内部的值，如果使用可变类的

话，可能需要每次记得重新拷贝出里面的值，性能会有一定的损失。

5 、字符串常量池

【字符串常量池概述】

1. 常量池表（ Constant_Pool table ）

Class 文件中存储所有常量（包括字符串）的 table 。这是 Class 文件中的内容，还不是运行时的内容，不 要理解它是个池子，其实就是Class 文件中的字节码指令。

1. 运行时常量池（ Runtime Constant Pool ）

JVM 内存中方法区的一部分，这是运行时的内容。这部分内容（绝大部分）是随着 JVM 运行时候，从常 量池转化而来，每个Class 对应一个运行时常量池。上一句中说绝大部分是因为：除了 Class 中常量池内容，还可能包括动态生成并加入这里的内容。

2. 字符串常量池（ String Pool ）

这部分也在方法区中，但与 Runtime Constant Pool 不是一个概念， String Pool 是 JVM 实例全局共享 的，全局只有一个。JVM 规范要求进入这里的 String 实例叫 “ 被驻留的 interned string” ，各个 JVM 可以有 不同的实现，HotSpot 是设置了一个哈希表 StringTable 来引用堆中的字符串实例，被引用就是被驻留。

 

【亨元模式】

其实字符串常量池这个问题涉及到一个设计模式，叫 “ 享元模式 ” ，顾名思义 - - - > 共享元素模式

也就是说：一个系统中如果有多处用到了相同的一个元素，那么我们应该只存储一份此元素，而让所有地方都引用这一个元素

StringBuilder 和 StringBuffffer

StringBuilder 是一个可变的字符序列。它继承于 AbstractStringBuilder ，实现了 CharSequence 接口。

StringBuffffer 也是继承于 AbstractStringBuilder 的子类；但是， StringBuilder 和 StringBuffffer 不同，前者是非线程安全的，后者是线程安全的。

StringBuilder 和 CharSequence 之间的关系图如下：

 

有很多方法

append

insert

delete

indexof

等等

4 、小结

【 String 、 StringBuffffer 、 StringBuilder 之间的区别】

首先需要说明的是：

String 字符串常量

StringBuffffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

在大多数情况下三者在执行速度方面的比较： StringBuilder > StringBuffffer > String

解释：

String 类型和 StringBuffffer 类型的主要性能区别其实在于 String 是不可变的对象 , 因此在每次对 String类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffffer 类则结果就不一样了，每次结果都会对 StringBuffffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffffer ，特别是字符串对象经常改变的情况下。

在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffffer 对象的拼接，

所以这些时候 String 对象的速度并不会比 StringBuffffer 对象慢，而特别是以下的字符串对象生成中，

String 效率是远要比 StringBuffffer 快的：  字符串拼接

 

String S1 = “This is only a” + “ simple” + “ test” ;

StringBuffer Sb = new StringBuilder ( “This is only a” ). append ( “

simple” ). append ( “ test” );

对于三者使用的总结：

1 ）如果要操作少量的数据用 = String

2 ）单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

3 ）多线程操作字符串缓冲区 下操作大量数据 = StringBuffffer

File 类

1 、 File 类的基本用法

1. java.io.File 类：文件和目录路径名的抽象表示形式。

public File ( String pathname )

1. File 的静态属性 String separator 存储了当前系统的路径分隔符。

2. 通过 File 对象可以访问文件的属性。

public boolean canRead ()

public boolean exists ()

public boolean isFile ()

public long lastModified ()

public String getName ()

public boolean canWrite ()

public boolean isDirectory ()

public boolean isHidden ()

public long length ()

public String getPath ()