常用类

Object类

Object是所有类的父类，任何类都默认继承Object。理论上Object类是所有类的父类，即直接或间接的继承java.lang.Object类。由于所有的类都继承在Object类，因此省略了extends Object关键字。

该类中主要有以下方法:

• toString()
• getClass()
• equals()
• clone()
• finalize()

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

【演示：查看Object类源码】

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

1、clone()方法

详解文章：
详解Java中的clone方法 — 原型模式

protected native Object clone() throws CloneNotSupportedException;

clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

创建对象的方式：

• 使用new操作符创建一个对象
• 使用clone方法复制一个对象

相同点和区别：

• new操作符的本意是分配内存。
  • 程序执行到new操作符时， 首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。
  • 分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。
• 而clone在第一步是和new相似的， 都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

clone与copy的区别
假设现在有一个Employee对象，Employee tobby =new Employee(“CMTobby”,5000)
通常我们会有这样的赋值Employee cindyelf=tobby，这个时候只是简单了copy了一下reference，cindyelf和tobby都指向内存中同一个object，这样cindyelf或者tobby的一个操作都可能影响到对方。打个比方，如果我们通过cindyelf.raiseSalary()方法改变了salary域的值，那么tobby通过getSalary()方法得到的就是修改之后的salary域的值，显然这不是我们愿意看到的。我们希望得到tobby的一个精确拷贝，同时两者互不影响，这时候， 我们就可以使用Clone来满足我们的需求。Employee cindy=tobby.clone()，这时会生成一个新的Employee对象，并且和tobby具有相同的属性值和方法。

Shallow Clone与Deep Clone
主要是JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用，我们有时候不希望在方法里将参数改变，这是就需要在类中复写clone方法（实现深复制）。

Clone是如何完成的呢？
Object在对某个对象实施Clone时对其是一无所知的，它仅仅是简单地执行域对域的copy，这就是Shallow Clone。
以Employee为例，它里面有一个域hireDay不是基本数据类型的变量，而是一个reference变量，经过Clone之后就会产生一个新的Date型的reference，它和原始对象中对应的域指向同一个Date对象，这样克隆类就和原始类共享了一部分信息，而这样显然是不利的，过程下图所示：

这个时候我们就需要进行deep Clone了，对那些非基本类型的域进行特殊的处理，例如本例中的hireDay。我们可以重新定义Clone方法，对hireDay做特殊处理，如下代码所示：

class Employee implements Cloneable {
  public Object clone() throws CloneNotSupportedException {
    Employee cloned = (Employee) super.clone();
    cloned.hireDay = (Date) hireDay.clone()
      return cloned;
  }
}

clone方法的保护机制
在Object中Clone()是被声明为protected的，这样做是有一定的道理的，以Employee类为例，通过声明为protected，就可以保证只有Employee类里面才能“克隆”Employee对象.

clone方法的使用
什么时候使用shallow Clone，什么时候使用deep Clone，这个主要看具体对象的域是什么性质的，基本型别还是reference variable
调用Clone()方法的对象所属的类(Class)必须implements Clonable接口，否则在调用Clone方法的时候会抛出CloneNotSupportedException

2、toString()方法

public String toString() {
  return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。
该方法用得比较多，一般子类都有覆盖。
我们推荐在学习阶段所有有属性的类都加上toString() 方法！

public static void main(String[] args){
  Object o1 = new Object();
  System.out.println(o1.toString());
}

3、getClass()方法

public final native Class<?> getClass();

返回此Object的运行时类类型。

不可重写，要调用的话，一般和getName()联合使用，如getClass().getName();

public static void main(String[] args) {
  Object o = new Object();
  System.out.println(o.getClass());
  //class java.lang.Object
}

4、finalize()方法

protected void finalize() throws Throwable { }

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

Java允许在类中定义一个名为finalize()的方法。它的工作原理是：一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法。并且在下一次垃圾回收动作发生时，才会真正回收对象占用的内存。

关于垃圾回收，有三点需要记住：

• 对象可能不被垃圾回收。只要程序没有濒临存储空间用完的那一刻，对象占用的空间就总也得不到释放。

• 垃圾回收并不等于“析构”。

  【科普：析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。】

• 垃圾回收只与内存有关。使用垃圾回收的唯一原因是为了回收程序不再使用的内存。

finalize()的用途：
无论对象是如何创建的，垃圾回收器都会负责释放对象占据的所有内存。
这就将对finalize()的需求限制到一种特殊情况，即通过某种创建对象方式以外的方式为对象分配了存储空间。不过这种情况一般发生在使用“本地方法”的情况下，本地方法是一种在Java中调用非Java代码的方式。

5、equals()方法

public boolean equals(Object obj) {
  return (this == obj);
}

Object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参obj所引用的对象是否是同一对象，所谓同一对象就是指内存中同一块存储单元，如果this和obj指向的hi同一块内存对象，则返回true,如果this和obj指向的不是同一块内存，则返回false。

注意：即便是内容完全相等的两块不同的内存对象，也返回false。
如果是同一块内存，则object中的equals方法返回true,如果是不同的内存，则返回false

如果希望不同内存但相同内容的两个对象equals时返回true,则我们需要重写父类的equal方法
String类已经重写了object中的equals方法（这样就是比较内容是否相等了）

【演示：查看String类源码equals方法】

public boolean equals(Object anObject) {
  if (this == anObject) {
    return true;
  }
  if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = value.length;
    if (n == anotherString.value.length) {
      char v1[] = value;
      char v2[] = anotherString.value;
      int i = 0;
      while (n-- != 0) {
        if (v1[i] != v2[i])
          return false;
        i++;
      }
      return true;
    }
  }
  return false;
}

6、hashCode()方法

public native int hashCode();

返回该对象的哈希码值。
该方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash Code() == obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

7、wait()方法

public final void wait() throws InterruptedException {
  wait(0);
}
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException
{
  if (timeout < 0) {
    throw new IllegalArgumentException("timeout value is negative");
  }
  if (nanos < 0 || nanos > 999999) {
    throw new IllegalArgumentException(
      "nanosecond timeout value out of range");
  }
  if (nanos > 0) {
    timeout++;
  }
  wait(timeout);
}

可以看到有三种重载，wait什么意思呢？

方法中的异常：

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。
wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生:
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

8、notify()方法

public final native void notify();

该方法唤醒在该对象上等待的某个线程。

public final native void notifyAll();

该方法唤醒在该对象上等待的所有线程。

包装类

1、包装类介绍

虽然 Java 语言是典型的面向对象编程语言，但其中的八种基本数据类型并不支持面向对象编程，基本类型的数据不具备“对象”的特性——不携带属性、没有方法可调用。

