Java常用API-Date-DateFormat-Calendar-System-Scanner-String-StringBuilder及使用

Java常用API

• Date
• DateFormat
• Calendar
• System
• Scanner
• String
• StringBUilde

API：应用程序编程接口

Date类

Date 表示特定的瞬间，精确到毫秒。

 /*构造函数*/

 //分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。 
 public Date()；
 
 //分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元 （epoch）”，
 即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
 public Date(long date);

示例代码：

/**
 * Date
 */
public class Date {
    public static void main(String[] args) {
        //创建对象
        java.util.Date date = new java.util.Date();
        System.out.println("时间1"+date);

        java.util.Date date2 = new java.util.Date(1000*60*60);
        System.out.println("时间2"+date2);

        //输出：时间1Wed Dec 19 12:59:25 CST 2018
        //输出：时间2Thu Jan 01 09:00:00 CST 1970
    }
}

   /*成员方法*/
   public long getTime()
   public void setTime(long time)

示例代码：

/**
 * Date
 */
public class Date {
    public static void main(String[] args) {
        //创建对象
        java.util.Date date = new java.util.Date();
        System.out.println("时间1："+(Long)date.getTime());

        java.util.Date date2 = new java.util.Date();
        date2.setTime(1000);//设置时间
        System.out.println("时间2："+date2);

        //输出：时间1：1545197445870
        //输出：时间2：Thu Jan 01 08:00:01 CST 1970
    }
}

DateFormat抽象类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、分析（文本-> 日期）和标准化。将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年，1 月 1 日 00:00:00 这一刻开始的毫秒数。
DateFormat作用：即可以将一个Date对象转换为一个符合指定格式的字符串，也可以将一个符合指定格式的字符串转换为一个Date对象

示例代码1：

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 将一个Date对象转换为一个符合指定格式的字符串
 * DateFormat抽象类
 */
public class DateFormat {
    public static void main(String[] args) {
        //创建日期
        Date date = new Date();
        //创建日期格式化对象
        //DateFormat不能创建对象，因此由其子类来创建对象
        java.text.DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        //输出
         System.out.println("时间："+dateFormat.format(date));
        //输出内容：时间：时间：2018-12-19

    }
}

示例代码2：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 将String转换为Date对象
 * DateFormat抽象类
 */
public class DateFormat {
    public static void main(String[] args) {
        //创建日期
        String str = "2018-12-19";
        //创建日期格式化对象,
        java.text.DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = dateFormat.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //输出
         System.out.println("时间："+date);
        //输出内容：时间：Wed Dec 19 00:00:00 CST 2018

    }
}

Calendar类

表示日历的类里面的方法基本都是静态方法，Calendar 又是抽象类，不能new，该类将所有可能用到的时间信息封装为静态成员变量，方便获取。

示例代码：

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * Calendar
 */
public class TextCalendar{
    public static void main(String[] args) {
       Calendar calendar = Calendar.getInstance(); //返回当前日历对象
        //返回当前年
        System.out.println("年"+calendar.get(Calendar.YEAR));//结果：2018
        //返回当前月，从0开始算起，最大11；0代表1月，11代表12月。
        System.out.println("月"+calendar.get(Calendar.MONTH));//结果：11
        //返回当前日，
        System.out.println("天"+calendar.get(Calendar.DATE));//结果：19
        //返回当前时
        System.out.println("时"+calendar.get(Calendar.HOUR));//结果：2
        //返回当前分
        System.out.println("分"+calendar.get(Calendar.MINUTE));//结果：14
        //返回当前秒
        System.out.println("秒"+calendar.get(Calendar.SECOND));//结果：5

        //获取该日历对象转成的日期对象
        Date date = calendar.getTime();
        System.out.println("时间："+date);//结果：Wed Dec 19 14:17:42 CST 2018

        //设置指定字段的日期值
        calendar.set(Calendar.YEAR, 2020);
        calendar.set(Calendar.MONTH, 4);
        calendar.set(Calendar.DATE, 20);
        Date date2 = calendar.getTime();
        System.out.println("时间："+date2);//结果：Wed May 20 14:20:14 CST 2020

        //或者用子类创建对象也是可以实现的：
        Calendar c = new GregorianCalendar();
    }
}

System类

System中代表程序所在系统，提供了对应的一些系统属性信息，和系统操作。System类不能手动创建对象，因为构造方法被private修饰，阻止外界创建对象。System类中的都是static方法，类名访问即可。其构造方法为Final类型因此一般不会创建对象，并且成员方法一般为静态方法
示例代码：

import com.manager.pojo.Employees;
import java.util.Arrays;

