JAVASE第五章(API)

---

前言

本章主要介绍了JAVA一些常用的类,包括系统类、包装类、字符类、数组类等,熟悉各种常用类的使用对我们编写程序有很大的帮助

---

一、Java API概述

API(Application Programming Interface)应用程序编程接口:是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。

---

二、基本数据类型包装类

JAVA在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。

为什么要设计包装类？

1.Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便。
2.包装类包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

public class IntegerDemo {
    public static void main(String[] args) {
        //使用Integer包装一个整数,可以使用Integer类提供的方法
       /* 对于包装类来说，这些类的用途主要包含两种：
          1.作为和基本数据类型对应的类类型存在
          2.包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法*/
        Integer m = new Integer(10);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(m.byteValue());
        System.out.println(Integer.BYTES);
        Integer n = new Integer("12");   //会自动转换为数值类型；
        System.out.println(n.equals(m));
        System.out.println(n.compareTo(m));
        Integer.max(10,20);
        Integer.min(10,20); 
        System.out.println(Integer.toBinaryString(3));
        System.out.println(Integer.toHexString(17));
        System.out.println(Integer.toOctalString(9));

    }
}

那么在日常使用中，我们如何将包装类和基本类进行互相转换呢？使用装箱和拆箱。
装箱：将基本数据类型转换成包装类类型。以Integer为例，装箱的时候自动调用的是Integer的valueOf(int)方法。

//装箱的时候自动调用的是Integer的valueOf(int)方法
int x=1;
Integer m=x;   //装箱，把基本数据类型赋给引用类型;
//Integer m=Integer.valueOf(x);
  /*
   自动装箱问题    当范围在-128到127之间时,会从缓存数组中取出一个地址,超出范围会创建一个新的对象;
       public static Integer valueOf(int i) {
            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
            return new Integer(i);
       }*/

拆箱：将包装类类型转换成基本数据类型。以Integer为例，拆箱的时候自动调用的是Integer的intValue方法。

//拆箱的时候自动调用的是Integer的intValue方法
Integer m=1;
int y=m;       //拆箱，把引用数据类型赋给基本数据类型
//int y=m.intValue();
/*   public int intValue() {
         return value;
}*/
             

---

三、Object类

1.什么是Object类

Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都实现这个类的方法。

//如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
public class Person { ... }
//等价于：
public class Person extends Object {
... }

2.toString方法

Object类中定义有public String toString()方法，其返回值是 String类型，返回的是地址值。
大多数情况下我们都会选择重写toString（）方法，返回我们需要的内容。

public class Person {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {         //重写了Object里面的toString方法
        return "age=" + age +
                " name='" + name ;
    }
    @Override
    public boolean equals(Object o) {           //重写Object里面的equals方法
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
}


public class ObjectToString extends Object{
    public static void main(String[] args) {
      Person p1=new Person();
      Person p2=new Person();
      p1.setName("张三");
      p1.setAge(20);
      p2.setName("张三");
      p2.setAge(20);
        //如果不在Person类里面重写toString方法则调用的是父类Object里面的toString方法
        /*  public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());*/

      System.out.println(p1);   //调用的是重写的toString方法
    }
}

import java.util.Arrays;
public class ArraysToString {
    public static void main(String[] args) {
        int []a={1,2,3};
        int []b={1,2,3,4,5};
        System.out.println(a);    //调用的是Object类里面的toString方法;
        System.out.println(Arrays.toString(a));    //调用的是Arrays里面的toString方法,返回指定数组内容的字符串表示形式
        /*  public static String toString(int[] a) {
            if (a == null)
                return "null";
            int iMax = a.length - 1;
            if (iMax == -1)
                return "[]";

            StringBuilder b = new StringBuilder();
            b.append('[');
            for (int i = 0; ; i++) {
                b.append(a[i]);
                if (i == iMax)
                    return b.append(']').toString();
                b.append(", ");
            }
        }*/

    }
}

3.equals方法

x.equals ( y ) ：当 x 和 y是同一个对象的引用时返回 true 否则返回 false

JDK提供的一些类，如String，Date等，重写了Object的equals方法
调用这些类的equals方法， 比较的是内容是否相同。
大多数情况下都需要重写equals方法，equals方法往往和hashcode方法同时重写。

public class ObjectEquals {
    public static void main(String[] args) {
        Person p1=new Person();
        Person p2=new Person();
        p1.setAge(10);
        p1.setName("李四");
        p2.setAge(10);
        p2.setName("李四");
        System.out.println(p1==p2);
        //System.out.println(p1.equals(p2));   没有重写equals方法,调用的是Object里面的equals方法,
        /*Object 的 equals 方法 定义为：x.equals ( y ) ，当 x 和 y是同一
        个对象的引用时返回 true 否则返回 false*/
        System.out.println(p1.equals(p2));//在Person里面重写了equals方法后，调用重写的方法；
        String a=new String("张三");
        String b=new String("张三");
        System.out.println(a==b); //== 当基本类型比较时比较的是值,引用类型比较的是地址;

        System.out.println(a.equals(b));        //调用的是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;
        }*/
    }
}

