Java复习笔记：Java常用的API

Java常用API一、API概述API (Application Programming Interface) : 应用程序编程接口Java API :指的就是JDK中提供的各种功能的Java类,这些类将底层的实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用二、API文档的使用①打开API文档②找到索引选项卡中的输入

MadnessQing

258人浏览 · 2021-08-10 22:13:45

MadnessQing · 2021-08-10 22:13:45 发布

Java常用API

一、API概述

API (Application Programming Interface) : 应用程序编程接口

Java API :
	指的就是JDK中提供的各种功能的Java类,这些类将底层的实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用

二、API文档的使用

①打开API文档

②找到索引选项卡中的输入框

③输入要学习的类的名称，回车

④看类在那个包下

⑤看类的描述，知道这个类能干啥

⑥看构造方法（参数个数，参数的类型）

ctry+alt+v 快速生成方法返回值

⑦看成员方法（方法名，参数，返回值类型，方法的介绍）

三、Scanner类

使用的注意事项：

next() ：遇到空格，就不再录入数据

结束标记：空格、tab键
nextline():可以将数据完整的接收过来结束标记：回车换行符
nextInt()那hextl ine()方法配台使用的时候，nextline方法就没有键盘录入的机会

解决方案：

建议:今后键盘承入数据的时候，如果是宇符串和整数一起接收，建议使用next.方法接受字符申。

四、String

1.String类在java.lang包下，使用时不需要导包

2.java程序中，所有的双引号宇符串，都是String这个类的对象

3.字符串是常量：它们的值（地址值）在创建之后不能更改

1、String常见的构造方法

①public Strin() 创建一个空白字符串对象，不含有任何内容

②public String(char[] chs) 根据字符数组的内容，来创建字符串对象

③public String(String original) :根据传入的字符申内容,来创建宇符申对象

④String s =““abc”; 西接赋值的方式创建字符串对象,内容就是abc

注意：

String这个类比较特殊，打印其对象名的时候，不会出现内存地址而是该对象所记录的真实内容.

2、创建字符串对象的区别对比

以""方式给出的字符串,只要字符序列相同(顺序和大小写) ,无论在程序代码中出现几次,JVM都只会建立一个String对象，并在字符串常量池中维护

问题:构造方法能创建对象,双引|号也能创建字符串对象,有什么区别吗?
字符串的比较

字符串是对象,它比较内容是否相同,是通过一个方法来实现的,这个方法叫: equalsO

（public boolean equals(Object anObject) :将此字符串与指定对象进行比较。由于我们比较的是字符串对象,所以参数直接传递一个字符串）
注意：==号作比较

基本数据类型：比较的是具体的值

引用数据类型：比较的是地址值
字符串常量池:当使用双引号创建字符串对象的时候,系统会检查该字符串是否在字符串常量池中存在

（不存在：创建；存在：不会重新创建,而是直接复用）
双引号创建的字符串对象与通过构造方法创建的字符串对象的区别？

结论:双引号创建的字符串对象,在字符串常量池中存储,通过构造方法创建的字符串对象,在堆内存中存储

3、String字符串的特点

Java程序中所有的双引号字符串,都是String类的对象
字符串不可变,它们的值在创建后不能被更改
虽然String的值是不可变的,但是它们可以被共享
当字符串之间使用+号串联(拼接)的时候,系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成并接，拼接后,再调用其toString方法转换为String类型