public class TextSystem {
    public static void main(String[] args) {
    //常用方法：
        //currentTimeMillis()返回以毫秒为单位的当前时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println("hi:" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
        //结果：hello:99999
        //共耗时：615毫秒

        //exit(int status)用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常终止
        System.out.println("你好啊");
        System.exit(0);
        System.out.println("你不好");
        //输出结果：你好啊

        //System.gc();//用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。
        Employees employees = new Employees();
        employees.setE_Code("11");
        employees.setE_RealName("张三");
        System.out.println(employees);
        employees=null;
        System.gc();
        //输出结果：Employees{e_Code='11', e_RealName='张三'}
        //当前对象被回收了，Employees{e_Code='11', e_RealName='张三'}
        
        //arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：
        //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束，注意是替换而不是插入。
        int[] arr1 = {11,22,33,44,55};
        int[] arr2 = {5,6,7,8,9,10};
        System.arraycopy(arr1,1,arr2,2,2);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
        //输出结果：[11, 22, 33, 44, 55]
        //          [5, 6, 22, 33, 9, 10]
}
}

Employees代码

扫描二维码关注公众号，回复： 4750696 查看本文章

   private String e_Code;
   private String e_RealName; 
  public String getE_Code() {
        return e_Code;
    }

    public void setE_Code(String e_Code) {
        this.e_Code = e_Code;
    }

   public String getE_RealName() {
        return e_RealName;
    }

    public void setE_RealName(String e_RealName) {
        this.e_RealName = e_RealName;
    }
 @Override
    public String toString() {
        return "Employees{" +
                "e_Code='" + e_Code + '\'' +
                ", e_RealName='" + e_RealName + '\'' +
                '}';
    }
    @Override
    protected void finalize() throws Throwable {
        System.out.println("当前对象被回收了，"+this);
        super.finalize();
    }

Scanner

用Scanner类的方法可以完成接收键盘录入的数据

示例代码：

public class ScannerDemo {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        System.out.println("请输入一个字符串数据：");
        String s = sc.nextLine();
        
        //输出结果
        System.out.println("s:"+s);
    }
}

String

字符串类由多个字符组成的一串数据字符串其本质是一个字符数组

示例代码：

public class TestString {
    public static void main(String[] args) {
     /*构造方法1
        * String(String original)把字符串数据封装成字符串对象
        * */
       String str = new String("hi");
       System.out.println(str);//输出结果：hi

        /*构造方法2
        * String(char[] value):把字符数组的数据封装成字符串对象
        * */
        char[] chs = {'a','b','c','d','e'};
        String str2 = new String(chs);
        System.out.println(str2);//输出abcde

        /*构造方法3
        * String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
        * */
        String str3 = new String(chs,1,3);//取下标1开始3结束
        System.out.println(str3);//输出结果：bcd

        /*最简洁的*/
        String str4 = "hi";
        System.out.println(str4);//输出结果：hi

        /*
        *   String str = new String("hi");
        *   String str4 = "hi";
        *   的创建区别：
        *   通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?
        *   通过构造方法创建字符串对象是在堆内存。
        *   直接赋值方式创建对象是在方法区的常量池
        * */

        //用==比较的是地址
        System.out.println(str4==str);//输出结果：false

        //用equals(Object obj)比较的是值
        System.out.println(str4.equals(str));//输出结果：true

        //equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println(str4.equalsIgnoreCase(str));//输出结果：true

        //startsWith(String str):判断字符串对象是否以指定的str开头
        System.out.println(str4.startsWith("h"));//输出结果：true

        //length():获取字符串的长度，其实也就是字符个数
        System.out.println(str4.length());//输出结果：2

        //charAt(int index):获取指定索引处的字符
        System.out.println(str4.charAt(1));//输出结果：i

        //indexOf(String str):获取str在字符串对象中第一次出现的索引
        System.out.println(str4.indexOf("i"));//输出结果：1

        //substring(int start):从start开始截取字符串
        System.out.println(str4.substring(1));//输出结果：i

        //substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
        System.out.println(str4.substring(0,1));//输出结果：h
    }
}

StringBuilder

StringBuilder是一个可变的字符序列。StringBuilder类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

String和StringBuilder的区别：String的内容是固定的， StringBuilder的内容是可变的
String每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器

示例代码：

public class TestStringBuilder {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();
        //返回当前容量
        System.out.println(sb.capacity());

        //返回长度（字符数）
        System.out.println(sb.length());

        //append可以添加任意类型，对象，字符串，int，数组，boole
        System.out.println(sb.append("sfl"));

        //链式编程
        sb.append("hello").append("world").append(true).append(100);
        System.out.println(sb);//输出结果：helloworldtrue100
        System.out.println(sb.reverse());//输出结果：001eurtdlrowolleh


        //string转为StringBuilder
        String s = "helloworld";
        StringBuilder sb2 = new StringBuilder(s);
        System.out.println(sb2);//输出结果：helloworld

        //StringBuilder转为string
        sb.append("hello").append("world");
        s = sb.toString();
        System.out.println(s);//输出结果：helloworld
    }

}