这种借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object 类的特性，要转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的toString()即可，而基本数据类型转换为 String 类型则要麻烦得多。
为解决此类问题 ，Java为每种基本数据类型分别设计了对应的类，称之为包装类(Wrapper Classes)，也有教材称为外覆类或数据类型类。

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

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

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

2、包装类的应用

1）实现 int 和 Integer 的相互转换
可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。

public static void main(String[] args) {
  int m = 500;
  Integer obj = new Integer(m); // 手动装箱
  int n = obj.intValue(); // 手动拆箱
  System.out.println("n = " + n);
  Integer obj1 = new Integer(500);
  System.out.println("obj 等价于 obj1？" + obj.equals(obj1));
}

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

parseInt(String s, int radix);

s 为要转换的字符串，radix 为进制，可选，默认为十进制。

下面的代码将会告诉你什么样的字符串可以转换为整数：

public static void main(String[] args) {
  String[] str = {"123", "123abc", "abc123", "abcxyz"};
  for(String str1 : str){
    try{
      int m = Integer.parseInt(str1, 10);
      System.out.println(str1 + " 可以转换为整数 " + m);
    }catch(Exception e){
      System.out.println(str1 + " 无法转换为整数");
    }
  }
}
//结果
123 可以转换为整数 123
123abc 无法转换为整数
abc123 无法转换为整数
abcxyz 无法转换为整数

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

public static void main(String[] args) {
  int m = 500;
  String s = Integer.toString(m);
  String s2 = m+"";
  System.out.println("s = " + s);
}

3、自动拆箱和装箱

上面的例子都需要手动实例化一个包装类，称为手动拆箱装箱。Java 1.5(5.0) 之前必须手动拆箱装箱。

Java 1.5 之后可以自动拆箱装箱，即在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。

public static void main(String[] args) {
  int m = 500;
  Integer obj = m; // 自动装箱
  int n = obj; // 自动拆箱
  System.out.println("n = " + n);
  Integer obj1 = 500;
  System.out.println("obj 等价于 obj1？" + obj.equals(obj1));
}
//结果：
// n = 500
// obj 等价于 obj1？true

自动装箱与拆箱的功能事实上是编译器来帮您的忙，编译器在编译时期依您所编写的语法，决定是否进行装箱或拆箱动作。例如：

Integer i = 100;
相当于编译器自动为您作以下的语法编译：
Integer i = new Integer(100);

所以自动装箱与拆箱的功能是所谓的“编译器蜜糖”(Compiler Sugar)，虽然使用这个功能很方便，但在程序运行阶段您得了解Java的语义。例如下面的程序是可以通过编译的：

Integer i = null;
int j = i;

这样的语法在编译时期是合法的，但是在运行时期会有错误，因为这种写法相当于：

Integer i = null;
int j = i.intValue();

null表示i 没有参考至任何的对象实体，它可以合法地指定给对象参考名称。由于实际上i并没有参考至任何的对象，所以也就不可能操作intValue()方法，这样上面的写法在运行时会出现NullPointerException错误。

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

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。
为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

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

System类

• System类代表系统，系统级的很多属性和方法都放置在该类的内部。该类位于java.lang包。
• 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便地进行调用。
• 成员变量
  • System类内部包含in、out和err三个成员变量，分别代表标准输入流（键盘输入）、标准输出流（显示器）和标准错误输出流（显示器）。
• 成员方法
  • native long currentTimeMillis();
    该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间（格林威治时间）1970年1月1好0时0分0秒之间所差的毫秒数；
  • void exit(int status);
    该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
  • void gc();
    该方法的作用是请求系统进行垃圾回收。至于系统是否立刻进行回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
  • String getProperty(String key);
    该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下：
    • java.version java运行时的环境版本
    • java.home java安装目录
    • os.name 操作系统的名称
    • os.version 操作系统的版本
    • user.name 用户的账户名称
    • user.home 用户的主目录
    • user.dir 用户的当前工作目录

Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

【演示：查看Math类的源码】

public final class Math{
//数学方法
}

【常用值与函数】

• Math.PI 记录的圆周率
• Math.E 记录e的常量
• Math中还有一些类似的常量，都是一些工程数学常用量。
• Math.abs 求绝对值
• Math.sin 正弦函数 Math.asin 反正弦函数
• Math.cos 余弦函数 Math.acos 反余弦函数
• Math.tan 正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数
• Math.toDegrees 弧度转化为角度 Math.toRadians 角度转化为弧度
• Math.ceil 得到不小于某数的最大整数
• Math.floor 得到不大于某数的最大整数
• Math.IEEEremainder 求余
• Math.max 求两数中最大
• Math.min 求两数中最小
• Math.sqrt 求开方
• Math.pow 求某数的任意次方, 抛出ArithmeticException处理溢出异常
• Math.exp 求e的任意次方
• Math.log10 以10为底的对数
• Math.log 自然对数
• Math.rint 求距离某数最近的整数（可能比某数大，也可能比它小）
• Math.round 同上，返回int型或者long型（上一个函数返回double型）
• Math.random 返回0，1之间的一个随机数 ```java public static void main(String[] args) { / Math.sqrt()//计算平方根 Math.cbrt()//计算立方根 Math.pow(a, b)//计算a的b次方 Math.max( , );//计算最大值 Math.min( , );//计算最小值 / System.out.println(Math.sqrt(16)); //4.0 System.out.println(Math.cbrt(8)); //2.0 System.out.println(Math.pow(3,2)); //9.0 System.out.println(Math.max(2.3,4.5));//4.5 System.out.println(Math.min(2.3,4.5));//2.3 /

• abs求绝对值 / System.out.println(Math.abs(-10.4)); //10.4 System.out.println(Math.abs(10.1)); //10.1 /*
• ceil天花板的意思，就是返回大的值 / System.out.println(Math.ceil(-10.1)); //-10.0 System.out.println(Math.ceil(10.7)); //11.0 System.out.println(Math.ceil(-0.7)); //-0.0 System.out.println(Math.ceil(0.0)); //0.0 System.out.println(Math.ceil(-0.0)); //-0.0 System.out.println(Math.ceil(-1.7)); //-1.0 /*
• floor地板的意思，就是返回小的值 / System.out.println(Math.floor(-10.1)); //-11.0 System.out.println(Math.floor(10.7)); //10.0 System.out.println(Math.floor(-0.7)); //-1.0 System.out.println(Math.floor(0.0)); //0.0 System.out.println(Math.floor(-0.0)); //-0.0 /*
• random 取得一个大于或者等于0.0小于不等于1.0的随机数 [0,1) / System.out.println(Math.random()); //小于1大于0的double类型的数 System.out.println(Math.random()+1);//大于1小于2的double类型的数 /*
• rint 四舍五入，返回double值
• 注意.5的时候会取偶数 异常的尴尬=。= / System.out.println(Math.rint(10.1)); //10.0 System.out.println(Math.rint(10.7)); //11.0 System.out.println(Math.rint(11.5)); //12.0 System.out.println(Math.rint(10.5)); //10.0 System.out.println(Math.rint(10.51)); //11.0 System.out.println(Math.rint(-10.5)); //-10.0 System.out.println(Math.rint(-11.5)); //-12.0 System.out.println(Math.rint(-10.51)); //-11.0 System.out.println(Math.rint(-10.6)); //-11.0 System.out.println(Math.rint(-10.2)); //-10.0 /*
• round 四舍五入，float时返回int值，double时返回long值 */ System.out.println(Math.round(10.1)); //10 System.out.println(Math.round(10.7)); //11 System.out.println(Math.round(10.5)); //11 System.out.println(Math.round(10.51)); //11 System.out.println(Math.round(-10.5)); //-10 System.out.println(Math.round(-10.51)); //-11 System.out.println(Math.round(-10.6)); //-11 System.out.println(Math.round(-10.2)); //-10 } ```