4、字符串的两种遍历方式

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        /**
         * 需求:键盘录入一个字符串,使用程序实现在控制台遍历该字符串
         *
         * 思路:
         * ①键盘录入一个字符串,用Scanner实现
         * ②遍历字符串,首先要能够获取到字符串中的每-一个字符
         *      ●public char charAt(int index) :返回指定索引处的char值,字符串的索引也是从0开始的
         * ③遍历字符串,其次要能够获取到字符串的长度
         *      ●public int length() :返回此字符串的长度
         *      ●数组的长度:数组名.length
         *      ●字符串的长度:字符串对象.length()
         *  ④遍历
         */
        // 1.键盘录入一个字符串,用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String s = sc.nextLine();
        // 2.遍历字符串,首先要能够获取到字符串中的每-一个字符
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            System.out.println(c);
        }
    }
}

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        /**
         * 需求:键盘录入-个字符串,使用程序实现在控制台遍历该字符串
         * 思路:
         * ①键盘录入-个字符串,用Scanner实现
         * ②将字符串拆分为字符数组
         *      ●public char[ toCharArray() :将当前字符串拆分为字符数组并返回
         * ③遍历字符数组
         */
        // 1.键盘录入一个字符串,用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String s = sc.nextLine();
        // 2.将字符串拆分为字符数组
        char[] chars = s.toCharArray();
        // 3.遍历字符数组
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

    }
}

5、案例

案例一：统计字符次数

需求：键盘录入-一个字符串,统计该字符串中大写字母字符, 小写字姆字符,数字字符出现的次数(不考虑其他字符
思路:
①键盘录入-一个字符串,用Scanner实现
②要统计三种类型的字符个数,需定义三个统计变量,初始值都为0
③遍历字符串,得到每-个字符
④判断该字符属于哪种塑,然后对应类型的统计效+ 1
假如ch是一个字符,我要判断它属于大写字母,写字姆,还是数字,直接判断该字符是否在对应的范围即可

●大写字母: ch>=‘A’ &&ch<=‘Z’
●小写字母: ch>=‘a’ &&ch<=‘z’
●数字: ch>=‘0’&&ch<=‘9’

⑤.输出三种类型的字符个数

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        //1.键盘录入-一个字符串,用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String s = sc.nextLine();

        //2.要统计三种类型的字符个数,需定义三个统计变量,初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numCount = 0;

        //3.遍历字符串,得到每-个字符
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            //4.判断该字符属于哪种塑,然后对应类型的统计效+ 1
            if (c >='A' && c <='Z' ){
                bigCount++;
            }else if (c >='a' && c <='z'){
                smallCount++;
            }else if (c >='0' && c <='9' ){
                numCount++;
            }
        }
        System.out.println("大写字母的个数："+bigCount+", 小写字母的个数："+smallCount+", 数字的个数："+numCount);
    }
}

案例二：手机号屏蔽

求:以字符串的形式从键盘接受-个手机号,将中间四位号码屏蔽
终效果为: 1561234
思路:
①键盘录入一个字符串,用Scanner实现
②截取字符串前三位
●String substring(int beginIndex, int endIndex) :从beginIndex索引位置开始截取,截取到endIndex索引位置,
得到新字符串并返回(包含头,不包含尾)
●Strings1 = telString.substring(0,3);
③截取字符串后四位
●String substring(int beginIndex):从传入的索引位置处,向后截取, 一直截取到末尾,得到新的字符串并返回
●String s2 = telString.substring(7);
④将截取后的两个字符串,中间加进行拼接,输出结果

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        /**
         * 需求:以宇符串的形式从键盘接受- -个手机号,将中间四位号码屏蔽
         * 最终效果为: 156****1234
         * 思路:
         * 1.键盘录入一个字符串,用Scanner实现
         * 2.截取字符串前三位
         * 3.截取字符串后四位
         * 4.将截取后的两个字符串,中间加上****进行拼接,输出结果
         */
        //1.键盘录入-一个字符串,用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号：");
        String s = sc.nextLine();
        
        //2.截取字符串前三位
        String start = s.substring(0, 3);

        // 3.截取字符串后四位
        String end = s.substring(7);

        //4.将截取后的两个字符串,中间加上****进行拼接,输出结果
        System.out.println(start+"****"+end);
    }
}

案例三：敏感词替换

