3.2Java常用类（下）

Java常用类（下）

Date类

Date类：表示特定的瞬间，精确到毫秒；
构造方法：
	Date():			 		根据当前时间创建的日期对象
	Date(long date):
								根据毫秒值创建对象
								从1970 年 1 月 1 日 00:00:00 GMT 开始
成员方法：
	public long void getTime():获取的是毫秒值。从1970 年 1 月 1 日 00:00:00 GMT 开始
	public long setTime(long time):设置时间，给的是毫秒值

从Date得到一个毫秒值：
	getTime()
	
从一个毫秒值得到一个Date对象
	构造方法
	setTime(long time)

public class DateDemo {
    public static void main(String[] args) {
        //Date()
        Date d = new Date();
        System.out.println(d);
        //Date(long date)
        long date = 1000*60*60; //北京区时+8
        Date dd = new Date(date);
        System.out.println(dd);
    }
}

SimpleDateFormat类

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。
它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

格式化（日期 -> 文本）:Date ----> String
	public final String format(Date date)
	
解析（文本 -> 日期）:String ---->Date
	public Date parse(String souce)

构造方法:
	SimpleDateFormat();
	
成员方法:
	public final String format(Date date)
	public Date parse(String souce)

//格式化（日期 -> 文本）:Date ----> String
public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        //Date -- String
        Date d = new Date();
        //SimpleDateFormat
        SimpleDateFormat s1 = new SimpleDateFormat();
        String t1 = s1.format(d);
        System.out.println(t1); //20-3-13 下午3:54
        //虽然实现了把日期格式化成一个字符串，但是不是我们想要的格式；
        SimpleDateFormat s2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String t2 = s2.format(d);
        System.out.println(t2);
    }
}

//解析（文本 -> 日期）:String ---->Date
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
       String str = "2080-08-08 12:23:45";
       // 把字符串解析成日期时，请注意模式字符串和给定的日期字符串的格式要匹配
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date d = sdf.parse(str);
       System.out.println(d);
    }
}

SimpleDateFormat类练习编写工具类

工具类
构造方法私有
成员方法静态

package com.scy10;

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

public class DateUtil {
    private DateUtil(){}

    /* 把日期转换为指定格式的字符串
        两个明确：
            返回值类型：String
            参数列表：Date date, String format
     */
    public static String dateToString(Date date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }

    /* 把指定格式的字符串解析为日期
        两个明确：
            返回值类型：Date
            参数列表：String s,String format
     */
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;
    }
}

package com.scy10;		//测试类

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