public class ArraysEquals {
    public static void main(String[] args) {
        int a[]={1,2};
        int b[]={1,2};
        System.out.println(a.equals(b));   //数组本身的equals判断另一个数组是否它本身
     /*   public boolean equals(Object obj) {
            return (this == obj);
        }*/
        System.out.println(Arrays.equals(a,b)); //调用Arrays类中重写的equals方法;
         /*       public static boolean equals(int[] a, int[] a2) {
            if (a==a2)
                return true;
            if (a==null || a2==null)
                return false;

            int length = a.length;
            if (a2.length != length)
                return false;

            for (int i=0; i<length; i++)
                if (a[i] != a2[i])
                    return false;

            return true;
        }*/



    }
}

---

四、Arrays类

排序方法：

1.用于数组的所有元素排序
public static void sort(type[] a)

2.用于数组指定范围内的元素排序
public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))

3.自定义对象排序
  1.自定义类实现Comparable接口
  2.重写compareTo方法

public class Student implements Comparable<Student> {
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    //自定义类实现Comparable接口
    //重写compareTo方法自定义类实现Comparable接口
    //sort内部会调用compareTo方法

    public int compareTo(Student o) {
        return this.age-o.age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import java.util.Arrays;
public class ArraysSort {
    public static void main(String[] args) {
        int []a={5,4,3,2,1};
      /*  public static void sort(int[] a) {
            DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
        }*/
       //Arrays.sort(a);    //利用Arrays类里面的sort方法进行排序
        Arrays.sort(a,0,3);   // 排序的元素下标为0 1 2
        System.out.println(Arrays.toString(a));
        Student []p=new Student[5];
        Student s1=new Student("张三1",20);
        Student s2=new Student("张三2",21);
        Student s3=new Student("张三3",22);
        Student s4=new Student("张三4",23);
        Student s5=new Student("张三5",24);
        p[0]=s1;
        p[1]=s5;
        p[2]=s4;
        p[3]=s3;
        p[4]=s2;
       /* Arrays.sort(p);
        报错:com.ffyc.api.day2.Student cannot be cast to java.lang.Comparable,因为Student类没有实现Comparable接口;*/
        //当实现Comparable接口并且重写了compareTo方法后:
        Arrays.sort(p);
        System.out.println(Arrays.toString(p));
    }
}

binarySearch -使用二分搜索算法搜索指定数组

import java.util.Arrays;
public class ArraysBinarySearch {
    public static void main(String[] args) {
        int []a={1,3,4,2,5};
        //在查找之前一定要把数组进行排序,不然可能出现找不到数组元素的情况;
        //System.out.println(Arrays.binarySearch(a,2));
        /*private static int binarySearch0(int[] a, int fromIndex, int toIndex,
        int key) {
            int low = fromIndex;
            int high = toIndex - 1;

            while (low <= high) {
                int mid = (low + high) >>> 1;
                int midVal = a[mid];

                if (midVal < key)
                    low = mid + 1;
                else if (midVal > key)
                    high = mid - 1;
                else
                    return mid; // key found
            }
            return -(low + 1);  // key not found.
        }*/
        Arrays.sort(a);
        // 1 2 3 4 5
        System.out.println( Arrays.binarySearch(a,2));
    }
}

copyOf方法：复制指定的数组。

import java.util.Arrays;
public class ArraysCopyOf {
    public static void main(String[] args) {
        int []a={1,2,3,4,5};
        //复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
         int  []c= Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(c));
    }
}

---

五、String类

1.String类概述

String类：由多个字符组成的字符串常量，内部使用private final char value[]的数组实现，长度不可变。
两种创建方式：
1.String str1 = new String(“abc”)
2.String str2 = “abc”
两个语句都会去字符串常量池中检查是否已经存在 “abc”，如果有则直接使用，如果没有则会在常量池中创建 “abc” 对象。String str1 = new String(“abc”) 还会通过 new String() 在堆里创建一个 “abc” 字符串对象实例。

提问：String s = new String(“abc”)创建了几个对象？
答：一个或两个。如果字符串常量池已经有“abc”，则是一个；否则，两个。

当字符创常量池没有 “abc”，此时会创建如下两个对象：
一个是字符串字面量 "abc" 所对应的、字符串常量池中的实例
另一个是通过 new String() 创建并初始化的，内容与"abc"相同的实例，在堆中。

public class StringDemo {
    public static void main(String[] args) {
        String sb="abc";   //字符串底层用一个final修饰的char数组进行存储,值一旦确定不能修改;
        sb+="efg";  //会创建一个新的对象(abcefg)然后让sb指向它,并没有修改原来sb对象的值;
        System.out.println(sb);
        String s1="abc";
        String s2="abc";
        /*先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找
        有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中
        的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.*/
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
        String s3=new String("abc");   //一概在堆中创建新对象，值存储在堆内存的对象中。
        String s4=new String("abc");
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));
    }
}