需求:键盘录入一个字符串,如果字符串中包含(TMD) ,则使用**替换
思路:
①键盘录入一个字符串,用Scanner实现
②替换敏感词
●String replace(CharSequence target, CharSequence replacement)
将当前字符串中的target (被替换的旧值)内容,使用replacement (替换的新值)进行替换，返回新的字符串
③输出结果

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        /**
         * 需求:經盘录入一个宇符串，如果宇符串中包含(TMD ) ,则使用**替换
         * 思路:
         *      1.健盘录入一个字符串，用Scanner实现
         *      2.昔换敏感词
         *      String replace(CharSequence target, CharSequence replacement)
         *      舟当前字符串中的target内容，使replacement进行替换,返回新的字符串
         *      3.输出結果
         */
        // 1.键盘录入-一个字符串,用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String s = sc.nextLine();

        // 2.昔换敏感词
        String replace = s.replace("TMD", "***");

        //  3.输出結果
        System.out.println(replace);
    }
}

案例四：字符串的切割

需求:以宇符串的形式从健盘录入学生信息,例如:“张三，23”
从该字符申中切割出有效数据,封装为Student学生对象
思路:

1.编写Student类，用于封装数据

2.鍵盘录入一个宇符申,用Scanner 实现

3…根据逗号切割字符串, 得到(张三) (23 )

String[] split(String regex) : 根据传入的字符串作为规则进行切割,将切剖后的内容存入宇符申数組中，并将宇符申数組返回

4.从得到的字符申数组中取出元素内容,通过s tudent类的有参构造方法封装为对象

5.调用对象getXxx方法，取出数据并打印。

// 1.编写Student类，用于封装数据
public class Student {
    private String name;
    private String age;

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

import java.util.Scanner;

public class text6 {
    public static void main(String[] args) {
        /**
         * 需求:以宇符串的形式从健盘录入学生信息,例如:“张三，23”
         * 从该字符申中切割出有效数据,封装为Student学生对象
         * 思路:
         *      1.编写Student类，用于封装数据
         *      2.鍵盘录入一个宇符申,用Scanner 实现
         *      3..根据逗号切割字符串, 得到(张三) (23 )
         *      String[] split(String regex) : 根据传入的字符串作为规则进行切割,将切剖后的内容存入宇符申数組中，并将宇符申数組返回
         *      4.从得到的字符申数组中取出元素内容,通过s tudent类的有参构造方法封装为对象
         *      5.调用对象getXxx方法 ，取出数据并打印。
         */

        //2.鍵盘录入一个宇符申,用Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息：例如:张三，23");
        String s = sc.nextLine();
        //3..根据逗号切割字符串, 得到(张三) (23 )
        String[] split = s.split(",");
        // 4.从得到的字符申数组中取出元素内容,通过s tudent类的有参构造方法封装为对象
        Student student = new Student(split[0], split[1]);
        System.out.println(student.getName()+"...."+student.getAge());
    }
}

五、StringBuilder

1、StringBuilder概述

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder 对象中的内容是可变的

作用：提高字符串的操作效率

// 分别用string，Stringbuilder做100000次的拼接，比较耗时长短
public class Demo {
    public static void main(String[] args) {
        stringMethod(); //耗时 21407
        stringBuilderMethod(); //耗时: 21

    }

    public static void stringBuilderMethod() {
        long start = System.currentTimeMillis();
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            s.append(i);
        }
        System.out.println(s);
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }

    public static void stringMethod() {
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < 100000; i++) {
            s += i;
        }
        System.out.println(s);
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

2.构造方法

StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。

StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

3.StringBuilder类常用方法

public StringBuilder append(任意类型)  			添加数据，并返回对象本身

public StringBuilder reverse()				   返回相反的字符序列

public int length()        					   返回长度（字符出现的个数）

public String toString()        通过toString方法就可以实现吧StringBuilder转换为‘String对象

4.StringBuilder类和String类的各自的特点

1、String进行字符串拼接的特点：
	由于字符串的不可变性，所以每次拼接，都会产生新的字符串对象。
	这种拼接这样既耗时，又浪费内存空间，需要使用StringBuilder进行改进。
	  
2、StringBuilder的特点：
	StringBuilder是一个可变的字符串容器。
	StringBuilder可以解决字符串拼接时产生很多中间对象的问题，提高字符串拼接的效率。
	
3.StringBuilder类和String类的区别：
	String类：内容是不可变的
	StringBuilder类：内容是可变的

六、Object类介绍

java.lang.Object 注意:lang包中的类无需导包可以直接使用
Object类是类层次结构的根类(最顶层的类祖宗类)。
每个类都使用 Object 作为超类。任何一个类都直接或者间接的继承了Object类
所有对象（包括数组）都实现这个Object类的方法。任何一个类都可以使用Object类中的方法

1.Object 类的常用方法

（1）Object类的toString方法

/*
    Object类的常用方法:
        String toString() 返回该对象的字符串表示。
    Object类toString方法的底层源码(了解)
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        1.getClass().getName():使用反射技术获取类的全类名(包名+类名)
             com.itheima.demo01toString.Person
        2."@":字符串的@符号,原样输出,起到分割作用
        3.hashCode():Object类中的方法,可以获取对象的哈希值,哈希值是操作系统随机给出一个十进制的整数
        4.Integer.toHexString(十进制的整数): 把十进制的整数转换为十六进制 0-9 a-f
        组合在一起:com.itheima.demo01toString.Person@AC123(对象在堆内存中的地址值)
 */
public class Demo01ToString {
    public static void main(String[] args) {
        Person p = new Person("迪丽热巴",18);
        //Person类默认继承了Object类,所以可以使用Object类的toString方法
        String s = p.toString();
        System.out.println(s);//com.itheima.demo01toString.Person@4554617c 重写toString Person{name=迪丽热巴, age=18}

        //直接打印对象的名字,会默认调用对象的toString方法
        System.out.println(p);//com.itheima.demo01toString.Person@4554617c 重写toString Person{name=迪丽热巴, age=18}
    }
}

//ctrl+鼠标左键:进入类中或者方法
public class Person extends Object{
    private String name;
    private int age;

    /*
        Object类的toString方法,默认打印对象的地址值没有意义
        需要重写toString方法,打印对象的属性值(成员变量:name,age)
     */
    /*@Override
    public String toString() {
       return "Person{name="+name+", age="+age+"}";
    }*/

    //重点:会使用快捷键,重写toString方法  alt+insert==>toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

重点记忆

1.直接打印对象的名字,会默认调用对象的toString方法

2.Object类的toString方法,默认打印对象的地址值

3.重写toString方法快捷键 alt+insert==>toString方法

（2）Object类中的equals方法

/*
    Object类的中equals方法:
        boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
    Object类中的equals方法的源码:
        public boolean equals(Object obj) {
            return (this == obj);
        }
        ==:比较运算符
            基本数据类型:比较的值是否相同  10==20
            引用数据类型(数组,ArrayList集合,类Person,Student...):比较的是地址值是否相等  @AC123==@43DFA
 */
public class Demo01Equals {
    public static void main(String[] args) {
        //创建两个Person对象
        Person p1 = new Person("詹姆斯",35);
        Person p2 = new Person("韦德",38);
        //使用Object类的toString打印对象的地址值
        System.out.println(p1);//com.itheima.demo02equals.Person@4554617c
        System.out.println(p2);//com.itheima.demo02equals.Person@74a14482
        //使用Object类的equals方法,比较两个对象的地址值
        boolean b = p1.equals(p2);
        System.out.println(b);//false

        //把p2的地址值赋值给p1
        p1=p2;
        //使用Object类的toString打印对象的地址值
        System.out.println(p1);//com.itheima.demo02equals.Person@74a14482
        System.out.println(p2);//com.itheima.demo02equals.Person@74a14482

        boolean b2 = p1.equals(p2);
        System.out.println(b2);//true
    }
}

//ctrl+鼠标左键:进入类中或者方法
public class Person extends Object{
    private String name;
    private int age;