Random类

Java中存在着两种Random函数：

1）java.lang.Math.Random;
调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。例子如下：

public static void main(String[] args) {
  // 结果是个double类型的值，区间为[0.0,1.0）
  System.out.println("Math.random()=" + Math.random());
  int num = (int) (Math.random() * 3);
  // 注意不要写成(int)Math.random()*3，这个结果为0或1，因为先执行了强制转换
  System.out.println("num=" + num);
}
//结果
//Math.random()=0.44938147153848396
//num=1

2）java.util.Random
下面是Random()的两种构造方法：

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

你在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。

如下面的Java代码：
【演示一】
在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
rand.nextInt(100)中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。

public static void main(String[] args) {
  Random rand =new Random();
  int i=rand.nextInt(100);
  System.out.println(i);
}

【演示二】
对于种子相同的Random对象，生成的随机数序列是一样的。

public static void main(String[] args) {
  Random ran1 = new Random(25);
  System.out.println("使用种子为25的Random对象生成[0,100)内随机整数序列: ");
  for (int i = 0; i < 10; i++) {
    System.out.print(ran1.nextInt(100) + " ");
  }
  System.out.println();
}

【方法摘要】

• protected int next(int bits)：生成下一个伪随机数。
• boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。
• void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。
• double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
• float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
• double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。
• int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
• int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。
• long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
• void setSeed(long seed)：使用单个 long 种子设置此随机数生成器的种子。

【例子】

1. 生成[0,1.0)区间的小数：double d1 = r.nextDouble();
2. 生成[0,5.0)区间的小数：double d2 = r.nextDouble() * 5;
3. 生成[1,2.5)区间的小数：double d3 = r.nextDouble() * 1.5 + 1;
4. 生成[0,10)区间的整数：int n2 = r.nextInt(10);

BigInteger类与BigDecimal类

1、BigInteger类

• Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是它们的包装类都无能为力了，更别说作运算了。
• java.math包的BigInteger可以表示不可变的任何精度的整数。BigInteger提供所以Java的基本整数操作符的对应物，并提供java.lang.Math的所有相关方法。另外，BigInteger还提供一下运算：模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作。
• 构造器
  • BigInteger(String val); 根据字符串构建BigInteger对象
• 常用方法
  • public BigInteger abs();
    返回此BigInteger的绝对值的BigInteger。
  • BigInteger add(BigInteger val);
    返回其值为（this + val）的BigInteger。
  • BigInteger subtract(BigInteger val);
    返回其值为（this - val）的BigInteger。
  • BigInteger multiply(BigInteger val);
    返回其值为（this * val）的BigInteger。
  • BigInteger divide(BigInteger val);
    返回其值为（this / val）的BigInteger。整数相除只保留整数部分。
  • BigInteger remainder(BigInteger val);
    返回其值为（this % val）的BigInteger。
  • BigInteger[] divideAndRemainder(BigInteger val);
    返回包含（this / val）的后跟（this % val）的两个BigInteger的数组；
  • BigInteger pow(int exponent);
    返回其值为（thisexponent）的BigInteger。

2、BigDecimal类

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到 java.math.BigDecimal 类。
• BigDecimal 类支持不可变的、任意精度的有符号十进制定点数。
• 构造器
  • public BigDecimal(double val)
  • public BigDecimal(String val)
• 常用方法
  • public BigDecimal add(BigDecimal augend)
    加
  • public BigDecimal subtract(BigDecimal subtrahend)
    减
  • public BigDecimal multiply(BigDecimal multiplicand)
    乘
  • public BigDecimal devide(BigDecimal divisor,int scale,int roundingMode)
    除

日期时间类

JDK8之前的日期时间

• java.lang.System类
  • System类提供的 public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差，称为时间戳
  • 此方法适用于计算时间差
• java.util.Date类
  • 表示特定的瞬间，精确到毫秒
  • 构造器：
    • Date():使用无参构造器创建当前时间的Date对象
    • Date(long date)：创建指定毫秒数的Date对象
  • 常用方法
    • getTime()：返回自1970年1月1日00:00:00GMT之间的时间差（时间戳）
    • toString()：显示当前的年、月、日、时、分、秒
• java.sql.Date类
  • 对应数据可中的日期类型的变量
  • 实例化 new java.sql.Date(long date);
  • 将java.util.Date对象转换成java.sql.Date对象
  • 情况一：Date date4 = new java.sql.Date(12345678L);
java.sql.Date date5 = (java.sql.Date) date4;
  • 情况二：Date date6 = new Date();
java.sql.Date date7 = new java.sql.Date(date6.getTime());
• java.text.SimpleDateFormat类
  • 是一个不与语言环境有关的方式来格式化和解析日期的具体类
  • 格式化：日期 —>字符串 解析：字符串 —> 日期
  • 格式化
    • SimpleDateFormat() ：默认的模式和语言环境创建对象
    • public SimpleDateFormat(String pattern) ：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
      • public String format(Date date) 方法格式化时间对象date
  • 解析
    • public Date parse(String source) ：从给定字符串的开始解析文本，以生成一个日期
• java.util.Calendar()类
  • Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能。
  • 获取Calendar实例的方法
    • 使用Calendar.getInstance()静态方法
    • 调用它的子类GregorianCalendar的构造器
  • 一个Calendar的实例是系统时间的抽象表示，通过：（常用方法）
    • get(int field) ：获取想要的时间信息。
    • set(int field,int value)
    • add(int field,int amount)
    • getTime() ：日历类 —> Date
    • setTime(Date date) :Date —> 日历类
  • 注意：
    • 获取月份时：一月是0，二月是1，以此类推，12月是11
    • 获取星期时：周日是1，周二是2，…，周六是7

1、Date类

