java常用类：getClass,hashCode,toString,equals,clone,notify,wait,包装类，Math，Random，File，Data,String/Builder

最新推荐文章于 2022-12-12 20:40:18 发布

邹飞鸣

最新推荐文章于 2022-12-12 20:40:18 发布

阅读量307

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/qq_43483251/article/details/107523014

版权

java常用类

注：少量内容借鉴其他人的文章，只做学习交流，侵删。

1.Object类

1.基类，所以类默认继承此类

1.getClass（）方法

作用：判断类的对象是不是同一类型。

public class Foundation02 {
    public static void main(String[] args){
        GetClass01 g1=new GetClass01();
        GetClass01 g2=new GetClass01();
        //调用getClass方法，并用Class类型的变量接收
        Class C1=g1.getClass();
        Class C2=g2.getClass();
       if(C1==C2){
           System.out.println("是同一类型");
       }else{
           System.out.println("不是同一类型");
       }
    }
}
class GetClass01{

}

2.hashCode()方法

作用：根据对象地址或者字符串或者数字使用hash算法计算出来int类型的数值即返回值是int类型。

这里的对象不是指a,而是指new 出来A类的对象，而这个对象依靠类型为A的变量a来接收，且称a为对象引用变量

//比如new一个对象
A a=new A();

public class Foundation02 {
    public static void main(String[] args){
        GetClass01 g1=new GetClass01();
        GetClass01 g2=new GetClass01(); 
        //虽然类型相同，但是两个变量都有自己的地址，除非将其中一个值赋值给另一个变量，此时两变量哈希值才相同，即都指向同一个实例化地址
           System.out.println(g1.hashCode());
           System.out.println(g2.hashCode());
    }
}
class GetClass01{

}

3.toString()方法

1.返回

getClass().getName() + “@” + Integer.toHexString(hashCode())

这返回的是：类的全路径名称+它的哈希码值

public class Foundation02 {
    public static void main(String[] args){
        GetClass01 g1=new GetClass01();
        GetClass01 g2=new GetClass01(); 
        
           System.out.println(g1.toString());
           System.out.println(g2.toString());
    }
}
class GetClass01{

}

一般没用所以会重写方法：

按下Alt+Shift+s

public class Foundation02 {
    public static void main(String[] args){
        GetClass01 g1=new GetClass01();
        System.out.println(g1.toString());
    }
}
class GetClass01{
             public int ID=10;
    //在与重写变量相关的类中重写toString
    public String toString() {
        return ""+ID;
    }
}

4.equals()

1.没有重写时比较的是两个值的地址是否相同。

2.字符串的值是存放在常量池中的，每当一个字符串变量被赋值时，会先判断这个值是否在常量池中有相同的内容，如果有则不会重新开辟一个空间来存放这个值，而是直接将这个字符串变量指向这个值，所以equals()方法比较的就是这个值的地址是否相同。

3.总结就是equals方法比较的是变量指向的内容的地址！

4.变量.equals(Object obj),参数也是个变量。

5.返回值是布尔类型

//方法的源码
 public boolean equals(Object obj) {
        return (this == obj);
    }
//实现：实例化三个引用变量，且构造函数的初始化值都相同为“a”
public class Foundation02 {
    public static void main(String[] args){
        GetClass01 g1=new GetClass01("a");
        GetClass01 g2=new GetClass01("a");
        GetClass01 g3=g2;
        //可以发现g1和g2虽然是不同引用变量，但是他们指向的内容是相同的，所以为true
        
        System.out.println("g1,g2----------------");
        if(g1.str.equals(g2.str)){
            System.out.println("内容相同");
        }else{
            System.out.println("内容不同");
        }
        //同上都是在判断内容的地址是否相同
        
        System.out.println("g1==g2----------------");
        if(g1.str==g2.str){
            System.out.println("内容相同");
        }else{
            System.out.println("内容不同");
        }
        //而g2赋值给g3，相当于他们指向同一个对象，而之所以使用hashCode方法判断时g2和g3相同，是因为hashCode方法判断的是对象的地址，而不是对象引用变量的地址（对象引用变量即g2和g3）
        
        System.out.println("g3,g2----------------");
        if(g2.str.equals(g3.str)){
            System.out.println("内容相同");
        }else{
            System.out.println("内容不同");
        }
    }
}
class GetClass01{
             public int ID;
             public String str;
    public GetClass01(String i){
        this.str=i;
    }

}