    /*
        比较两个对象的地址值没有意义,所以我们需要重写Object类的equals方法
        分别比较两个对象的的属性(name,age)
     */
    @Override
    public boolean equals(Object obj) {
        /*
            增加一个判断,如果obj就是this本身,那么就没有必要在强转之后进行比较了
            直接返回true,可以提高效率
         */
        if(obj == this){
            return true;
        }

        /*
            增加一个判断,如果obj是null,那么直接返回false,可以提高程序的效率
         */
        if(obj==null){
            return false;
        }

        /*
            ClassCastException: java.util.Random cannot be cast to com.itheima.demo02equals.Person
            为了防止类型转换异常,强转之前使用instanceof关键字进行判断
         */
        if(obj instanceof Person){
            //多态的弊端:无法使用子类特有的成员==>解决方案:向下转型
            Person p = (Person)obj;
            //比较两个对象this(p1)和p(obj=p2)的属性name和age
            //             詹姆斯.equals(韦德)           35   ==   38
            boolean b = this.name.equals(p.name) && this.age == p.age;
            return b;
        }
        //obj不是Person类型,直接返回false
        return false;
    }

    //重点:快捷键添加equals方法  alt+insert equals() and hashCode()
    /*@Override
    public boolean equals(Object o) {
        if (this == o){
            return true;
        }
        //getClass() != o.getClass() 使用反射技术判断对象的类型==>相当于 obj instanceof Person
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Person person = (Person) o;

        if (age != person.age) {
            return false;
        }
        //使用三元运算符的目的:防止空指针异常
        return this.name != null ? this.name.equals(person.name) : person.name == null;
    }*/

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2.native本地方法

native修饰的方法:说明这个方法不是java语言编写的

调用的是其他语言编写的代码或者操作系统底层的代码,看不到具体的方法

Object类:
public native int hashCode();
public final native Class<?> getClass();

3.Objects对象的工具类

package com.itheima.demo03Objects;

import java.util.Objects;

/*
    java.util.Objects类:操作对象的工具类,里边的方法都是静态的
    Objects类JDK1.7之后出现的
    Objects中的方法都是空指针安全的,都是防止空指针异常的
    注意:
        java提供的工具类中的方法都是静态的,可以通过类名.方法名(参数)直接使用
    Objects工具类中equals方法
        static boolean equals(Object a, Object b):判断两个对象是否相等,相等返回true,相等返回false
    Objects工具类中equals方法的底层源码
       public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
        }
 */
public class Demo01Objects {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "abc";
        //使用String类的equals方法,比较两个字符串的内容是否相同
        //boolean b1 = s1.equals(s2);// s1=null  null.equals(s2) null是不能调用方法的,会抛出NullPointerException:空指针异常
        //System.out.println(b1);

        boolean b1= s1 != null ? s1.equals(s2) : s2 == null;
        System.out.println(b1);

        //Objects工具类中equals方法,可以防止空指针异常
        boolean b2 = Objects.equals(s1, s2);
        System.out.println(b2);
    }
}

七、Math 类

1.Math 类概述

Math是数学工具类，包含执行数学运算的各种方法。
Math类的构造方法是私有的，无法创建对象，通过类名即可调用方法。

2.常用的方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	向上取整
public static double floor(double a)	向下取整
public static int round(float a)	四舍五入
public static double pow(double a,double b)	返回a的b次幂的值

八、System类

1.System的概述

System位于java.lang包下，代表当前Java程序的运行平台。
System类中提供了大量静态方法，可以获取与系统相关的信息或执行系统级操作。

2.System 类的常用方法

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)
arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)	数组拷贝

九、BigDecimal类

1.BigDecimal类的概述

