io的常用操作

Q1:简单的创建文件

package com.zhangyuwei.io;

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

public class test1 {
    public static void main(String[] args) throws IOException {
        File file=new File("E:\io"+File.separator,"file1.txt");
        if(file.exists()){
            System.out.println("文件已经存在");
        }else{
            file.createNewFile();
            System.out.println("文件创建成功!");
        }
    }
}

Q2：文件的一些常用操作

package com.zhangyuwei.io;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class test2 {
    public static void main(String[] args) throws IOException {
        File file=new File("E:\io\file.txt");
        /*单个文件*/
        //file.createNewFile();
        /*单级文件夹*/
        //file.mkdir();
        /*多级文件夹*/
        //file.mkdirs();
        /*重命名*/
        //file.createNewFile();
        File file1=new File("E:\io\file1.txt");
        //file.renameTo(file1);
        /*删除*/
        //file.createNewFile();
        //file.delete();
        /*删除执行完后的*/
        //file.createNewFile();
        //file1.createNewFile();
        //file.deleteOnExit();
        /*判断文件或文件夹是否存在*/
        //file.createNewFile();
        /*if(file.exists()){
            System.out.println("文件存在");
        }*/
        //file.delete();
        /*是一个文件夹吗?*/
        //file.mkdir();
        /*if(file.isDirectory()){
            System.out.println("是一个文件夹");
        }else{
            System.out.println("不是一个文件夹");
        }*/
        /*获得文件或者文件夹的名称*/
        //System.out.println(file.getName());
        /*绝对路径*/
        //file.createNewFile();
        //System.out.println(file.getPath());
        //System.out.println(file.getAbsolutePath());
        /*文件大小是*/
        //System.out.println(file.length());
        /*父路径是*/
        //System.out.println(file.getParent());
        /*最后一次修改的时间是*/
        /*long  lastmodified= file.lastModified();
        Date data = new Date(lastmodified);
        SimpleDateFormat simpledataformat = new SimpleDateFormat("YY年MM月DD日 HH:mm:ss");
        System.out.println("最后一次修改的时间是："+simpledataformat.format(data));*/

    }
}

 Q3:获取文件或文件夹的方法

package com.zhangyuwei.io;

import java.io.File;

public class test3 {
    public static void main(String[] args) {
        //文件或者文件夹的方法
        File[] file=File.listRoots();
        System.out.println("所有的盘符是:");//盘符就是C:\   D:\  E:\等等
        for(File item:file){
            System.out.println("	"+item);
        }
        File fileName=new File("E:\");
        String[] name=fileName.list();
        System.out.println("指定文件夹下的文件或者文件夹有：");//包括当前这个文件下的所有文件，不包括子文件
        for (String item:name){//这个获得的是相对路径
            System.out.println("	"+item);
        }
        File[] files=fileName.listFiles();
        System.out.println("获得该路径下的文件或文件夹是：");//这个获得的是绝对路径
        for(File items:files){
            System.out.println("	"+items);
        }
    }
}

 Q4:递归获得所有文件与文件夹

package com.zhangyuwei.io;

import java.io.File;

public class test4 {
    public static void main(String[] args) {
        //递归获得所有文件与文件夹
        File file=new File("E:"+File.separator+"s3s143twoclass"+File.separator+"Idea");
        ListFile(file);
    }
    public static void ListFile(File file01){
        if(file01.isDirectory()){
            File[] files=file01.listFiles();
            for(File item:files){
                System.out.println(item);
                ListFile(item);
            }
        }
    }
}

Q5:字节流与字符流

1.字节流与字符流的区别:

• 读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
• 处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
• 结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