2.String类里面的方法和功能

构造方法：用来初始化一个字符串对象。常用的构造方法有以下三种

public String(String str)
public String(byte[] bytes)
public String(char[] value)

public class StringDemo1 {
   public static void main(String[] args)throws UnsupportedEncodingException {
      /* public String(String original) {
           this.value = original.value;
           this.hash = original.hash;
       }*/
       String s1=new String("abc");  //调用构造方法
       System.out.println(s1);

       String s2="中文";
       byte[]array=s2.getBytes();   //编码    utf-8
       System.out.println(Arrays.toString(array));
       String s3=new String(array);  //解码
       System.out.println(s3);

       String s = "中文";
       byte [] b = s.getBytes("GBK");//编码显性的用GBK格式  默认(utf-8)
       System.out.println(Arrays.toString(b));

       String s4 = new String(b,"GBK");//解码显性的用GBK格式 (默认utf-8)    乱码问题:编码和解码两边使用的编码格式不统一
       System.out.println(s4);

       /*String s5 = new String(b,2,2,"GBK");
       System.out.println(s2);*/

       char[]array2=s2.toCharArray();
       String s6=new String(array2);
       System.out.println(array2);  //printfln方法为char数组提供了一个方法可以直接打印数组的值,其他类型的数组当做object处理
     //  调用的是object类型的tostring方法打印的是地址
       System.out.println(s6);
   }
}

判断功能:判断字符串的内容是否相等或者以指定字符串开头等。

boolean equals(Object obj)   判断内容是否相同,区分大小写
boolean equalsIgnoreCase(String str)  判断内容是否相同,不区分大小写
boolean contains(String str)     判断是否包含指定字符串
boolean isEmpty()    判断是否为空("")  为空返回true
startsWith(String prefix)    判断是否以指定的字符串开头
boolean endsWith(String suffix)  判断是否以指定的字符串结尾      

System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.contains("ab"));
System.out.println(s1.isEmpty());
System.out.println(s1.startsWith("a"));
System.out.println(s1.endsWith("c"));

获取功能：获取字符串的长度，第几个位置的元素，以及指定区间的字符串等。

 int length()
 char charAt(int index)
 int indexOf(String str)
 int indexOf(String str,int fromIndex)
 String substring(int start)
 String substring(int start,int end)

 System.out.println(s1.length());   //放回字符串的长度
 System.out.println(s1.charAt(1)); //返回指定索引的字符
 System.out.println(s1.indexOf("a"));   //获取指定字符串首次出现的位置 从前向后找
 System.out.println(s1.indexOf("a",1));
 String s3=new String("abcdefg");         //0123456                   
 System.out.println(s3.substring(2));  
 //从s中截取指定区间的字符串:从指定位置开始到结束   输出:cdefg
 System.out.println(s3.substring(2,4));  
 //指定区间截取:开始位置-结束位置(不包含结束)    输出:cd

