大数据学习--day15(常用类：Date--DateFormat--SimpleDateFormat--File--包装类)

常用类：Date--DateFormat--SimpleDateFormat--File--包装类

这些常用类就不像字符串挖那么深了，只列列用法。

时间处理：

/**
 *    时间处理类
 *        DateFormat    抽象类
 *        SimpleDateFormat    子类
 *
 *        父类的格式器不够灵活 尤其是在解析的时候
 *        必须满足 yyyy-MM-dd HH:mm:ss  其中 - : 是核心  不能变
 *        如果要灵活使用 必须靠子类
 */
public class TestFormatDate {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        System.out.println(date);
        
        /**
         * 解决问题1 
         */
        
        // 得到 年月日的格式器 其实就是一个 子类的对象  然后调用 format 方法
        String format = DateFormat.getDateInstance().format(date);
        System.out.println(format);
        
        
        // 得到 时分秒的格式器 其实就是一个 子类的对象  然后调用 format 方法
        format = DateFormat.getTimeInstance().format(date);
        System.out.println(format);
        
        // 得到 年月日-时分秒的格式器 其实就是一个 子类的对象  然后调用 format 方法
        format = DateFormat.getDateTimeInstance().format(date);
        System.out.println(format);
        
        
        /**
         * 解决问题2  难以计算毫秒 来获得指定时间的 Date 对象
         */
        String str = "2000-1-1 12:12:13";
        // 获得 年月日的格式器 然后把字符串解析成 Date 对象
        Date parse = DateFormat.getDateInstance().parse(str);
        Person person = new Person("铁柱",parse);
        System.out.println(person);
        
        // 获得年月日  时分秒 的格式器    然后把字符串解析成 Date 对象
        parse = DateFormat.getDateTimeInstance().parse(str);
        person = new Person("铁柱",parse);
        System.out.println(person);
        
        str = "12:13:14"; // 如果获得的是 时分秒格式器  那么字符串不能出现年月日
        parse = DateFormat.getTimeInstance().parse(str);
        person = new Person("铁柱",parse);
        System.out.println(person);
        
        
    }
}

文件类：用法看API,放两个学习例子，模拟dir操作，递归删除文件夹（循环加栈删除）

模拟dir操作

/**
     * 模拟 dos命令    dir命令 
     * 时间
     * 目录 | 字节数
     * 文件名字
     * 文件计数  统计字节
     * 目录计数  可用字节
     */
    public static void DIR(File file){
        if( !file.isDirectory() ){
            System.out.println("不是目录");
            return ;
        }
        
        // 来到这里肯定是 目录
        
        // 时间处理
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd  HH:mm");
        Date date = null;
        
        // 文件目录    字节 计数    
        int fileSize = 0;
        int dirSize = 0;
        int lengthCount = 0 ;
        
        // 获得所有子文件对应的 file 对象
        File[] files = file.listFiles();
        // 遍历获得每一个
        for (File f : files) {
            
            long time = f.lastModified();
            date = new Date(time);
            System.out.printf("%-21s",sdf.format(date));
            
            String name = "";
            if( f.isDirectory() ){
                name = "<DIR>";
                dirSize++;
            }
            System.out.printf("%-10s",name);
            
            String length = "";
            if(f.isFile()){
                length += f.length();
                fileSize++;
                lengthCount += f.length();
            }
            System.out.printf("%-10s",length);
            
            
            System.out.println(f.getName());
        }
        
        System.out.println("			"+fileSize+"个文件   共 "+lengthCount+" 字节");
        System.out.println("			"+dirSize+"个目录 "+file.getUsableSpace());
    }

递归删除文件夹

/**
 * 递归删除文件夹
 * 该方法可以删除任意的 file 对象代表的文件
 */
public void delete(File file){
    // 先判断是不是目录 如果是就删除其所有的子文件
    // 所有的子文件删除完毕之后 再删自己
    if( file.isDirectory()){
        File[] files = file.listFiles();
        for (File f : files) {
            delete(f);
        }
    }
    file.delete();// 删自己
}

非递归删除文件夹（文件模拟一个队列，文件夹模拟一个栈）

package sy180928;

import java.io.File;
import java.util.ArrayList;

/**
 * @author suyuan
 *非递归删除文件夹
 */
public class FileDelStack
{

    public static void main(String[] args)
    {
        File file=new File("E:\sy\test");
        delete(file);
        System.out.println("删除成功");

    }
    
    public static void delete(File file)
    {
        ArrayList<File> filelist=new ArrayList();
        ArrayList<File> dirList=new ArrayList();
        if(file.isFile())
        {
            file.delete();
        }
        filelist.add(file);//是文件夹就压栈
        while(filelist.size()>0)
        {
            File f=filelist.remove(0);//出队列
            File[] listFiles = f.listFiles();
            for (File file2 : listFiles)
            {
                if(file2.isFile())
                {
                    file2.delete();
                }
                else
                {
                    filelist.add(file2);//是文件夹就压栈
                    dirList.add(file2);
                }
            }
        }
        //只剩空文件夹了
        System.out.println(dirList);
        System.out.println(dirList.size());
        for (int i=dirList.size()-1;i>=0;i--)
        {
            System.out.println(dirList.get(i)+"  "+i);
            dirList.get(i).delete();
        }
        System.out.println(dirList+"ddd");
        file.delete();
    }

}

包装类是为了好放入集合，重点掌握拆箱，装箱。

  自动装箱 : 可以把基本数据类型 直接赋值给 其对应的包装类的引用

  自动拆箱 : 从对象状态 可以直接转换成 其对应的基本数据类型