3.一般情况是会重写此方法，作用是比较两个对象内容是否相等

步骤：1.比较两个引用是否指向同一对象，是直接返回true

2.判断obj是否为null，

3.判断两个引用指向的实际对象类型是否一致

4.强制类型转换

5.比较各属性值是否相等

//重写代码
public boolean equals(Object obj){
    //判断两个对象是否是同一个引用
    if(this==obj) return true;
    //判断obj是否null
    if(obj==null) return false;
    //判断是否是同一类型
    if(obj instanceof GetClass01){//instanceof是比较两者类型是否相同和hashCode类似
        //强制类型转换
        GetClass01 g=(GetClass01)obj;
        //equals比较的是字符串，不能是其他类型
        if(this.str.equals(g.getStr())) 
            return true;
    }
    return false;
}

5.clone()方法

1.作用：复制对象。

与等号区别：等号是两个指向同一个对象，此方法是复制出两个完全一样，相互独立的对象。默认为protected

2.实现步骤，

1.clone存在于Object类中，要想调用此方法进行浅复制，首先实现Cloneable此接口，此接口无任何需要实现的方法，只是作为一个标志，其次需要对clone方法进行重写，因为此方法默认是受保护的即protected，重写时需要写成public

//clone()方法，复制对象
class A implements Cloneable{       //实现接口，即要重写方法，不然会报错
    public Object clone(){          //要进行异常处理，不然用supre调用不了方法
        A a=null;
        try{
            a=(A)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return a;
    }
}

3.继承至Object类的clone方法是浅复制，

4.浅复制：只复制了对象，但是一个类中可能有其他对象变量（如：String类型的变量），这些对象并没有被clone，所以这些对象依旧指向原空间。

示意图：（a为对象引用变量，a1为clone（）复制出来的，str为String类型变量，"名字"为str中的内容）

浅：两个对象的str指向一个空间

对象引用变量 | 类的对象 | String对象

a----------------------> str ------------------\