转换功能：把字符串转换成数组，把数组转换成字符串以及转换成大小写等。

char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符);

String s4="JAVa";
char []charArray=s4.toCharArray();
System.out.println(String.valueOf(12));  //将int的值转换为String类型之后的结果;
System.out.println(s4.toLowerCase());    //将字符串转换为小写
System.out.println(s4.toUpperCase());       //将字符串转换为大写
System.out.println(s4);
String s5="SE";
String s6=s4.concat(s5);          //两个字符串拼接 并返回新的字符串对象
System.out.println(s6);
String s7="JAVA-SE";
String[]s7Array=s7.split("-");
//根据参数regex(regex是一个正则表达式,用来限定分隔规则)将字符串分隔为若干个子字符串
System.out.println(Arrays.toString(s7Array));

替换功能：将字符串中的一些内容替换掉

public class StringDemo3 {
    public static void main(String[] args) {
        /**
         * 替换功能
         * String replace(char old,char new)
         * String replace(String old,String new)
         * replaceAll(String regex, String replacement)
         * replaceFirst(String regex, String replacement)
         * 去除字符串两空格
         * String trim()
         */
        String s1="abcde";
        System.out.println(s1.replace("a","t"));  //用t来代替a
        String s2="a1b1c";
        System.out.println(s2.replaceAll("\\d","a")); //正则表达式,用a代替所有的数字
        System.out.println(s2.replaceFirst("\\d","a")); //用a代替第一个出现的数字
        String s3=" abcdf ";
        System.out.println(s3);
        System.out.println(s3.trim());  //只能修剪两端的空格
    }
}

六、正则表达式

正则表达式是一种字符串模式匹配语言，是一种规则。可以用来判断格式是否满足要求。

package com.ffyc.api.day3;
public class StringDemo2 {
    public static void main(String[] args) {
        /**
         *  . 任何字符（与行结束符可能匹配也可能不匹配）
         * \d 数字：[0-9]
         * \D 非数字： [^0-9]
         * \s 空白字符：[ \t\n\x0B\f\r]
         * \S 非空白字符：[^\s]
         * \w 单词字符：[a-zA-Z_0-9]
         * \W 非单词字符：[^\w]
         *
         * X? X，一次或一次也没有
         * X* X，零次或多次
         * X+ X，一次或多次
         * X{n} X，恰好 n 次
         * X{n,} X，至少 n 次
         * X{n,m} X，至少 n 次，但是不超过 m 次
         *
         * X|Y X 或 Y
         */
        //以判断一个电话号码格式是否正确为例
        String s1="1";
        System.out.println(s1.matches("\\d"));  //是数字(只有一个)而且不能为空时返回true
        String s2="12345678910";
        System.out.println(s2.matches("\\d?"));  //一次或者一次都没有
        System.out.println(s2.matches("\\d*"));  //零次或多次(可以为空)
        System.out.println(s2.matches("\\d+"));   //一次或多次
        System.out.println(s2.matches("\\d{11}"));  //恰好11次;
        System.out.println(s2.matches("\\d{1,11}"));  //最少一次,但是不超过11次;
       //手机号匹配规则
        String s3="13057900521";
        System.out.println(s3.matches("1[35]\\d{9}")); //第一位是1第二位是3或者5加上9位构成11位电话号码
        System.out.println("17057900521".matches("1[35]\\d{9}")); //第二位不符合规则为false
        System.out.println("1".matches("1|2"));  //1或2时返回true
        //邮箱匹配模规则
        //1971812605Jzh@qq.com或者1971812605Jzh@qq.com.cn

        String s4="1971812605Jzh@qq.com.cn";
        System.out.println(s4.matches("\\w{6,16}@\\w{2,5}\\.(com|com\\.cn)"));

    }
}

---

七、StringBuffer类

字符串每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。StringBuffer就可以解决这个问题，StringBuffer是线程安全的可变字符序列。

构造方法：用来初始化StringBuffer类。

public StringBuffer()
public StringBuffer(String str)

 StringBuffer s1=new StringBuffer();  //StringBuffer内部采用char数组实现,无参默认为16大小
 /*  public StringBuffer() {
     super(16);
 }*/
 StringBuffer s2=new StringBuffer("abcde");
 /*public StringBuffer(String str) {
     super(str.length() + 16);   //16+5=21
     append(str);
 }*/