因为计算机无法精确表示浮点数，所以在进行数字运算时，如果有double或float类型的浮点数参与计算，容易出现计算不准确的情况。

  在一些对精度要求很高的系统中，需要使用 java.math.BigDecimal 类来解决数学运算的精度问题。

2.BigDecimal 类的构造方法

构造方法	说明
BigDecimal(double val)	参数为double（不推荐）
BigDecimal(String val)	参数为String（推荐使用）

3.BigDecimal 类的常用方法

方法名	说明
public BigDecimal add(另一个BigDecimal对象)	加法
public BigDecimal subtract (另一个BigDecimal对象)	减法
public BigDecimal multiply (另一个BigDecimal对象)	乘法
ublic BigDecimal divide (另一个BigDecimal对象)	除法（除得尽的情况）
public BigDecimal divide (另一个BigDecimal对象，保留位数，舍入模式)	除法（除不尽的情况）

注：舍入模式通常使用 RoundingMode.HALF_UP ，表示四舍五入

十、Date类

1.Date类概述

java.util.Date 代表了一个特定的时间，精确到毫秒。

2.构造方法

方法名	说明
public Date()	创建Date对象，代表当前系统的当前时间。
public Date(long date)	使用毫秒数创建Date对象（在1970年1月1日 00:00:00 GMT 基础上加上指定毫秒数）

3.常用方法

方法名	说明
public long getTime()	返回当前时间的毫秒值。（自1970年1月1日 00:00:00开始）
public void setTime(long time)	设置时间（在1970年1月1日 00:00:00基础上增加设置的毫秒值）

4.计算机中的时间原点

计算机中的起始时间：

1970年1月1日 00:00:00

原因：
1969年8月，贝尔实验室的程序员肯汤普逊（Ken Thompson）利用妻儿离开一个月的机会，开始着手创造一个全新的革命性的操作系统，他使用B编译语言在老旧的PDP-7机器上开发出了Unix的一个版本。
随后，汤普逊和同事丹尼斯里奇（Dennis Ritchie）改进了B语言，开发出了C语言，重写了UNIX。
1970年1月1日算C语言的生日

十一、SimpleDateFormat 类

1.SimpleDateFormat 类概述

ava.text.SimpleDateFormat 类可以实现日期格式化（日期–>文本）和解析（文本–>日期）。

2.SimpleDateFormat 的构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用指定的格式

3.SimpleDateFormat 格式化和解析日期

(1)日期格式化(从 Date 到 String )

public final String format(Date date)：将日期格式化成特定格式的字符串。

(2)解析(从 String 到 Date )

public Date parse(String source)：将字符串解析成日期对象。

4.日期模板中字母含义

字母	含义
y	年份，一般用 yy 表示2位年份，yyyy 表示 4 位年份
M	月份，一般用 MM 表示
d	天数，一般用 dd 表示
H	小时（0~23)，一般用 HH 表示
m	分钟，一般使用 mm 表示 minute
s	秒数，一般使用 ss 表示 second
h	小时（1~12)，一般使用 hh 表示
S	毫秒，一般使用 SSS 表示
E	星期，用 E 表示，会根据语言环境的不同，显示不同语言的星期几
a	上午/下午，用 a 表示，会根据不同语言环境显示。

十二、Calendar类

1.Calendar类概述

java.util.Calendar是日历类。

Date类中很多方法都过时了，而Calendar类的功能比Date强大很多，所以Java官方推荐使用Calendar来替换Date的使用。

2.Calendar类创建对象

Calender是一个抽象类，不能直接创建对象，需要通过静态的 getInstance() 方法创建子类对象。

方法	说明
static Calendar getInstance()	获取当前时间的日历对象。

3.Calendar类常用方法

方法	说明
get(int field)	返回指定日历字段的值。
set(int field, int value)	设置指定日历字段的值。
add(int field, int amount)	添加或减去某个日历字段的值。
getTime()	获取Date对象。
getTimeInMillies()	返回该日历时间的毫秒值。