 2:输出字节流OutputStream(OutputStream 是所有的输出字节流的父类，它是一个抽象类。)

package com.zhangyuwei.io;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class test5 {
    public static void main(String[] args) throws IOException {
        //输出字节流OutputStream
        // 第1步：使用File类找到一个文件
        File file=new File("E:"+File.separator+"io"+File.separator+"file.txt");
        if(file.exists()){
            System.out.println("文件存在");
        }else{
            file.createNewFile();
        }
        //第2步：通过子类实例化父类对象
        OutputStream outputStream=new FileOutputStream(file);//// 通过对象多态性，进行实例化
        // 第3步：进行写操作
        String str="Hello Word!";// 准备一个字符串
        byte[] b=str.getBytes();// 只能输出byte数组，所以将字符串变为byte数组
        outputStream.write(b);//将内容输出，保存文件
        //第4步，关闭输出流
        outputStream.close();
    }
}

3:字节输入流InputStream(是所有的输入字节流的父类，它是一个抽象类。)

package com.zhangyuwei.io;

import java.io.*;

public class test6 {
    public static void main(String[] args) throws IOException {
        //字节输入流inputStream
        // 第1步：使用File类找到一个文件
        File file=new File("E:"+File.separator+"io"+File.separator+"file.txt");
        // 第2步：通过子类实例化父类对象
        InputStream inputStream=new FileInputStream(file);// 通过对象多态性进行实例化
        // 第3步：进行读操作
        byte[] b=new byte[1024];// 所有的内容读到此数组中
        inputStream.read(b);// 把内容从文件中取出，内容读到byte数组中
        // 第4步：关闭输入流
        inputStream.close();
        System.out.println("内容为:"+new String(b));//将byte变成字符串输出
    }
}

内容已经被读取进来，但是发现后面有很多空格，这是应为开辟的byte数组大小为1024，而实际内容并没有1024个字节，也就是说存在很多个空白的空间这样操作显然不合理.

如果想要解决以上问题，这是你就需要观察read方法,它是有返回值的，次返回值表示向数组写入了多少个数据

改进代码如下：

package com.zhangyuwei.io;

import java.io.*;

public class test6 {
    public static void main(String[] args) throws IOException {
        //字节输入流inputStream
        // 第1步：使用File类找到一个文件
        File file=new File("E:"+File.separator+"io"+File.separator+"file.txt");
        // 第2步：通过子类实例化父类对象
        InputStream inputStream=new FileInputStream(file);// 通过对象多态性进行实例化
        // 第3步：进行读操作
        byte[] b=new byte[1024];// 所有的内容读到此数组中
        int len=inputStream.read(b);// 把内容从文件中取出，内容读到byte数组中
        // 第4步：关闭输入流
        inputStream.close();
        System.out.println("读取数据的长度:"+len);
        System.out.println("内容为:"+new String(b,0,len));//将byte变成字符串输出
    }
}

 此时，再次运行程序，发现没有多余的空格产生，这是因为程序最后只是把byte数组指定范围中的内容变成了字符串，注意：注意输入文件的路径，在使用FileInputStream读取时如果指定

路径不存在，则程序会出现异常。

以上问题是否还有其他办法解决呢？当然是有的，虽最后指定了byte数组的范围，但是程序依然开辟了很多无用的空间，这样肯定会造成资源的浪费，那么此时能否根据文件数据量来开辟？

想完成这样的操作，则要从File类着手，因为在File类中存在着一个length()方法，此方法可以取得文件的大小，来开辟指定大小的byte数组.

package com.zhangyuwei.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class test7 {
    public static void main(String[] args) throws IOException {
        //字节输入流inputStream
        // 第1步：使用File类找到一个文件
        File file=new File("E:"+File.separator+"io"+File.separator+"file.txt");
        // 第2步：通过子类实例化父类对象
        InputStream inputStream=new FileInputStream(file);// 通过对象多态性进行实例化
        // 第3步：进行读操作
        byte[] b=new byte[(int)file.length()];// 所有的内容读到此数组中
        inputStream.read(b);// 把内容从文件中取出，内容读到byte数组中
        // 第4步：关闭输入流
        inputStream.close();
        System.out.println("内容为:"+new String(b));//将byte变成字符串输出
    }
}