添加功能：往StringBuffer中增加字符串。

public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)

s2.append("1111111111");  //更改对象里面的char数组,对象本身没有改变
s2.append("1111111111");  //当长度超过时,会自动增加数组长度,更改数组的地址,对象本身地址不改变
/* private void ensureCapacityInternal(int minimumCapacity) {
     // overflow-conscious code
     if (minimumCapacity - value.length > 0) {
         value = Arrays.copyOf(value,
                 newCapacity(minimumCapacity));
     }
 }*/
s2.insert(2,"xxx");   //在指定位置插入

删除功能：删除指定位置的字符串。

public StringBuffer deleteCharAt(int index)
ublic StringBuffer delete(int start,int end)

s2.deleteCharAt(1);
System.out.println(s2);
s2.delete(1,5);  //删除指定区间的字符串,包含开始,不包含结尾
System.out.println(s2);

替换功能：替换指定位置的字符串。

 public StringBuffer replace(int start,int end,String str)

反转功能：反转StringBuffer里面的字符串。

public StringBuffer reverse()

截取功能：截取部分字符串，本身不发生改变。

public String substring(int start)
public String substring(int start,int end)

String类和StringBuffer类和StringBuilder区别？

String：String 的值被创建后不能修改，任何对 String 的修改都会引发新的 String 对象的生成。
StringBuffer：跟 String 类似，但是值可以被修改，使用 synchronized 来保证线程安全。
StringBuilder：StringBuffer 的非线程安全版本，性能上更高一些。

StringBuffer  添加synchronized 同步锁  多线程安全
public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);调用父类
        return this;
 }
StringBuilder  没有添加同步锁  多线程不安全
public StringBuilder append(String str) {
        super.append(str);  调用父类
        return this;
}

---

八、Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

ublic class MathDemo {
    public static void main(String[] args) {
       /* abs 绝对值
        sqrt 平方根
        pow(double a, double b) a的b次幂
        max(double a, double b)
        min(double a, double b)
        random() 返回 0.0 到 1.0 的随机数
        long round(double a) double型的数据a转换为long型（四舍五入）*/
        System.out.println(Math.abs(-5));  //绝对值
        System.out.println(Math.sqrt(9));  //平方根
        System.out.println(Math.pow(2,3));  //幂运算
        System.out.println(Math.max(10,24)); //求最大值
        System.out.println(Math.min(5,10));  //求最小值
        System.out.println(Math.random());   //返回 0.0 到 1.0 的随机数
        System.out.println(Math.floor(9.9));  //向下取整
        System.out.println(Math.ceil(9.1));  //向上取整
        System.out.println(Math.round(9.8));//double型的数据a转换为long型（四舍五入）
    }
}

---

九、Random类

Random类：此类用于产生随机数，需要随机数的场合可以使用该类。

public class RandomDemo {
    public static void main(String[] args) {
        /**
         * 构造方法
         * public Random()
         * 成员方法
         * public int nextInt()
         * public int nextInt(int n)
         */
        Random d=new Random();
        System.out.println(d.nextInt());
        System.out.println(d.nextInt(33));  //返回0-32直接的一个数;
        System.out.println(d.nextBoolean());
    }
}

---

十、System类

System 类：位于 java.lang 包，代表当前Java程序的运行平台，系统级的很多属性和控制方法都放置在该类的内部。

注意：由于该类的构造方法是 private 的，所以无法创建该类的对象，也就是无法实例化该类。

System 类中提供了一些系统级的操作方法，常用的方法有 arraycopy()、currentTimeMillis()、exit()、gc() 和 getProperty()。

package com.ffyc.api.day4;
import java.util.Arrays;
public class SystemDemo1 {
    public static void main(String[] args) {
        long time1=System.currentTimeMillis(); //返回当前时间（以毫秒为单位） 从1970-1-1  0:0:0
        System.out.println(time1);
        for (int i = 0; i <10000 ; i++) {
            System.out.println(i);
        }
        long time2=System.currentTimeMillis();
        System.out.println(time2-time1);
        System.out.println(System.getenv());    //返回当前系统环境的不可修改的字符串映射视图。
        System.out.println(System.getenv("path"));  //获取指定环境变量的值。
        System.out.println(System.getProperties());   //getProperties() 确定当前的系统属性。
      //  System.exit(0); //终止当前运行的Java虚拟机。
        /*src - 源数组。
        srcPos - 源数组中的起始位置。
        dest - 目标数组。
        destPos - 目的地数据中的起始位置。
        length - 要复制的数组元素的数量。*/
        int []a=new int[]{1,2,3,4,5};
        int []b=new int[10];
        System.arraycopy(a,0,b,0,5);
        System.out.println(Arrays.toString(b));
    }
}