java.util 包提供了 Date 类来封装当前的日期和时间。
Date 类提供两个构造函数来实例化 Date 对象。

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

Date()

第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。

Date(long millisec)

Date对象创建以后，可以调用下面的方法。

【演示：获取当前日期时间】
Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间
如下所示：

public static void main(String args[]) {
  // 初始化 Date 对象
  Date date = new Date();
  // 使用 toString() 函数显示日期时间
  System.out.println(date.toString());
  //Sat Apr 27 15:09:43 CST 2019
}

【演示：日期比较】

• 使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。

  public static void main(String[] args) {
  // 初始化 Date 对象
  Date date = new Date();
  long time = date.getTime();
  long time2 = date.getTime();
  System.out.println(time==time2);
  }

• 使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2,12).before(new Date (99, 2, 18)) 返回true。

  public static void main(String[] args) {
  boolean before = new Date(97, 01, 05).before(new Date(99, 11, 16));
  System.out.println(before);
  }

2、SimpleDateFormat

【演示：使用 SimpleDateFormat 格式化日期】
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。例如：

public static void main(String args[]) {
  Date dNow = new Date( );
  SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
  System.out.println("当前时间为: " + ft.format(dNow));
}

其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。

注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：

【演示：使用printf格式化日期】
Java 格式化输出 printf 例子
printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

public static void main(String args[]) {
  // 初始化 Date 对象
  Date date = new Date();
  //c的使用
  System.out.printf("全部日期和时间信息：%tc%n",date);
  //f的使用
  System.out.printf("年-月-日格式：%tF%n",date);
  //d的使用
  System.out.printf("月/日/年格式：%tD%n",date);
  //r的使用
  System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);
  //t的使用
  System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);
  //R的使用
  System.out.printf("HH:MM格式（24时制）：%tR",date);
}
//结果:
全部日期和时间信息：星期六 四月 27 15:23:45 CST 2019
年-月-日格式：2019-04-27
月/日/年格式：04/27/19
HH:MM:SS PM格式（12时制）：03:23:45 下午
HH:MM:SS格式（24时制）：15:23:45
HH:MM格式（24时制）：15:23

【时间休眠：休眠(sleep)】
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。

你可以让程序休眠一毫秒的时间或者到您的计算机的寿命长的任意段时间。例如，下面的程序会休眠3秒：

public static void main(String args[]) {
  try {
    System.out.println(new Date( ) + "\n");
    Thread.sleep(1000*3); // 休眠3秒
    System.out.println(new Date( ) + "\n");
  } catch (Exception e) {
    System.out.println("Got an exception!");
  }
}

3、Calendar类

Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类，在实际使用时实现特定 的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象

public static void main(String args[]) {
  Calendar c = Calendar.getInstance();//默认是当前日期
  System.out.println(c);
}
//输出
java.util.GregorianCalendar[time=1556350818634,areFieldsSet=true,areAllFields Set=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offs
et=28800000,dstSavings=0,useDaylight=false,transitions=29,lastRule=null],firs
tDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=3,WEEK_OF_YEAR=17
,WEEK_OF_MONTH=4,DAY_OF_MONTH=27,DAY_OF_YEAR=117,DAY_OF_WEEK=7,DAY_OF_WEEK_IN
_MONTH=4,AM_PM=1,HOUR=3,HOUR_OF_DAY=15,MINUTE=40,SECOND=18,MILLISECOND=634,ZO
NE_OFFSET=28800000,DST_OFFSET=0]

创建一个指定日期的Calendar对象
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

//创建一个代表2019年4月27日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2019, 4 - 1, 27);

Calendar类对象字段类型
Calendar类中用以下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想

// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
  int day = c1.get(Calendar.DAY_OF_WEEK);

【演示：设置完整日期】