 除上面方法外，也可以通过循环从文件中一个一个内容读取出来，直接使用read（）方法即可

package com.zhangyuwei.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class test8 {
    public static void main(String[] args) throws IOException {
        //字节输入流inputStream
        // 第1步：使用File类找到一个文件
        File file=new File("E:"+File.separator+"io"+File.separator+"file.txt");
        // 第2步：通过子类实例化父类对象
        InputStream inputStream=new FileInputStream(file);// 通过对象多态性进行实例化
        // 第3步：进行读操作
        byte[] b=new byte[(int)file.length()];// 所有的内容读到此数组中
        for(int i=0;i<b.length;i++){
            b[i]=(byte)inputStream.read();//将内容读出
        }
        // 第4步：关闭输入流
        inputStream.close();
        System.out.println("内容为:"+new String(b));//将byte变成字符串输出
    }
}

总结：以上便是方法的一些改进，无论是哪个总有它的用处，最好呢，都掌握，因为随着开发的需要，有可能都使用到.

4:字符流操作

1:因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 

程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。

2:字符流输出（OutputStream 写出 就是将数据从程序写入到外部文件。对应 Writer）

package com.zhangyuwei.io;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class test10 {
    public static void main(String[] args) throws IOException {
        File file=new File("E:"+File.separator+"io"+File.separator+"file.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        Writer writer=new FileWriter(file);
        //Writer writer=new FileWriter(file,true);//追加
        String str="张雨威";
        writer.write(str);
        writer.flush();
        writer.close();
    }
}

3：字符流输入

package com.zhangyuwei.io;

import java.io.*;

public class test11 {
    /*字符流输入*/
    public static void main(String[] args) throws IOException {
        File file=new File("e:"+File.separator+"io"+File.separator+"file.txt");
        Reader reader=new FileReader(file);
        char[] bytes=new char[(int)file.length()];
        reader.read(bytes);
        reader.close();
        System.out.println(new String(bytes));
    }
}

另一种做法

package com.zhangyuwei.io;

import java.io.*;

public class test11 {
    /*字符流输入*/
    public static void main(String[] args) throws IOException {
        File file=new File("e:"+File.separator+"io"+File.separator+"file.txt");
        Reader reader=new FileReader(file);
        char[] bytes=new char[(int)file.length()];
        int temp;
        int i=0;
        while ((temp=reader.read(bytes)) !=-1){
            bytes[i++]=(char)temp;
        }
        reader.close();
        System.out.println("内容:"+new String(bytes));
    }
}

4:打印流

package com.zhangyuwei.io;

import java.io.*;

public class test12 {
    public static void main(String[] args) throws IOException {
        File file=new File("E:"+File.separator+"io"+File.separator+"file2.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        PrintStream ps=null;
        ps=new PrintStream(new FileOutputStream(file));
        ps.print("我是：");ps.println("zhangyuwei");
        ps.print("	"+"嚄噢哦");
        ps.close();
    }
}

Q6:简单的动态页面静态化

package com.zhangyuwei.io;

import java.io.*;
import java.util.UUID;

public class test9 {
    public static void main(String[] args) throws IOException {
        //生成新闻页
        File file05 = new File("e:" + File.separator +"io"+File.separator+"index.html");
        OutputStream os=new FileOutputStream(file05);
        StringBuffer strb=new StringBuffer();
        strb.append("<ul>");
        for (int i = 0; i <10; i++) {
            File file=new File("e:"+File.separator+"io"+File.separator+"news0"+i+".html");
            OutputStream os2=new FileOutputStream(file);
            String val=UUID.randomUUID().toString();
            os2.write(val.getBytes());
            os2.close();
            strb.append("<li>");
            strb.append("<a href='news0"+i+".html' >"+UUID.randomUUID()+"</a>");
            strb.append("</li>");
        }
        strb.append("</ul>");
        String news=strb.toString();
        os.write(news.getBytes());
        os.close();
    }
}

  结果:

Q7:文件操作工具类

package com.zhangyuwei.io;
import java.io.*;
import java.util.StringTokenizer;

public class FileUtil2 {
    private static String message;

    /**
     * 读取文本文件内容
     *
     * @param filePathAndName
     *            带有完整绝对路径的文件名
     * @param encoding
     *            文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    public static String readTxt(String filePathAndName, String encoding) throws IOException {
        encoding = encoding.trim();
        StringBuffer str = new StringBuffer("");
        String st = "";
        try {
            FileInputStream fs = new FileInputStream(filePathAndName);
            InputStreamReader isr;
            if (encoding.equals("")) {
                isr = new InputStreamReader(fs);
            } else {
                isr = new InputStreamReader(fs, encoding);
            }
            BufferedReader br = new BufferedReader(isr);
            try {
                String data = "";
                while ((data = br.readLine()) != null) {
                    str.append(data + " ");
                }
            } catch (Exception e) {
                str.append(e.toString());
            }
            st = str.toString();
        } catch (IOException es) {
            st = "";
        }
        return st;
    }

    /**
     * @description 写文件
     * @param args
     * @throws UnsupportedEncodingException
     * @throws IOException
     */
    public static boolean writeTxtFile(String content, File fileName, String encoding) {
        FileOutputStream o = null;
        boolean result=false;
        try {
            o = new FileOutputStream(fileName);
            o.write(content.getBytes(encoding));
            result=true;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (o != null) {
                try {
                    o.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return result;
    }

    /**
     *
     * @param content
     * @param fileName
     * @return
     */
    public static boolean writeTxtFile(String content,String fileName)
    {
        return   writeTxtFile(content,new File(fileName),"UTF-8");
    }

    /**
     * 新建目录
     *
     * @param folderPath
     *            目录
     * @return 返回目录创建后的路径
     */
    public static String createFolder(String folderPath) {
        String txt = folderPath;
        try {
            java.io.File myFilePath = new java.io.File(txt);
            txt = folderPath;
            if (!myFilePath.exists()) {
                myFilePath.mkdir();
            }
        } catch (Exception e) {
            message = "创建目录操作出错";
        }
        return txt;
    }

    /**
     * 多级目录创建
     *
     * @param folderPath
     *            准备要在本级目录下创建新目录的目录路径 例如 c:myf
     * @param paths
     *            无限级目录参数，各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:myfac
     */
    public static String createFolders(String folderPath, String paths) {
        String txts = folderPath;
        try {
            String txt;
            txts = folderPath;
            StringTokenizer st = new StringTokenizer(paths, "|");
            for (int i = 0; st.hasMoreTokens(); i++) {
                txt = st.nextToken().trim();
                if (txts.lastIndexOf("/") != -1) {
                    txts = createFolder(txts + txt);
                } else {
                    txts = createFolder(txts + txt + "/");
                }
            }
        } catch (Exception e) {
            message = "创建目录操作出错！";
        }
        return txts;
    }

    /**
     * 新建文件
     *
     * @param filePathAndName
     *            文本文件完整绝对路径及文件名
     * @param fileContent
     *            文本文件内容
     * @return
     */
    public static void createFile(String filePathAndName, String fileContent) {

        try {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            FileWriter resultFile = new FileWriter(myFilePath);
            PrintWriter myFile = new PrintWriter(resultFile);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
            resultFile.close();
        } catch (Exception e) {
            message = "创建文件操作出错";
        }
    }

    /**
     * 有编码方式的文件创建
     *
     * @param filePathAndName
     *            文本文件完整绝对路径及文件名
     * @param fileContent
     *            文本文件内容
     * @param encoding
     *            编码方式 例如 GBK 或者 UTF-8
     * @return
     */
    public static void createFile(String filePathAndName, String fileContent, String encoding) {

        try {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            PrintWriter myFile = new PrintWriter(myFilePath, encoding);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
        } catch (Exception e) {
            message = "创建文件操作出错";
        }
    }

    /**
     * 删除文件
     *
     * @param filePathAndName
     *            文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public static boolean delFile(String filePathAndName) {
        boolean bea = false;
        try {
            String filePath = filePathAndName;
            File myDelFile = new File(filePath);
            if (myDelFile.exists()) {
                myDelFile.delete();
                bea = true;
            } else {
                bea = false;
                message = (filePathAndName + "删除文件操作出错");
            }
        } catch (Exception e) {
            message = e.toString();
        }
        return bea;
    }

    /**
     * 删除文件夹
     *
     * @param folderPath
     *            文件夹完整绝对路径
     * @return
     */
    public static void delFolder(String folderPath) {
        try {
            delAllFile(folderPath); // 删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File(filePath);
            myFilePath.delete(); // 删除空文件夹
        } catch (Exception e) {
            message = ("删除文件夹操作出错");
        }
    }

    /**
     * 删除指定文件夹下所有文件
     *
     * @param path
     *            文件夹完整绝对路径
     * @return
     * @return
     */
    public static boolean delAllFile(String path) {
        boolean bea = false;
        File file = new File(path);
        if (!file.exists()) {
            return bea;
        }
        if (!file.isDirectory()) {
            return bea;
        }
        String[] tempList = file.list();
        File temp = null;
        for (int i = 0; i < tempList.length; i++) {
            if (path.endsWith(File.separator)) {
                temp = new File(path + tempList[i]);
            } else {
                temp = new File(path + File.separator + tempList[i]);
            }
            if (temp.isFile()) {
                temp.delete();
            }
            if (temp.isDirectory()) {
                delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
                delFolder(path + "/" + tempList[i]);// 再删除空文件夹
                bea = true;
            }
        }
        return bea;
    }

    /**
     * 复制单个文件
     *
     * @param oldPathFile
     *            准备复制的文件源
     * @param newPathFile
     *            拷贝到新绝对路径带文件名
     * @return
     */
    public static void copyFile(String oldPathFile, String newPathFile) {
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPathFile);
            if (oldfile.exists()) { // 文件存在时
                InputStream inStream = new FileInputStream(oldPathFile); // 读入原文件
                FileOutputStream fs = new FileOutputStream(newPathFile);
                byte[] buffer = new byte[1444];
                while ((byteread = inStream.read(buffer)) != -1) {
                    bytesum += byteread; // 字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        } catch (Exception e) {
            message = ("复制单个文件操作出错");
        }
    }

    /**
     * 复制整个文件夹的内容
     *
     * @param oldPath
     *            准备拷贝的目录
     * @param newPath
     *            指定绝对路径的新目录
     * @return
     */
    public static void copyFolder(String oldPath, String newPath) {
        try {
            new File(newPath).mkdirs(); // 如果文件夹不存在 则建立新文件夹
            File a = new File(oldPath);
            String[] file = a.list();
            File temp = null;
            for (int i = 0; i < file.length; i++) {
                if (oldPath.endsWith(File.separator)) {
                    temp = new File(oldPath + file[i]);
                } else {
                    temp = new File(oldPath + File.separator + file[i]);
                }
                if (temp.isFile()) {
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(newPath + "/" + (temp.getName()).toString());
                    byte[] b = new byte[1024 * 5];
                    int len;
                    while ((len = input.read(b)) != -1) {
                        output.write(b, 0, len);
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if (temp.isDirectory()) {// 如果是子文件夹
                    copyFolder(oldPath + "/" + file[i], newPath + "/" + file[i]);
                }
            }
        } catch (Exception e) {
            message = "复制整个文件夹内容操作出错";
        }
    }

    /**
     * 移动文件
     *
     * @param oldPath
     * @param newPath
     * @return
     */
    public static void moveFile(String oldPath, String newPath) {
        copyFile(oldPath, newPath);
        delFile(oldPath);
    }

    /**
     * 移动目录
     *
     * @param oldPath
     * @param newPath
     * @return
     */
    public static void moveFolder(String oldPath, String newPath) {
        copyFolder(oldPath, newPath);
        delFolder(oldPath);
    }

    /**
     * 得到错误信息
     */
    public static String getMessage() {
        return message;
    }
}

测试

package com.zhangyuwei.io;

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

public class test13 {
    public static void main(String[] args) throws IOException {
        //多级目录的创建
        /*String path=FileUtil2.createFolders("E:io","a/b/c/d");
        System.out.println(path);*/
        FileUtil2.createFile("E:"+File.separator+"io"+File.separator+"files3.txt","飞洒发的飞洒","utf-8");
    }
}

Q8:官网下载地址:

官网：http://commons.apache.org/proper/commons-io/

下载 ：http://commons.apache.org/proper/commons-io/download_io.cgi

提示:要想要知道Excel导入导出，请看我另一篇博客:https://www.cnblogs.com/zywds/p/9921692.html