---

十一、Date类和Calendar类

Date：代表当前系统时间，由于Date类不便于实现国际化，Date的一些方法都过时了，系统推荐使用Calendar类。

Calendar：是一个抽象类，需要使用getInstance方法创建即可。在设计上，Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

import java.util.Date;
public class DateDemo1 {
    public static void main(String[] args) {
        Date d=new Date();
        System.out.println(d.getTime());
        System.out.println(d.getYear()+1900);
        System.out.println(d.getDate());
        System.out.println(d.getHours());
        System.out.println(d.getMinutes());
        System.out.println(d.getSeconds());
        System.out.println(d.toLocaleString()); //将此 Date对象转换为 LocalDate
        Date d2=new Date(1621740628485L);   //使用给定的毫秒时间值构造一个 Date对象。
        System.out.println(d2.getYear()+1900);
        System.out.println(d2.getMinutes());
        System.out.println(d2.getSeconds());
    }
}


import java.util.Calendar;
import java.util.Locale;
public class CalendarDemo1 {
    public static void main(String[] args) {
       /* Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建
        对象的过程对程序员来说是透明的，只需要使用getInstance方法创建
        即可。*/
        Calendar c1=Calendar.getInstance(Locale.CHINA);
        System.out.println(c1.get(Calendar.DAY_OF_MONTH));
        System.out.println(c1.get(Calendar.DAY_OF_WEEK_IN_MONTH));
        System.out.println(c1.get(Calendar.DAY_OF_WEEK));
        System.out.println(c1.get(Calendar.DAY_OF_YEAR));
        System.out.println(c1.getTime());

    }
}

SimpleDateFormat：日期格式化类，用来将日期格式化成我们需要的样子。

package com.ffyc.api.day4;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo1 {
    public static void main(String[] args) throws ParseException {
        Date d1=new Date();
        SimpleDateFormat myformat=new SimpleDateFormat("yyyy-MM-dd");
        String str=myformat.format(d1);    //日期转字符串
        System.out.println(str);
        String str2="2021-06-21";
        d1=myformat.parse(str2);      //字符串转日期
        System.out.println(d1);
        System.out.println(d1.getYear()+1900);  //获得年
        System.out.println(d1.getMonth()+1);  //获得月
        System.out.println(d1.getDate());  //获得天
    }
}

---

十二、BigIntege和BigDecima

BigIntege类：基于Integer的局限性，最大值为2^31-1,若需要更大的整数数据，就可以使用BigIntege。

import java.math.BigInteger;
public class BigIntegeDemo1 {
    public static void main(String[] args) {
        //BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支
        //持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何
        //大小的整数值而不会丢失任何信息。
            BigInteger a=new BigInteger("11111111111112222");
            BigInteger b=new BigInteger("1111122121212111111111111");
            System.out.println(a.add(b));
    }
}

BigDecima：不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去
一定的精确度。BigDecima类可以帮助我们解决这个问题。

根本原因是:十进制值通常没有完全相同的二进制表示形式;
十进制数的二进制表示形式可能不精确，只能无限接近于那个值。

import java.math.BigDecimal;
import java.math.BigInteger;
public class BigDecimalDemo1 {
    public static void main(String[] args) {
        /*
        double b = 0.8-0.7;
        System.out.println(b);   //输出0.10000000000000009
        BigDecimal b1=new BigDecimal("0.8");
        BigDecimal b2=new BigDecimal("0.7");
        System.out.println(b1.subtract(b2));   //输出0.1
    }
}

---

总结

API是JAVA程序员必备的文档。在平时编代码的过程中,当我们遇到问题或者对类和方法的使用不清楚的情况下,我们可以通过API快速的查找相关的知识。学习JAVA的常用类一定要通过自己编写程序来熟悉它的语法以及使用场景。要不断的练习,加深印象,直到牢固记忆为止。