                               "名字"

a1---------------------> str------------------/

注意：String类型虽然是浅复制，但是String类型，在赋值的时候，并没有修改原来的值！而是重新指向了一个新值的地址，所以不用担心还是指向原来地址的问题，所以深复制一般用做以类名为类型的数据，此时就要用到深复制。

（注：此时不宜以String为例，则用以类名为类型的变量为例）

为什么基本数据类型不需要深复制，而引用对象变量需要：

因为基本数据类型存在于栈中，而引用对象变量虽然也在栈中，但是它指向堆中的一个地址，如果只是单纯复制，那么复制的是引用对象变量，即还是复制了一个指向原来地址的引用对象变量，那么原引用对象变量和现引用对象变量作用的是一个地址空间，这样是不允许的，必须要将现有的引用对象变量指向的地址独立出来，才是成功的复制，所以用到了深复制来解决这个问题：

深：类中如果有以类名为类型的变量即：

class A{}
class B{
    A a;//以类名为类型的变量
}

这时候就需要将这个也进行clone（复制），才能保证这个a指向的地址不是原来的空间

代码：

//在F05类中定义一个以A2为类型的变量a，用做深复制的例子。
public class F05 implements Cloneable{
    A2 a;
    public F05(){}             //因为要调用以其他类为类型的变量，所以此类实例化对象时也要附带new其他类
    public F05(A2 a){          //所以构造方法只有空的，要写一个初始化a的构造方法，最好保留一个空的构造函数
        this.a=a;
    }
    public  Object clone () throws CloneNotSupportedException{
       F05 f=(F05)super.clone();  //重写方法，并在方法之上抛出，在main方法时接收异常并处理
       f.a=(A2)a.clone();         //对其他类的引用对象变量进行复制
       return f;                  //返回值变为new出来的f
    }
}
//对类进行接口继承与方法重写，只有这样才能clone以A2为类型的变量（即引用对象变量）
class A2 implements Cloneable{
    public Object clone () throws CloneNotSupportedException{
        return (A2)super.clone();         //返回类型要强制转换为类名，super是调用父类的clone
    }
}
//测试类
class Cs{
    public static void main(String[] args) {
        try {                            //try做检测用
            F05 f=new F05(new A2());     //实例化对象时要记得在构造方法中new A2类
            F05 f1=(F05) f.clone();      //进行复制（深复制）
            System.out.println(f.a.hashCode());//进行类中变量a的哈希值比较，即比较地址是否相同，如果不同，则表明是两个不同的地址空间，即成功！
            System.out.println(f1.a.hashCode());
        }catch (CloneNotSupportedException c){
            c.printStackTrace();
        }
    }
}

代码结果：

356573597
1735600054

Process finished with exit code 0

对象引用变量 | 类的对象指向的变量a | a变量地址的哈希值

f---------------------> a ------------------> 356573597

f1---------------------> a ------------------> 1735600054

6.notify()

public final void notify()
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：
通过执行此对象的同步实例方法。
通过执行在此对象上进行同步的 synchronized 语句的正文。
对于 Class 类型的对象，可以通过执行该类的同步静态方法。
一次只能有一个线程拥有对象的监视器。

/**
 * wait()&&notify()方法
 * 这两个方法是在Object中定义的，用于协调线程同步，比join更加灵活
 */
public class NotifyDemo {
    public static void main(String[] args) {
        //写两个线程 1.图片下载
        Object obj=new Object();
        Thread download=new Thread(){
            public void run() {
                System.out.println("开始下载图片");
                for (int i = 0; i < 101; i+=10) {
                    System.out.println("down"+i+"%");
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("图片下载成功");
                synchronized (obj) {
                    obj.notify();//唤起
                }
                System.out.println("开始下载附件");
                for (int i = 0; i < 101; i+=10) {
                    System.out.println("附件下载"+i+"%");

                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
                System.out.println("附件下载成功");
            }
        };
        //2.图片展示
        Thread show=new Thread(){
            public void run(){
                synchronized (obj) {
                    try {
                        obj.wait();//阻塞当前
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("show:开始展示图片");
                    System.out.println("图片展示完毕");
                }

            }
        };
        download.start();
        show.start();
    }
}
————————————————
版权声明：本文为CSDN博主「Of_the」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41140741/article/details/81488663

7.wait()

wait（）：
public final void wait() throws InterruptedException
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。
对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：
synchronized (obj) {
while ()
obj.wait();
… // Perform action appropriate to condition
}
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。
抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，任何线程中断了当前线程。在抛出此异常时，当前线程的中断状态被清除。
————————————————

2.包装类

1.装箱：基本类型转成引用类型的过程。

拆箱：引用类型转换成基本类型。

//jdk1.5以前
//装箱
int num=10;
//先创建int类型的对象
Integer i=new Integer(num);//利用Integer类中的构造函数进行转换
Integer I=Integer.valueof(num);//利用类中方法进行转换
//拆箱
Integer i=new Integer(100);//构造函数初始化
int num=i.intValue();//利用类中方法转换
//jdk1.5以后可自动转换
//装箱
int num=30;
Integer i=num;
//拆箱
int num=i;

2.基本类型的包装类

byte Byte

shotr Short

int Integer

long Long

float Float

double Double

boolean Boolean

char Character

3.字符串与基本类型之间的转换

1.int类型转换

1.使用加号

int i=10;
String str=i+"";

3.Math类

算数计算：

Math.sqrt() : 计算平方根
Math.cbrt() : 计算立方根
Math.pow(a, b) : 计算a的b次方
Math.max( , ) : 计算最大值
Math.min( , ) : 计算最小值
Math.abs() : 取绝对值

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

进位：

Math.ceil(): 天花板的意思，就是逢余进一
Math.floor() : 地板的意思，就是逢余舍一
Math.rint(): 四舍五入，返回double值。注意.5的时候会取偶数
Math.round(): 四舍五入，float时返回int值，double时返回long值

/**
* 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

System.out.println("-------------------");

/**
 * 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

System.out.println("-------------------");

/**
 * 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

System.out.println("-------------------");
/**
 * round 四舍五入，float时返回int值，double时返回long值
 */
System.out.println(Math.round(10)); // 10
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

注意：参数要是float或者double。

随机数：

Math.random(): 取得一个[0, 1)范围内的随机数

4.Random（生成随机数）

1.存在两种一个是

1.java.lang.Math.Random下的random方法，伪随机数，取值0.0-1.0，double类型

2.java.util.Random

伪随机，

//不写种子默认为当前时间毫秒数，相同种子数，得出的随机数也相同
Random r=new random();//构造方法中填写种子数，可默认
Random r=new random(20);
r.nextInt(100);//0-100内随机数，不包括100
//如果需要不重复的随机数，可借助数组和集合类，具体代码不写。

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 种子设置此随机数生成器的种子。

5.File类（操作文件）

File类的构造方法：

1.File（String path）:将一个字符串描述的路径，封装成一个File对象

File file = new File("F:/a.txt");//指定路径  [构造函数]

2.File(String parent，String Child ):将两个字符串（父级路径，子级路径），拼接之后形成的路径封装成一个File对象。

3.File(File parent, String child)
将File类型的父级路径和String类型的字节路径拼接成一个新路径，封装成File对象

File files = new File("F:\\","b.txt");//第一个参数是路径，第二个参数是要创建文件的文件名  [构造函数]

路径最好是绝对路径。：在电脑中的真实路径如：D:/a/b/c.txt

1.创建

目录分割符：在Windows机器上的目录分隔符是\，在Linux机器上的目录分隔符是/

注意：在Windows上面\与/都可以作为目录分隔符。而且，如果写/的时候，只需要写1个正斜杠即可，而写\的时候，需要写2个反斜杠。

1.创建文件：

注意：需要进行异常处理。

createNewFile();//成功返回true

2.创建文件夹：

mkdir()
 	 	创建文件夹，如果父级路径不存在，则文件夹创建失败
mkdirs()
 	 	创建文件夹，如果父级路径不存在，则自动创建父级路径，再创建子级路径

3.renameTo(File dest)：重命名文件或文件夹。文件不同时，相当于文件的剪切，剪切的时候不能操作非空文件夹。移动/重命名成功返回true，失败返回false

例：

注意：1.要进行异常处理，2.要导入包。

import java.io.File;
import java.io.IOException;

public class F06 {
    public static void main(String[] args) throws IOException {
        new F06().found();
    }
    public  void found() throws IOException {
        //创建文件
        File file = new File("C:\\Users\\邹飞鸣\\Desktop\\学习资料\\2020.7.14（暑假）\\markdown学习笔记\\javaSE笔记\\File类创建的文件.md");
        if(file.createNewFile()){//创建文件并判断是否成功
                System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
        //创建文件夹
        File file01=new File("C:\\Users\\邹飞鸣\\Desktop\\学习资料\\2020.7.14（暑假）\\markdown学习笔记\\javaSE笔记\\File类创建的文件夹");
        if(file01.mkdir()){//创建文件夹并判断是否成功
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
    }
}

2.删除

1.方法名称：delete()

2.使用规范：既可以删除文件，也可以删除文件夹

3.注意：1、删除的时候不走回收站，直接删除
2、不能删除非空文件夹

例：

public static void main(String[] args) throws IOException {
        //创建文件
        File file = new File("C:\\Users\\邹飞鸣\\Desktop\\学习资料\\2020.7.14（暑假）\\markdown学习笔记\\javaSE笔记\\File类创建的文件.md");
        file.createNewFile();
        //创建文件夹
        File file01 = new File("C:\\Users\\邹飞鸣\\Desktop\\学习资料\\2020.7.14（暑假）\\markdown学习笔记\\javaSE笔记\\File类创建的文件夹");
        file01.mkdir();
        //删除文件,删除文件夹
        if(file.delete())
        if(file01.delete()) System.out.println("删除成功");
    }

4.deleteOnExit()：在虚拟机终止时,请求删除此抽象路径名的文件或者目录,保证文件异常时也可以删除文件(注意：谨慎使用)

3.重命名

方法名称：renameTo(File dest)

2、注意事项：

1、方法的调用者，是一个File对象，方法的参数是另外一个File对象
2、调用者是当前修改之前的路径对象，参数是要修改为的路径对象
3、如果改了父级路径，就是剪切，如果不改父级路径就是重命名

4.获取

getName()：获取文件或文件夹名称
getPath()：返回的是绝对路径,可以是相对路径,但是目录要指定
getAbsolutePath()：获取绝对路径
length()：获取文件的大小(字节为单位)
getParent()：获取文件的父路径
lastModified()：获取文件最后一次修改的时间

5.判断

exists()：判断指定的文件或者文件夹是否存在
isFile()：判断是否是一个文件；如果不存在，则为false
isDirectory()：判断是否是一个文件夹
isHidden()：判断指定的文件是否是隐藏文件
isAbsolute()：判断指定的文件或文件夹是否是在绝对路径下

6.Data类

1.包：Date类是在java.util包下的Date类。

2.创建

Data d=new Data();//构造函数没有值默认为当前时间
//创建我们指定的时间对象
Date d1 = new Date(2014-1900, 6-1, 12);//年要减去1900，月要减1

3正确获得一个date对象所包含的信息

如：

Date d2 = new Date(2014-1900, 6-1, 12);
   //获得年份 （注意年份要加上1900，这样才是日期对象d2所代表的年份）
   int year = d2.getYear() + 1900;
   //获得月份 （注意月份要加1，这样才是日期对象d2所代表的月份）
   int month = d2.getMonth() + 1;
   //获得日期
   int date = d2.getDate();
   //获得小时
   int hour = d2.getHours();//不设置默认为0
   //获得分钟
   int minute = d2.getMinutes();
   //获得秒
   int second = d2.getSeconds();
   //获得星期 （注意：0代表星期日、1代表星期1、2代表星期2，其他的一次类推了）
   int day = d2.getDay();

2.Calendar(建议使用的时间操作类)

1.创建：

Java月份是从0-11，月份设置时要减1

// 使用当前时间创建
Calendar calendar = Calendar.getInstance();
// 设置指定日期，月份需要减一
calendar.set(year, month - 1, day);
// 指定时间创建，参数依次为：年，月，日，时，分，秒，月份需要减一
Calendar calendar = new GregorianCalendar(2016, 8, 1, 15, 41, 22);
// Date转换为Calendar 
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);

获取：年，月，日，时，分，秒，星期

Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
// 取月份要加1
int month = calendar.get(Calendar.MONTH) + 1;
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hover = calendar.get(Calendar.HOUR_OF_DAY);
int minute = calendar.get(Calendar.MINUTE);
int seconds = calendar.get(Calendar.SECOND);
// 1-7分别代表 -- 星期日,星期一,星期二,星期三,星期四,星期五,星期六
int week = calendar.get(calendar.DAY_OF_WEEK);

获取当前月份的最大天数

Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_MONTH);

Calendar 转换为Date

Date date = Calendar.getInstance().getTime();

日期加减

public class A {
    // 使用默认时区和语言环境获得一个日历。
    private static Calendar calendar = Calendar.getInstance();
    public static void print(String name) {
        System.out.print(name + ": ");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime()));
    }
    public static void main(String[] args) {
        print("当前时间   ");
        calendar.add(Calendar.HOUR_OF_DAY, 1);
        print("增加1小时");
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        print("增加1天");
        calendar.add(Calendar.MONTH, 1);
        print("增加1个月");
        calendar.add(Calendar.YEAR, 1);
        print("增加1年");
        calendar.add(Calendar.YEAR, -2);
        print("减少2年");
    }
}

两个日期相差天数:

long millisOfDay = 24 * 60 * 60 * 1000;
Calendar calendar = new GregorianCalendar(2015, 9, 1);
Calendar calendar1 = new GregorianCalendar(2016, 9, 1);
Calendar calendar2 = new GregorianCalendar(2017, 9, 1);
// 2016年是闰年，得到366天
System.out.println((calendar1.getTimeInMillis() - calendar.getTimeInMillis()) / millisOfDay);
// 2017年是平年，得到365天
System.out.println((calendar2.getTimeInMillis() - calendar1.getTimeInMillis()) / millisOfDay);

Calendar获取年、月、日、时间

Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT+08:00"));    //获取东八区时间
        //获取年
        int year = c.get(Calendar.YEAR);
        //获取月份，0表示1月份
        int month = c.get(Calendar.MONTH) + 1;
        //获取当前天数
        int day = c.get(Calendar.DAY_OF_MONTH);
        //获取本月最小天数
        int first = c.getActualMinimum(Calendar.DAY_OF_MONTH);
        //获取本月最大天数
        int last = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        //获取当前小时
        int time = c.get(Calendar.HOUR_OF_DAY);
        //获取当前分钟
        int min = c.get(Calendar.MINUTE);
        //获取当前秒
        int sec = c.get(Calendar.SECOND);  

        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String curDate = s.format(c.getTime());                                      //当前日期
        System.out.println("当前时间：" + year + "-" + month + "-" + day + " " + time + ":" + min + ":" + sec);
        System.out.println("第一天和最后天：" + first +"," + last);
        System.out.println("当前日期：" + curDate);

3.SimpleDateFormat类

定义：是时间简单格式化类，它允许格式日期，解析日期，并且格式化，它可以将String类型的时间格式转化成Date类型或者将Date类型时间转化成为String类型。SimpleDateFormat不是线程安全的，因此format方法和parse方法会在多线程的情况下发生严重错误，这个需要注意。

SimpleDateFormat() 
SimpleDateFormat(String pattern) 
SimpleDateFormat(String pattern, DateFormatSymbols formatSymbols) 
SimpleDateFormat(String pattern, Locale locale)

pattern函数语法:

G 年代标志符

y 年

M 月

d 日

h 时在上午或下午 (1~12)

H 时在一天中 (0~23)

m 分

s 秒

S 毫秒

E 星期

D 一年中的第几天

F 一月中第几个星期几

w 一年中第几个星期

W 一月中第几个星期

a 上午 / 下午标记符

k 时在一天中 (1~24)

K 时在上午或下午 (0~11)

z 时区

Date parse(String text, ParsePosition pos) //分析字符串中的文本以生成日期 
StringBuffer format(Date date) //将给定日期格式化为日期/时间字符串，并将结果追加到给定的StringBuffer。

例：

1. 时间格式化（年月日时分秒

public class DateDemo1{
    public static void main(String args[]){
        Date current=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String c=sdf.format(current);
        System.out.println(c);
    }
}

//输出：
2019-06-01 10:01:52

2.时间转换

//日期格式为 x年x月x日（eg：2019年6月25日）
public Date DateDemo2(String s){
	DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
	LocalDate date= LocalDate.parse(s, formatter);
}

7.String类

构造方法摘要

//创建String对象，字符串中没有内容
String s1 = new String();   
// 创建String对象，把数组元素作为字符串的内容
byte[] bys = new byte[]{97,98,99,100};
String s2 = new String(bys); 
//创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数length为要几个元素
String s3 = new String(bys, 1, 3); 
//创建String对象，把数组元素作为字符串的内容
char[] chs = new char[]{’a’,’b’,’c’,’d’,’e’};
String s4 = new String(chs); 
//创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数count为要几个元素
String s5 = new String(chs, 0, 3);
//创建String对象，字符串内容为abc
String s6 = new String(“abc”);

方法摘要

1.获取字符串长度

tring str = "abcde";
int len = str.length();
System.out.println("len="+len);

2.获取部分字符串

tring str = "abcde";
System.out.println(str.substring(0,1));

3.字符串是否以指定字符串开头

String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//判断是否以给定字符串开头
boolean b2 = str.startsWith("String");
boolean b3 = str.endsWith("java");//判断是否以给定字符串结尾

4.字符串是否包含另一个字符串

String str = "abcde";
int index = str.indexOf(“bcd”); //判断是否包含指定字符串，包含则返回第一次出现该字符串的索引，不包含则返回-1
boolean b2 = str.contains("bcd");//判断是否包含指定字符串，包含返回true，不包含返回false

5.将字符串转成一个字符数组。或者字节数组。

String str = "abcde";
char[] chs = str.toCharArray();//将此字符串转为一个新的数组
byte[] bytes = str.getBytes();//使用平台默认字符集将String编码为byte序列，并将结果存储到一个新的byte数组中

6.判断两个字符串中的内容是否相同

String str = "abcde";
String str2 = "abcde";
String str3 = "hello";
boolean b1 = str.equals(str2);
boolean b2 = str.equals(str3);

//boolean equalsIgnoreCase(String a):不考虑大小写,两个字符串比较
boolean b2 = str.equalsIgnoreCase(str3);

7.获取该字符串对象中的内容

String str = new String("hello");
System.out.println( str.toString() );//返回此对象本身（它已经是一个字符串）
System.out.pintln( str );

8.String trim()

截去字符串两端的空格，但对于中间的空格不处理。

String str = " a sd ";
String str1 = str.trim();
int a = str.length();//a = 6
int b = str1.length();//b =

9.String[] split(String str)

将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。

1 String str = "asd!qwe|zxc#";
2 String[] str1 = str.split("!|#");//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";

注意：

之所以，要用到下面类，是因为String类型的变量被赋值之后值是无法被更改的，当重新对这个变量进行赋值，实际上是将这个变量指向的地址更改为新值的地址，旧值依旧存在于常量池中，那么如何做到不改变指向只改变内容了？这就要用下面类：

8.StringBuffer:

特点：多线程数据量大效率低，安全

1.定义：StringBuffer又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

2.构造方法

StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。

3.方法

append(),insert(),delete()replace()

StringBuffer sb = new StringBuffer();

sb.append("haha"); //添加字符串

sb.insert(2, "it");//在指定位置插入

sb.delete(1, 4);//删除

sb.replace(1, 4, "cast");//替换指定范围内的内容

reverse():返回，反的字符串顺序

 StringBuffer stringBuffer=new StringBuffer();
        stringBuffer.append("zoufeiming");
        System.out.println(stringBuffer.reverse());
//结果：gnimiefuoz

toString()：返回字符串内容

StringBuffer stringBuffer=new StringBuffer();
        stringBuffer.append("zoufeiming");
        System.out.println(stringBuffer.toString());
//结果：zoufeiming