public class DateUtilTest {
    public static void main(String[] args) throws ParseException {
        Date d = new Date();
        String s1 = DateUtil.dateToString(d,"yyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);
        String s2 = DateUtil.dateToString(d,"yyy年MM月dd日");
        System.out.println(s2);

        String str = "2080-08-08 12:34:56";

        Date dd = DateUtil.stringToDate(str,"yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);

    }
}

File类

File:文件和目录路径名的抽象表示形式
也就是说文件和目录可以通过File封装成对象
目录：其实就是文件夹

File构造方法：

File(String pathname)：通过将给定路径名字符串转换为抽象路径名来创建一个新File实例。

File(String parent, String child)：根据parent路径名字符串和child路径名字符串创建
一个新File实例。

File(File parent, String child) ：根据 parent 抽象路径名和 child 路径名字符串
创建一个新 File 实例。

package com.scy12;

import java.io.File;

public class MyFile {
    public static void main(String[] args) {
        //File(String pathname)
        File f1 = new File("d:\\aa\\b.txt");
        //File(String parent, String child)
        File f2 = new File("d:\\aa","b.txt");
        //File(File parent, String child)
        File f3 = new File("d:\\aa");
        File f4 = new File(f3,"b.txt");
        // f1,f2,f4其实做的是一样的事情，就是把d:\\aa\\bb.txt转换为一个File对象
    }
}

File类的创建功能

public boolean createNewFile() ：
	创建文件（如果文件不存在，创建文件返回true，存在不创建并返回false）
	
public boolean mkdir()：
	创建目录（如果目录不存在，创建目录返回true，存在不创建并返回false）
	
public boolean mkdirs()：创建多级目录

package com.scy12;

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

public class MyFile {
    public static void main(String[] args) throws IOException {
        //需求1：d盘目录下创建一个文件a.txt
        File f1 = new File("d:\\a.txt");
        System.out.println("createNewFile"+f1.createNewFile());

        //需求2：我要在d盘目录下创建一个目录bb
        File f2 = new File("d:\\b");
        System.out.println("mkdir:"+f2.mkdir());

        //需求3：我要在d盘目录下创建多级目录cc\\dd
        File f3 = new File("d:\\cc\\dd");
        System.out.println("mkdir:"+f3.mkdirs());

        //需求4：我要在d盘目录下创建文件ee\\f.txt
        File f4 = new File("d:\\ee");
        File f5 = new File("d:\\ee\\f.txt");
        System.out.println("mkdir:"+f4.mkdir());
        System.out.println("createNewFile:"+f5.createNewFile());
    }
}

File类的删除功能

删除功能：
public boolean delete()：删除文件和目录

路径问题：
绝对路径：是以盘符开始的路径：d:\\aa\\b.txt
相对路径：不以盘符开始。相对于当前的项目而言，在项目的目录下。如何显示出来，刷新即可

注意：
	如果一个目录中有内容（目录，文件），就不能直接删除
	应该先删除目录中的内容，最好才能删除目录

package com.scy12;

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

public class MyFile {
    public static void main(String[] args) throws IOException {
        //需求1：创建一个文件a.txt
        //File f1 = new File("a.txt");
        //System.out.println("createNewFile:"+f1.createNewFile());
        //需求2：我要创建一个目录bb
        //File f2 = new File("bb");
        //System.out.println("mkdir:"+f2.mkdir());
        //需求3：我要创建一个文件cc\\d.txt
        //File f3 = new File("cc");
        //File f4 = new File("cc\\d.txt");
        //System.out.println("mkdir:"+f3.mkdir());
        //System.out.println("createNewFile:"+f4.createNewFile());
        // public boolean delete():删除文件和目录
        //需求1：我要删除a.txt文件
        File f1 = new File("a.txt");
        System.out.println("delete:"+f1.delete());
        //需求2：我要删除bb这个目录
        File f2 = new File("bb");
        System.out.println("delete:"+f2.delete());
        //需求3：我要先删除cc这个目录中的文件
        File f3 = new File("cc\\d.txt");
        System.out.println("delete:"+f3.delete());
        File f4 = new File("cc");
        System.out.println("delete:"+f4.delete());
    }
}

方法摘要(以下方法是File类当中必须要掌握的)

判断功能
  	  public boolean isDirectory():判断是否是目录
  	  public boolean isFile():判断是否是文件
  	  public boolean exists():判断是否存在
获取功能
  	  public String getAbsolutePath():获取绝对路径
  	  public String getPath():获取相对路径
  	  public String getName():获取名称

package com.scy12;

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

public class MyFile {
    public static void main(String[] args) throws IOException {
        //创建File对象
        File f = new File("aaa\\bbb.txt");
        //判断功能
        //public boolean isDirectory()
        System.out.println("isDirectory:"+f.isDirectory());
        //public boolean isFile()
        System.out.println("isFile:"+f.isFile());
        //public boolean exists()
        System.out.println("exists:"+f.exists());

        //获取绝对路径 	F:\java_project\aaa\bbb.txt
        System.out.println("getAbsolutePath:"+f.getAbsolutePath());
        //获取相对路径	aaa\bbb.txt
        System.out.println("getPath:"+f.getPath());
        //获取名称	bbb.txt
        System.out.println("getName:"+f.getName());
    }
}

Arrays类

Arrays类概述：
	针对数据进行操作的工具类；
	提供了把数组转成字符串，排序等功能；
成员方法：
	public static String toString(int[] a)
	public statis void sort(int[] a) 

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {15,30,2,50,12,66};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

Arrays类中构造方法问题

Arrays类中是否真的没有构造方法？
	一个类中没有构造方法，系统将提供一个无参构造方法
	而我们在帮助文档中没有Arrays类的构造方法，这是为什么呢？

查看Arrays类源码内容：
	private Arrays() {}  有构造方法，但是被private修饰，外界无法使用，
	所以在帮助文档中看不到
	所以他不能生成对象；

Arrays类的这种设计是常用的工具类的设计思想：
	构造方法私有；
	成员都用static
	
如Math/Collections等都是工具类

基本类型包装类

需求：我要判断一个数据是否在int范围内？
要想判断一个数据是否在unt范围内，首先我们需要知道int范围。
在基本数据类型学习时范围为（-2147483648到2147483648）

为了对基本数据类型进行更多更方便的操作，
Java就针对每一种基本数据类型提供可对应的引用类型。
基本类型包装类：
	Byte ---> byte
	Short ---> short
	Integer ---> int
	Long ---> long
	Float ---> float
	Double ---> double
	Character ---> char
	Boolean ---> boolean
*基本类型包装类最常用的用法就是用于和字符串之间进行相互转换；

Integer：Integer类在对象中包装了一个基本类型int的值。
构造方法：
	Integer(int value) 
	Integer(String s) 
	注意：当使用Integer(String s) 构造方法时，字符串必须是数字字符组成；

int类型和String类型的相互转换

int -----> String
	String 类中：public static String valueOf(int i)

public static void main(String[] args) {
        int number =  100;
        //方式1
        String s1 = "" + number;
        System.out.println(s1);
        System.out.println("---------");
        //方式2
        String s2 = String.valueOf(number); //public static String valueOf(int i)
        System.out.println(s2);
    }

String -----> int
	Integer 类中：public static int parseInt(String s) （最常用）

String s = "100";
        //方式1
        Integer i = new Integer(s); // public int intValue()
        int result = i.intValue();
        System.out.println(result);
        //方式2
        int y = Integer.parseInt(s);//public static int parseInt(String s)
        System.out.println(y);

Integer的练习

我有如下 一个字符串："91 27 46 38 50"
请实现代码最终输出结果是："27 38 46 50 91"
提示：这里需要参考String类中的方法
public String[] split(String regex)

package com.scy10;

import java.util.Arrays;

public class IntegerDemo {
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        String[] arr_str = s.split(" ");
        int[] arr_int = new int[arr_str.length];
        for (int i =0;i<arr_int.length;i++){
            arr_int[i] = Integer.parseInt(arr_str[i]);
        }
        Arrays.sort(arr_int);
        StringBuilder sb = new StringBuilder();

        for (int i=0;i<arr_int.length;i++){
            if (i==arr_int.length-1){
                sb.append(arr_int[i]);
            }
            else {
                sb.append(arr_int[i]);
                sb.append(" ");
            }
        }
        System.out.println(sb.toString());
    }
}

自动装箱和拆箱

JDK5新特性：
自动装箱：把基本数据类型转换为对应的包装类类型
	public static Integer valueOf(int i)
	
自动拆箱：把包装类类型转换为对应的基本数据类型
	public int intValue()
	
Java程序的运行：
	编写Java文件 ---> 编译生成class文件 -- 执行
	   java文件 <--- 反编译工具
	  
*注意：在使用包装类类型的新特性的时候，如果做操作，
最好都要先判断 是否为null；

public class IntegerDemo {
    public static void main(String[] args) {
        Integer i = new Integer(100);
        Integer ii = 100;   //自动装箱通过这个代码实现：Integer ii = Integer.valueOf(100);
        ii +=200; // ii = ii +200; 自动拆箱，自动装箱 ii = Integer.valueOf(ii.intValue() + 200);
        ii.getClass();
        System.out.println(ii);
        /*	反编译工具对class文件进行反编译得到
        public static void main(String args[])
	    {
		Integer ii = Integer.valueOf(100);
		ii = Integer.valueOf(ii.intValue() + 200);
		System.out.println(ii);
	    }
         */
        Integer iii = null;
        if(iii !=null){
        	iii+=300;   //如果不判断是否为null
        				//iii.intValue()是就会NullPointerException
        	System.out.print(iii)
        }
    }
}