c1.set(2009, 6 - 1, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12

【演示：设置某个字段】

c1.set(Calendar.DATE,10);
c1.set(Calendar.YEAR,2008);
//其他字段属性set的意义以此类推

【add设置】

//把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
//把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);

【演示：GregorianCalendar】

public static void main(String args[]) {
  String months[] = {
    "Jan", "Feb", "Mar", "Apr",
    "May", "Jun", "Jul", "Aug",
    "Sep", "Oct", "Nov", "Dec"};
  int year;
  // 初始化 Gregorian 日历
  // 使用当前时间和日期
  // 默认为本地时间和时区
  GregorianCalendar gcalendar = new GregorianCalendar();
  // 显示当前时间和日期的信息
  System.out.print("Date: ");
  System.out.print(months[gcalendar.get(Calendar.MONTH)]);
  System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
  System.out.println(year = gcalendar.get(Calendar.YEAR));
  System.out.print("Time: ");
  System.out.print(gcalendar.get(Calendar.HOUR) + ":");
  System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
  System.out.println(gcalendar.get(Calendar.SECOND));
  // 测试当前年份是否为闰年
  if(gcalendar.isLeapYear(year)) {
    System.out.println("当前年份是闰年");
  }
  else {
    System.out.println("当前年份不是闰年");
  }
}
//输出：
Date: Apr 27 2019
Time: 3:56:20
当前年份不是闰年

注意：Calender的月份是从0开始的，但日期和年份是从1开始的

【演示】

public static void main(String[] args) {
  Calendar c1 = Calendar.getInstance();
  c1.set(2017, 1, 1);
  System.out.println(c1.get(Calendar.YEAR)
                     +"-"+c1.get(Calendar.MONTH)
                     +"-"+c1.get(Calendar.DATE));
  c1.set(2017, 1, 0);
  System.out.println(c1.get(Calendar.YEAR)
                     +"-"+c1.get(Calendar.MONTH)
                     +"-"+c1.get(Calendar.DATE));
}
//输出
2017-1-1
2017-0-31

可见，将日期设为0以后，月份变成了上个月，但月份可以为0，把月份改为2试试：

public static void main(String[] args) {
  Calendar c1 = Calendar.getInstance();
  c1.set(2017, 2, 1);
  System.out.println(c1.get(Calendar.YEAR)
                     +"-"+c1.get(Calendar.MONTH)
                     +"-"+c1.get(Calendar.DATE));
  c1.set(2017, 2, 0);
  System.out.println(c1.get(Calendar.YEAR)
                     +"-"+c1.get(Calendar.MONTH)
                     +"-"+c1.get(Calendar.DATE));
}
//输出
2017-2-1
2017-1-28

可以看到上个月的最后一天是28号，所以Calendar.MONTH为1的时候是2月 。

Java8中新的日期时间API

• java.time — 包含值对象的基础包
• java.time.chrono — 提供对不同的日历系统的访问
• java.time.format — 格式化和解析时间和日期
• java.time.temporal — 包括底层框架和拓展特性
• java.time.zone — 包含时区支持的类

说明：大多数开发者只会用到基础包和format包，也可能用到temporal包。

LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime类是其中重要的几个类，它们的实例对象是不可变的对象，分别表示使用ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与失去相关的信息。

ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历。

• LocalDate代表ISO格式（yyyy-MM-dd）的日期，可以存储生日、纪念日等日期。
• LocalTime表示一个时间，而不是日期。
• LocalDateTime是用来表示日期和时间的，这是一个最常用的类。

/**
now(); 获取当前的日期、时间、日期和时间；
of();  获取指定的年、月、日、时、分、秒（没有偏移量）；
getXxx(); 获取相关的属性；
getDayOfMonth();/getDayOfYear();  获取月份天数（1-31）/获取年份天数（1-366）；
getDayOfWeek();  获取星期几，返回一个DayOfWeek枚举值；
getMonth();  获得月份，返回一个Month枚举值；
getMonthValue();/getYear();  获得月份（1-12）/获得年份
getHour();/getMinute();/getSecond();  获取当前对象对应的小时、分钟、秒
withXxx();  设置相关的属性； 
withDayOfMonth();/withDayOfYear();/withMonth();/withYear();  设置月份天数、年份天数、月份、年份；
plusDays();/plusWeeks();/plusMonths();/plusYears();/plusHours();  添加几天、几周、几个月、几年、几小时；
minusDays();/minusWeeks();/minusMonths();/minusYears();/minusHours();  减去几天、几周、几月、几年、几小时；  
*/

Instant瞬时

• Instant：时间线上的一个瞬时点。这可能被用来记录应用程序中事件的时间戳。
• java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上一个点，而不需要任何上下文信息，例如：时区。
• 概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。
• （1ns = 10-9 s） 1秒=1000毫秒=106微妙=109纳秒 ```java /** now(); 静态方法，返回默认UTC时区的Instant类的对象；获取对应的格林威治时间；

ofEpochMilli(long epochMilli); 静态方法，返回1979-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象；

atOffset(ZoneOffset offset); 结合即时的偏移来创建一个OffsetDateTime;

toEpochMilli(); 返回1979-01-01 00:00:00到当前时间的毫秒数，即为时间戳； */

> 时间戳是指格林威治时间1979-01-01 00:00:00（北京时间1979-01-01 08:00:00）起到现在的总秒数。
<a name="b4dae58a"></a>
#### 格式化与解析日期或时间
`java.time.format.DateTimeFormat`类：该类提供了三种格式化方法：
-  预定义的标准格式；如：`ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME;` 
-  本地化相关的格式；如：`ofLocalizedDateTime(FormatStyle.LONG);ofLocalizedDateTime(FormatStyle.MEDIUM);ofLocalizedDateTime(FormatStyle.SHORT);` 
-  自定义的格式；如：`ofPattern("yyyy-MM-dd hh:mm:ss E")` 
```java
/**
ofPattern(String pattern);  静态方法，返回一个指定字符串格式的DateTimeFormatter;
format(TemporalAccessor t);  格式化一个日期、时间，返回字符串；
parse(CharSequence text);  将指定格式的字符序列解析为一个日期、时间；
*/

String类

1、String概述

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

String对象的字符内容是存储在一个字符数组value[]中的。

【演示：查看String源码】

public final class String
  implements java.io.Serializable, Comparable<String>, CharSequence{
  /** The value is used for character storage. */
  private final char value[];
  /** Cache the hash code for the string.*/
  private int hash;//Default to 0
}

String:字符串，使用一堆""双引号引起来表示
1.String 声明为final，不可被继承
2.String 实现了 Serializable接口：表示字符串是支持序列化的
         实现了Comparable接口：表示字符串可以比较大小
3.String 内部定义了final char[] value用于存储字符串数据
4.String：代表不可变的字符序列。简称：不可变性

【理解String的不可变性】

package com.wang.classtest.string;
import org.junit.Test;
/**
 * @Author wangjin
 * @Date 2022/03/27 10:46
 * @Description String的使用
 */
public class stringTest {
    /**
     * String:字符串，使用一堆""双引号引起来表示
     * 1.String 声明为final，不可被继承
     * 2.String 实现了 Serializable接口：表示字符串是支持序列化的
     * 实现了Comparable接口：表示字符串可以比较大小
     * 3.String 内部定义了final char[] value用于存储字符串数据
     * 4.String：代表不可变的字符序列。简称：不可变性
     *      体现：1）当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值
     *           2）当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
     *           3）当调用String的replace()方法修改指定的字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
     * 5.通过字面量的方式（区别于new方式）给一个字符串赋值，此时字符串声明在字符串常量池中
     * 6.字符串常量常量池中不会
     */
    @Test
    public void test1() {
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        s1 = "hello";
        System.out.println(s1 == s2);//比较的是s1和s2的地址值
        System.out.println(s1);//hello
        System.out.println(s2);//abc
        String s3="abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        String s4="abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }
}

【String的成员变量】

//String的属性值
private final char value[];
//数组被使用的开始位置
private final int offset;
//String中元素的个数
private final int count;
//String类型的hash值
private int hash; // Default to 0
private static final long serialVersionUID = -6849794470754667710L;
private static final ObjectStreamField[] serialPersistentFields =
  new ObjectStreamField[0];

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

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

【String的构造方法】

String()
        //初始化一个新创建的 String 对象，使其表示一个空字符序列。
String(byte[] bytes)
        //通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, Charset charset)
        //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, int offset, int length)
        //通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, int offset, int length, Charset charset)
        //通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, int offset, int length, String charsetName)
        //通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, String charsetName)
        //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String(char[] value)
        //分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String(char[] value, int offset, int count)
        //分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
String(int[] codePoints, int offset, int count)
        //分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。
String(String original)
        //初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
String(StringBuffer buffer)
        //分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
String(StringBuilder builder)
        //分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

2、创建字符串对象方式

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

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

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

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

//本质上 this.value = new char[0];
String s1 = new String();
//this.value = original.value;
String s2 = new String(String original1);
//this.value = Arrays.copyOf(value,value.length);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count);

package com.wang.classtest.string;
import org.junit.Test;
/**
 * @Author wangjin
 * @Date 2022/03/27 11:56
 * @Description String的实例化方式
 */
public class stringDemo02 {
    /**
     * String的实例化方式
     * 方式一：通过字面量定义的方式
     * 方式二：通过 new + 构造器 的方式
     */
    @Test
    public void test() {
        //通过字面量定义的方式：此时s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1 = "javaEE";
        String s2 = "javaEE";
        //通过 new + 构造器 的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false
    }
}

【字符串对象是如何存储的？】

面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？ 两个：一个是堆空间中new结构，另一个是char[]数组对应的常量池中的数据“abc”.

public class stringDemo02 {
    /**
     * 结论：
     * 1.常量与常量的拼接结果在常量池中，并且常量池中不会存在相同内容的常量
     * 2.只要其中有一个是变量，结果就在堆中
     * 3.如果拼接的结果调用intern()方法，返回值就在常量池中
     */
    @Test
    public void test01() {
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
    }

结论：

• 常量与常量的拼接结果在常量池中，并且常量池中不会存在相同内容的常量
• 只要其中有一个是变量，结果就在堆中
• 如果拼接的结果调用intern()方法，返回值就在常量池中

【一道面试题】

public class StringTest(){
  String str = new String(original:"good");
  char[] ch = {'t','e','s','t'};
  public void change(String str,char ch[]){
    str = "test ok";
    ch[0] = 'b';
  }
  public static void main(String[] args){
    StringTest ex = new StringTest();
    ex.change(ex.str,ex.ch);
    System.out.println(ex.str);//good
    System.out.println(ex.ch);//best
  }
}

【两种实例化方式的比较】

• 编写代码比较 ```java public static void main(String[] args) { String str1 = “Lance”; String str2 = new String(“Lance”); String str3 = str2; //引用传递，str3直接指向st2的堆内存地址 String str4 = “Lance”; /**

• ==:
• 基本数据类型：比较的是基本数据类型的值是否相同
• 引用数据类型：比较的是引用数据类型的地址值是否相同
• 所以在这里的话：String类对象==比较，比较的是地址，而不是内容 */ System.out.println(str1==str2);//false System.out.println(str1==str3);//false System.out.println(str3==str2);//true System.out.println(str1==str4);//true } ```

• 内存图分析

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

首先：

当我们再一次的new一个String对象时：

【字符串常量池】
在字符串中，如果采用直接赋值的方式（String str="Lance"）进行对象的实例化，则会将匿名对象“Lance”放入对象池，每当下一次对不同的对象进行直接赋值的时候会直接利用池中原有的匿名对象，我们可以用对象手工入池；

public static void main(String args[]){
  String str =new String("Lance").intern();//对匿名对象"hello"进行手工入池操作
  String str1="Lance";
  System.out.println(str==str1);//true
}

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

• 直接赋值（String str = "hello"）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。
• 构造方法（String str= new String("hello");）:会开辟两块堆内存空间，其中一块堆内存会变成垃圾被系统回收，而且不能够自动入池，需要通过public String intern();方法进行手工入池。
• 在开发的过程中不会采用构造方法进行字符串的实例化。

【避免空指向】
首先了解： == 和public boolean equals()比较字符串的区别
==在对字符串比较的时候，对比的是内存地址，而equals比较的是字符串内容，在开发的过程中，equals()通过接受参数，可以避免空指向。

String str = null;
if(str.equals("hello")){//此时会出现空指向异常
  ...
}
if("hello".equals(str)){//此时equals会处理null值，可以避免空指向异常
  ...
}

【String类对象一旦声明则不可以改变；而改变的只是地址，原来的字符串还是存在的，并且产生垃圾】

3、String常用的方法

//1.基本操作
int length():返回字符串的长度，return value.length
char charAt(int index):返回某索引处的字符，return value[index]
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引,从前往后找
int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引，从后往前找
int lastindexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
//注：indexOf() 和 lastIndexOf()方法如果未找到都是返回-1
//2.转换操作
char[] toCharArray():将此字符串转换为一个字符数组  char[] arr = str.toCharArray(); --str是字符串
String valueOf(int i):将int型数转换为字符串
String toLowerCase():使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase():使用默认语言环境，将 String 中的所有字符转换为大写  
//3.替换与去除
String replace(char oldChar, char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的
String replace(CharSequence target,CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
String replaceAll(String regex, String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
String replaceFirst(String regex, String replacement):使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串  
String trim():返回字符串的副本，忽略前导空白和尾部空白
//4.连接、截取与分割
String concat(String str):将指定字符串连接到此字符串的尾部，等价于用 "+"
String[] split(String regex):根据给定正则表达式的匹配拆分此字符串
String[] split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中
String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串
String substring(int beginIndex, int endIndex):返回一个新的字符串，它是此字符串从beginIndex开始截取到endIndex（不包含）的一个字符串  
//5.判断操作
int compareTo(String antherString):比较两个字符串的大小
boolean isEmpty():判断是否是空字符，return value.length == 0
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String antherString):与equals方法类似，忽略大小写
boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix,int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true
//6.匹配
boolean matches(String regex):告知此字符串是否匹配给定的正则表达式

1）String的判断

【常用方法】

• boolean equals(Object obj)：比较字符串的内容是否相同
• boolean equalsIgnoreCase(String str)： 比较字符串的内容是否相同,忽略大小写
• boolean startsWith(String str)： 判断字符串对象是否以指定的str开头
• boolean endsWith(String str)： 判断字符串对象是否以指定的str结尾

【演示】

public static void main(String[] args) {
  // 创建字符串对象
  String s1 = "hello";
  String s2 = "hello";
  String s3 = "Hello";
  // boolean equals(Object obj):比较字符串的内容是否相同
  System.out.println(s1.equals(s2)); //true
  System.out.println(s1.equals(s3)); //false
  System.out.println("-----------");
  // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
  System.out.println(s1.equalsIgnoreCase(s2)); //true
  System.out.println(s1.equalsIgnoreCase(s3)); //true
  System.out.println("-----------");
  // boolean startsWith(String str):判断字符串对象是否以指定的str开头
  System.out.println(s1.startsWith("he")); //true
  System.out.println(s1.startsWith("ll")); //false
}

2）String的截取

【常用方法】

• int length():获取字符串的长度，其实也就是字符个数
• char charAt(int index):获取指定索引处的字符
• int indexOf(String str):获取str在字符串对象中第一次出现的索引
• String substring(int start):从start开始截取字符串
• String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end

【演示】

public static void main(String args[]) {
  // 创建字符串对象
  String s = "helloworld";
  // int length():获取字符串的长度，其实也就是字符个数
  System.out.println(s.length()); //10
  System.out.println("--------");
  // char charAt(int index):获取指定索引处的字符
  System.out.println(s.charAt(0)); //h
  System.out.println(s.charAt(1)); //e
  System.out.println("--------");
  // int indexOf(String str):获取str在字符串对象中第一次出现的索引
  System.out.println(s.indexOf("l")); //2
  System.out.println(s.indexOf("owo")); //4
  System.out.println(s.indexOf("ak")); //-1
  System.out.println("--------");
  // String substring(int start):从start开始截取字符串
  System.out.println(s.substring(0)); //helloworld
  System.out.println(s.substring(5)); //world
  System.out.println("--------");
  // String substring(int start,int end):从start开始，到end结束截取字符串
  System.out.println(s.substring(0, s.length())); //helloworld
  System.out.println(s.substring(3, 8)); //lowor
}

3）String的转换

【常用方法】

• char[] toCharArray()：把字符串转换为字符数组
• String toLowerCase()：把字符串转换为小写字符串
• String toUpperCase()：把字符串转换为大写字符串

【演示】

public static void main(String args[]) {
  // 创建字符串对象
  String s = "abcde";
  // char[] toCharArray():把字符串转换为字符数组
  char[] chs = s.toCharArray();
  for (int x = 0; x < chs.length; x++) {
    System.out.println(chs[x]);
  }
  System.out.println("-----------");
  // String toLowerCase():把字符串转换为小写字符串
  System.out.println("HelloWorld".toLowerCase());
  // String toUpperCase():把字符串转换为大写字符串
  System.out.println("HelloWorld".toUpperCase());
}

4）其他方法

【常用方法】

• 去除字符串两端空格：String trim()
• 按照指定符号分割字符串：String[] split(String str)

【演示】

public static void main(String args[]) {
  // 创建字符串对象
  String s1 = "helloworld";
  String s2 = " helloworld ";
  String s3 = " hello world ";
  System.out.println("---" + s1 + "---");
  System.out.println("---" + s1.trim() + "---");
  System.out.println("---" + s2 + "---");
  System.out.println("---" + s2.trim() + "---");
  System.out.println("---" + s3 + "---");
  System.out.println("---" + s3.trim() + "---");
  System.out.println("-------------------");
  // String[] split(String str)
  // 创建字符串对象
  String s4 = "aa,bb,cc";
  String[] strArray = s4.split(",");
  for (int x = 0; x < strArray.length; x++) {
    System.out.println(strArray[x]);
  }
}

4、String的不可变性

当我们去阅读源代码的时候，会发现有这样的一句话：

Strings are constant; their values cannot be changed after they are created.

意思就是说：String是个常量，从一出生就注定不可变。String类被final修饰，官方注释说明创建后不能被改变。

【了解一个经典的面试题】

public static void main(String[] args) {
  String a = "abc";
  String b = "abc";
  String c = new String("abc");
  System.out.println(a==b); //true
  System.out.println(a.equals(b)); //true
  System.out.println(a==c); //false
  System.out.println(a.equals(c)); //true
}

内存图分析：

【分析】
因为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文件中的字节码指令。

• 运行时常量池（Runtime Constant Pool）

JVM内存中方法区的一部分，这是运行时的内容。这部分内容（绝大部分）是随着JVM运行时候，从常量池转化而来，每个Class对应一个运行时常量池。

• 字符串常量池（String Pool）

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

【亨元模式】
其实字符串常量池这个问题涉及到一个设计模式，叫“享元模式”，顾名思义 - - - > 共享元素模式也就是说：一个系统中如果有多处用到了相同的一个元素，那么我们应该只存储一份此元素，而让所有地方都引用这一个元素

Java中String部分就是根据享元模式设计的，而那个存储元素的地方就叫做“字符串常量池 - String Pool”

【详细分析】

int x = 10;
String y = "hello";

1. 首先， 10 和”hello” 会在经过javac（或者其他编译器）编译过后变为Class文件中constant_pool table 的内容
2. 当我们的程序运行时，也就是说JVM运行时，每个Class constant_pool table 中的内容会被加载到JVM内存中的方法区中各自Class的Runtime Constant Pool。
3. 一个没有被String Pool包含的Runtime Constant Pool中的字符串（这里是”hello”）会被加入到String Pool中（HosSpot使用hashtable引用方式），步骤如下：
   • 在Java Heap（堆）中根据”hello”字面量create一个字符串对象
   • 将字面量”hello”与字符串对象的引用在hashtable中关联起来，键 - 值形式是：”hello” = 对象的引用地址。

另外来说，当一个新的字符串出现在Runtime Constant Pool中时怎么判断需不需要在Java Heap中创建新对象呢？
策略是这样：会先去根据equals来比较Runtime Constant Pool中的这个字符串是否和String Pool中某一个是相等的（也就是找是否已经存在），如果有那么就不创建，直接使用其引用；反之，就如同上面的第三步。如此，就实现了享元模式，提高的内存利用效率。

举例：

使用String s = new String("hello");会创建几个对象
答：会创建2个对象
首先，出现了字面量"hello"，那么去String Pool中查找是否有相同字符串存在，因为程序就这一行代码所以肯定没有，那么就在Java Heap中用字面量"hello"首先创建1个String对象。
接着，new String("hello")，关键字new又在Java Heap中创建了1个对象，然后调用接收String参数的构造器进行了初始化。最终s的引用是这个String对象.

String 与基本数据类型、包装类之间的转换

• String —-> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)

• 基本数据类型 —-> String：调用String重载的valueOf(xxx)方法

  public void test(){
  String str1 = "123";
  int num = Integer.parseInt(str1);
  String str2 = String.valueOf(num);
  System.out.println(str2);//123
  }

String与字符数组转换

• 字符数组 —-> 字符串
  • String类的构造器：String(char[])和 String(char[], int offset, int length)分别用字符数组中的全部字符和部分字符创建字符串对象。

• 字符串 —-> 字符数组

  • public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法
  • public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法。 ```java public void test(){ String str1 = “abc123”;

  //String —> char[]:调用String的toCharArray()方法 //char[] —> String:调用String的构造器 char[] charArray = str1.toCharArray(); for(int i = 0;i < charArray.length;i++){ System.out.println(charArray[i]) }

  char[] arr = new char[]{‘h’,’e’,’l’,’l’,’o’}; String str2 = new String(arr); System.out.println(str2) } ```

String与字节数组转换

//String与byte[]之间的转换
//String --> byte[]：调用String的getBytes()方法
//byte[] --> String：调用String构造器
public void test(){
  String str1 = "abc123";
  byte[] bytes = str1.getBytes();//使用默认的字符集进行转换
  System.out.println(Arrays.toString(bytes));//[97,98,99,49,50,51]
  String str2 = new String(bytes);
  System.out.println(str2);
}

StringBuilder和StringBuffer

1、概述

【演示：查看源码及API文档】

public final class StringBuilder
  extends AbstractStringBuilder
  implements java.io.Serializable, CharSequence{
}

StringBuilder 是一个可变的字符序列。它继承于AbstractStringBuilder，实现了CharSequence接口。
StringBuffer 也是继承于AbstractStringBuilder的子类；但是，StringBuilder和StringBuffer不同，前者是非线程安全的，后者是线程安全的。

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

【源码概览】

package java.lang;
public final class StringBuilder
  extends AbstractStringBuilder
  implements java.io.Serializable, CharSequence {
  static final long serialVersionUID = 4383685877147921099L;
  // 构造函数。
  //默认的字符数组大小是16。
  public StringBuilder() {
    super(16);
  }
  // 构造函数。指定StringBuilder的字符数组大小是capacity。
  public StringBuilder(int capacity) {
    super(capacity);
  }
  // 构造函数。指定字符数组大小=str长度+15，且将str的值赋值到当前字符数组中。
  public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
  }
  // 构造函数。指定字符数组大小=seq长度+15，且将seq的值赋值到当前字符数组中。
  public StringBuilder(CharSequence seq) {
    this(seq.length() + 16);
    append(seq);
  }
  // 追加“对象obj对应的字符串”。String.valueOf(obj)实际上是调用obj.toString()
  public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
  }
  // 追加“str”。
  public StringBuilder append(String str) {
    super.append(str);
    return this;
  }
  // 追加“sb的内容”。
  private StringBuilder append(StringBuilder sb) {
    if (sb == null)
      return append("null");
    int len = sb.length();
    int newcount = count + len;
    if (newcount > value.length)
      expandCapacity(newcount);
    sb.getChars(0, len, value, count);
    count = newcount;
    return this;
  }
  // 追加“sb的内容”。
  public StringBuilder append(StringBuffer sb) {
    super.append(sb);
    return this;
  }
  // 追加“s的内容”。
  public StringBuilder append(CharSequence s) {
    if (s == null)
      s = "null";
    if (s instanceof String)
      return this.append((String)s);
    if (s instanceof StringBuffer)
      return this.append((StringBuffer)s);
    if (s instanceof StringBuilder)
      return this.append((StringBuilder)s);
    return this.append(s, 0, s.length());
  }
  // 追加“s从start(包括)到end(不包括)的内容”。
  public StringBuilder append(CharSequence s, int start, int end) {
    super.append(s, start, end);
    return this;
  }
  // 追加“str字符数组对应的字符串”
  public StringBuilder append(char[] str) {
    super.append(str);
    return this;
  }
  // 追加“str从offset开始的内容，内容长度是len”
  public StringBuilder append(char[] str, int offset, int len) {
    super.append(str, offset, len);
    return this;
  }
  // 追加“b对应的字符串”
  public StringBuilder append(boolean b) {
    super.append(b);
    return this;
  }
  // 追加“c”
  public StringBuilder append(char c) {
    super.append(c);
    return this;
  }
  // 追加“i”
  public StringBuilder append(int i) {
    super.append(i);
    return this;
  }
  // 追加“lng”
  public StringBuilder append(long lng) {
    super.append(lng);
    return this;
  }
  // 追加“f”
  public StringBuilder append(float f) {
    super.append(f);
    return this;
  }
  // 追加“d”
  public StringBuilder append(double d) {
    super.append(d);
    return this;
  }
  // 追加“codePoint”
  public StringBuilder appendCodePoint(int codePoint) {
    super.appendCodePoint(codePoint);
    return this;
  }
  // 删除“从start(包括)到end的内容”
  public StringBuilder delete(int start, int end) {
    super.delete(start, end);
    return this;
  }
  // 删除“位置index的内容”
  public StringBuilder deleteCharAt(int index) {
    super.deleteCharAt(index);
    return this;
  }
  // “用str替换StringBuilder中从start(包括)到end(不包括)的内容”
  public StringBuilder replace(int start, int end, String str) {
    super.replace(start, end, str);
    return this;
  }
  // “在StringBuilder的位置index处插入‘str中从offset开始的内容’，插入内容长度是len”
    public StringBuilder insert(int index, char[] str, int offset,
                                int len)
  {
    super.insert(index, str, offset, len);
    return this;
  }
  // “在StringBuilder的位置offset处插入obj对应的字符串”
  public StringBuilder insert(int offset, Object obj) {
    return insert(offset, String.valueOf(obj));
  }
  // “在StringBuilder的位置offset处插入str”
  public StringBuilder insert(int offset, String str) {
    super.insert(offset, str);
    return this;
  }
  // “在StringBuilder的位置offset处插入str”
  public StringBuilder insert(int offset, char[] str) {
    super.insert(offset, str);
    return this;
  }
  // “在StringBuilder的位置dstOffset处插入s”
  public StringBuilder insert(int dstOffset, CharSequence s) {
    if (s == null)
      s = "null";
    if (s instanceof String)
      return this.insert(dstOffset, (String)s);
    return this.insert(dstOffset, s, 0, s.length());
  }
  // “在StringBuilder的位置dstOffset处插入's中从start到end的内容'”
  public StringBuilder insert(int dstOffset, CharSequence s,
                              int start, int end)
  {
    super.insert(dstOffset, s, start, end);
    return this;
  }
  // “在StringBuilder的位置Offset处插入b”
  public StringBuilder insert(int offset, boolean b) {
    super.insert(offset, b);
    return this;
  }
  // “在StringBuilder的位置Offset处插入c”
  public StringBuilder insert(int offset, char c) {
    super.insert(offset, c);
    return this;
  }
  // “在StringBuilder的位置Offset处插入i”
  public StringBuilder insert(int offset, int i) {
    return insert(offset, String.valueOf(i));
  }
  // “在StringBuilder的位置Offset处插入l”
  public StringBuilder insert(int offset, long l) {
    return insert(offset, String.valueOf(l));
  }
  // “在StringBuilder的位置Offset处插入f”
  public StringBuilder insert(int offset, float f) {
    return insert(offset, String.valueOf(f));
  }
  // “在StringBuilder的位置Offset处插入d”
  public StringBuilder insert(int offset, double d) {
    return insert(offset, String.valueOf(d));
  }
  // 返回“str”在StringBuilder的位置
  public int indexOf(String str) {
    return indexOf(str, 0);
  }
  // 从fromIndex开始查找，返回“str”在StringBuilder的位置
  public int indexOf(String str, int fromIndex) {
    return String.indexOf(value, 0, count,
                          str.toCharArray(), 0, str.length(),
                          fromIndex);
  }
  // 从后向前查找，返回“str”在StringBuilder的位置
  public int lastIndexOf(String str) {
    return lastIndexOf(str, count);
  }
  // 从fromIndex开始，从后向前查找，返回“str”在StringBuilder的位置
  public int lastIndexOf(String str, int fromIndex) {
    return String.lastIndexOf(value, 0, count,
                              str.toCharArray(), 0, str.length(),
                              fromIndex);
  }
  // 反转StringBuilder
  public StringBuilder reverse() {
    super.reverse();
    return this;
  }
  public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
  }
  // 序列化对应的写入函数
  private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    s.defaultWriteObject();
    s.writeInt(count);
    s.writeObject(value);
  }
  // 序列化对应的读取函数
  private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();
    count = s.readInt();
    value = (char[]) s.readObject();
  }
}