文件和流

IO作用：解决设备和设备之间数据传输问题，内存->硬盘，硬盘->内存，键盘数据->内存数据存到硬盘上，就做到了永久保存，数据一般是以文件形式保存到硬盘上，sun用File描述文件文件夹

File构造方法

File file = new File(String pathname);

public class Test {
    public static void main(String[] args) {
        File file = new File("E:\\test.txt");
        try {
            file.createNewFile();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

在文件夹里创建文件
File file = new File (String 文件夹， String 文件名）；

public class Test {
    public static void main(String[] args) {
        File file = new File("E:\\k","test.txt");
        try {
            file.createNewFile();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

在文件夹中的文件夹里创建文件

public class Test {
    public static void main(String[] args) {
        File file1 = new File("E:\\k\\k")
        File file = new File(file1,"test.txt");
        try {
            file.createNewFile();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

绝对路径 & 相对路径

相对路径不能跨盘
相对路径：../../Test1.txt, ./Test1.txt = Test1.txt

创建

创建文件：
createNewFile();
创建单层文件夹：
mkdir();

//在E盘里创建一个叫k的文件夹
File file = new File("E:/k");
try{
  file.mkdir();
}catch(Exception e){
  e.printStackTrace();
}

mkdir
public boolean mkdir()
创建此抽象路径名指定的目录。
返回：
当且仅当已创建目录时，返回 true；否则返回 false

File file = new File("E:.k.txt");
boolean b = file.mkdir();
System.out.println(b);

创建多层文件夹：
mkdirs();

File file = new File("E:/a/b/c/d");
file.mkdirs();

文件重命名：

File srcFile = new File("E:/test.txt");
File destFile = new File("E:/k.txt");
srcFile.renameTo(destFile);

删除文件(夹）：

File srcFile = new File("E:/test.txt");
File destFile = new File("E:/k.txt");
srcFile.delete();

删除成功返回true，否则返回false

存在：
exists()；
System.out.println(srcFile.exists());
boolean型, 存在返回true，否则返回false

是不是文件： src.isFile(); boolean型

是不是目录：isDirectory(); boolean

是不是一个目录： isDirectory(); boolean

是否被隐藏： isHidden(); boolean

是否是绝对路径： isAbsolute(); boolean

获取文件名： getName(); String

获取（假）绝对路径： getPath(); String

获取绝对路径： getAbsolutePath(); String

获取文件内容字节个数： long length();

获取最后一次修改时间： lastModified();

获取次抽象路径名表示的目录中的所有子文件（夹）：
File[] listFiles(); 数组

File file = new File("E:/k");
File[] list = file.listFiles();
for(File file1 : list){
  System.out.println(file1.getName());
}
//或取E盘k文件夹下的文件（夹）名

public class Test {
    public static void main(String[] args) {
        File file = new File("E:/k");
        test(file);
    }
    public static void test(File file){
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++){
            if (files[i].isFile()){
                System.out.println(files[i].getName());
            }else {
                test(files[i]);
            }
        }
    }
}
//获取E盘k文件夹里所有文件名

获取文件夹里的所有文件：
递归思想

public class Practice {
    public static void main(String[] args) {
       PrintFiles("e/neusoft");
    }
    public static void PrintFiles(String path){
        File file1 = new File(path);
        File[] files = file1.listFiles();
        for (File file : files){
            if (file.isFile()) {
                System.out.println(file.getName());
            }
            else if (file.isDirectory()){
                System.out.println(file.getAbsolutePath());
                PrintFiles(file.getAbsolutePath());
            }
        }
    }
}

流

流是指一连串流动的字符，是以先进先出方式发送信息的通道。
通过流来读写文件。
字符，字节流：

  • 往文本文档里写东西是字符流，字符输入流Reader,字符输出流Writer
  • 往word里写东西是字节流，字节输入流InputStream,字符输出流OutputStream
    输入，输出流：
  • 往内存里读叫输入流，InputStream 和Reader作为基类
  • 从内存出叫输出流，OutputStream和Writer作为基类

文本文件的读写：

  • 用FileInputStream和FileOutputStream读写
  • 用BufferedReader和BufferedWriter读写

二进制文件读写：

  • 使用DataInputStream和DataOutputStream读写

使用FileInputStream读写：


image.png

InputStream类常用方法：
int read( ) 读取一个字节
int read(byte[] b) 读取一批字节
int read(byte[] b,int off,int len)
void close( )
子类FileInputStream常用的构造方法
FileInputStream(File file)
FileInputStream(String name)

byte[] buffer = new byte[10];
buffer[0] = 97;
buffer[1]=98;//b
String string = new String(buffer,0//offset,2//length);
System.out.println(string);

read()

File file = new File("e:/test.txt");
System.out.println(file.length());
byte[] buffer = new byte[(int)file.length()];
FileInputStream fileInputStream = new FileInputStream(file);
int index = 0;
byte content = (byte)fileInputStream.read();//读取文件的一个字节
while (content != -1){
  buffer[index] = content;
  index++;
  content = (byte)fileInputStream.read();
}
System.out.println(Arrays.toString(buffer));
String string = new String(buffer,0,index);
System.out.println(string);

read(byte[] b)

public static void main(String[] args) throws IOException {
        // write your code here

        File file = new File("d:/我的青春谁做主.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

        byte[] buffer = new byte[SIZE];//保存从磁盘读到的字节


        int len = fileInputStream.read(buffer);//第一次读文件中的100个字节
        while (len != -1)
        {
            String string = new String(buffer,0, len);
            System.out.println(string);
            //读下一批字节
            len = fileInputStream.read(buffer);
        }
    }

写文件：

FileOutputStream fileOutputStream = new FileOutputStream("e:/test.txt");
        String string = "good job";
        byte[] words = string.getBytes();
        fileOutputStream.write(words,0,words.length);

OutputStream类常用方法
void write(int c)
void write(byte[] buf)
void write(byte[] b,int off,int len)
void close( )
子类FileOutputStream常用的构造方法
FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)
1、前两种构造方法在向文件写数据时将覆盖文件中原有的内容
2、创建FileOutputStream实例时，如果相应的文件并不存在，则会自动创建一个空的文件

复制文件内容
文件“我的青春谁做主.txt”位于D盘根目录下，要求将此文件的内容复制到
C:\myFile\my Prime.txt中
实现思路:
创建文件“D:\我的青春谁做主.txt”并自行输入内容
创建C:\myFile的目录。
创建输入流FileInputStream对象，负责对D:\我的青春谁做主.txt文件的读取。
创建输出流FileOutputStream对象，负责将文件内容写入到C:\myFile\my Prime.txt中。
创建中转站数组words，存放每次读取的内容。
通过循环实现文件读写。
关闭输入流、输出流

 File file = new File("e:/Test.txt");
        File file1 = new File("d:/myFile");
        try{
            file1.mkdir();
        }catch (Exception e){
            e.printStackTrace();
        }
        File file2 = new File("d:/myFile/my Prime.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        FileOutputStream fileOutputStream = new FileOutputStream(file2);
        byte[] buffer = new byte[5];
        int read_len = fileInputStream.read(buffer);
        while (read_len != -1){
            String string = new String(buffer,0,read_len);
            System.out.println(string);
            byte[] words = string.getBytes();
            fileOutputStream.write(words,0,words.length);
            read_len = fileInputStream.read(buffer);
        }

File file = new File("e:/c2fdfc039245d688c56332adacc27d1ed21b2451.jpg");
        File file1 = new File("d:/myFile");
        if (!file1.exists()){
            file1.mkdir();
        }
        File file2 = new File("d:/myFile/my Prime.jpg");
        FileInputStream fileInputStream = new FileInputStream(file);
        FileOutputStream fileOutputStream = new FileOutputStream(file2);
        byte[] buffer = new byte[10];
        int read_len = fileInputStream.read(buffer);
        while (read_len != -1){
            fileOutputStream.write(buffer,0,buffer.length);
            read_len = fileInputStream.read(buffer);
        }
        fileInputStream.close();
        fileOutputStream.close();

使用字符流读写文件

使用FileReader读取文件

public static void main(String[] args) throws IOException {
        //
        FileReader fileReader = new FileReader("D:/我的青春谁做主.txt");

        char[] array = new char[100];
        int length = fileReader.read(array);
        StringBuilder sb = new StringBuilder();//拼接字符串
        while (length != -1)
        {
            sb.append(array);//追加字符串
            length = fileReader.read(array);
        }

        System.out.println(sb.toString());
        fileReader.close();

    }

FileReader fileReader = new FileReader("e:/test.txt");
        char[] chars = new char[5];
        int length = fileReader.read(chars);
        StringBuilder stringBuilder = new StringBuilder();
        int count = 0;
        while (length != -1){
            count++;
            System.out.println(count);
            stringBuilder.append(chars);
            Arrays.fill(chars,'\u0000');
            length = fileReader.read(chars);
            
        }
        System.out.println(stringBuilder.toString());
        fileReader.close();

BufferedReader类

使用FileReader类与BufferedReader类
BufferedReader类是Reader类的子类
BufferedReader类带有缓冲区
按行读取内容的readLine()方法


image.png
public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("D:/我的青春谁做主.txt");

        BufferedReader bufferedReader = new BufferedReader(fileReader);

        String strContent = bufferedReader.readLine();
        StringBuilder sb = new StringBuilder();
        while (strContent != null)
        {
            sb.append(strContent);
            sb.append("\n");
            sb.append("\r");
            strContent = bufferedReader.readLine();
        }

        System.out.println(sb.toString());
        fileReader.close();
        bufferedReader.close();
    }

使用FileWriter写文件

FileWriter fileWriter = new FileWriter("e:/test.txt");
fileWriter.append("hello world");
fileWriter.flush();
fileWriter.close();

如何提高字符流写文本文件的效率？
使用FileWriter类与BufferedWriter类
BufferedWriter类是Writer类的子类
BufferedWriter类带有缓冲区


image.png
public class BufferedWriterTest {
    public static void main(String[] args) {
        FileWriter fw=null;
        BufferedWriter bw=null;
        FileReader fr=null;
        BufferedReader br=null;
        try {
           //创建一个FileWriter 对象
           fw=new FileWriter("D:\\myDoc\\hello.txt"); 
           //创建一个BufferedWriter 对象
           bw=new BufferedWriter(fw); 
           bw.write("大家好！"); 
           bw.write("我正在学习BufferedWriter。"); 
           bw.newLine(); 
           bw.write("请多多指教！"); 
           bw.newLine();               
           bw.flush();
                       
           //读取文件内容
            fr=new FileReader("D:\\myDoc\\hello.txt"); 
            br=new BufferedReader(fr); 
            String line=br.readLine();
            while(line!=null){ 
                System.out.println(line);
                line=br.readLine(); 
            }
          
            fr.close(); 
           }catch(IOException e){
                System.out.println("文件不存在!");
           }finally{
               try{
                   if(fw!=null)
                       fw.close();
                   if(br!=null)
                       br.close();
                   if(fr!=null)
                       fr.close();  
               }catch(IOException ex){
                    ex.printStackTrace();
               }
           }
    }
}

文本拷贝

FileReader fr = new FileReader("e:/test.txt");
        FileWriter wr = new FileWriter("d:/myFile/my Prime.txt");
        BufferedReader reader = new BufferedReader(fr);
        BufferedWriter writer = new BufferedWriter(wr);
        StringBuffer str = new StringBuffer();
        String line = reader.readLine();
        while (line != null){
            str.append(line);
            str.append("\n");
            str.append("\t");
            wr.flush();
            line = reader.readLine();
        }
        System.out.println(str.toString());
        String string = str.toString().replace("{name}","golden");
        string = string.toString().replace("{type}","dog");
        string = string.toString().replace("{master}","zabrath");
        System.out.println(string);
        writer.write(string);
        writer.flush();

练习 统计某个文件夹下所有java文件代码行数之和:

File file = new File("C:\\Users\\Administrator\\IdeaProjects\\jemalsjava\\src\\com\\company\\");
        File[] arr = file.listFiles();
        int totalCount = 0;
        for (File file1 : arr){
            FileReader fileReader = new FileReader(file1);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            int countLine = 0;
            String strLine = bufferedReader.readLine();
            while (strLine != null){
                countLine++;
                strLine = bufferedReader.readLine();
            }
            totalCount += countLine;
        }
        System.out.println(totalCount);

package com.company;

import java.io.*;

/**
 * Created by ttc on 2018/6/5.
 */
public class CodeLinesCount {
    public static int CountLines(String filename) throws IOException {
        FileReader fileReader = new FileReader(filename);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        int count = 0;
        String strLine = bufferedReader.readLine();
        while(strLine != null)
        {
            count++;
            strLine = bufferedReader.readLine();
        }
        System.out.println(count);
        return count;
    }
    public static void main(String[] args) throws IOException {
//        CountLines("d:/Main.java");
        File file = new File("D:\\javacode");
        File[] files = file.listFiles();
        int sum = 0;
        for(File file1 : files)
        {
            System.out.println(file1.getPath());
            int count = CountLines(file1.getPath());
            sum += count;
        }
        System.out.println(sum);
    }
}

DataOutputStream和DataInputStream

DataOutputStream数据输出流： 将java基本数据类型写入数据输出流中。
DataInputStream数据输入流：将DataOutputStream写入流中的数据读入。

DataOutputStream中write的方法重载：

继承了字节流父类的两个方法：
（1）void write(byte[] b,int off,int len);
（2）void write(int b);//写入UTF数值，代表字符
注意字节流基类不能直接写入string 需要先将String转化为getByte()转化为byte数组写入
特有的指定基本数据类型写入：
（1）void writeBoolean(boolean b);//将一个boolean值以1byte形式写入基本输出流。
（2）void writeByte(int v);//将一个byte值以1byte值形式写入到基本输出流中。
（3）void writeBytes(String s);//将字符串按字节顺序写入到基本输出流中。
（4）void writeChar(int v);//将一个char值以2byte形式写入到基本输出流中。先写入高字节。写入的也是编码值；
（5）void writeInt(int v);//将一个int值以4byte值形式写入到输出流中先写高字节。
（6）void writeUTF(String str);//以机器无关的的方式用UTF-8修改版将一个字符串写到基本输出流。该方法先用writeShort写入两个字节表示后面的字节数。

DataInputStream中read方法重载：

继承了字节流父类的方法：
int read();
int read(byte[] b);
int read(byte[] buf,int off,int len);
对应write方法的基本数据类型的读出：
String readUTF();//读入一个已使用UTF-8修改版格式编码的字符串
boolean readBoolean;
int readInt();
byte readByte();
char readChar();
注意：
基本数据类型的写入流和输出流，必须保证以什么顺序按什么方式写入数据，就要按什么顺序什么方法读出数据，否则会导致乱码，或者异常产生。

public class DataStream {
    public static void main(String[] args) throws IOException {
        String[] strings = {"main","flush","String","FileOutputStream","java.io.*"};
        FileOutputStream fileOutputStream = new FileOutputStream("e:/output.txt");
        DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);

        for(String string : strings)
        {
            int strlen = string.length();
            dataOutputStream.writeShort(strlen);
            dataOutputStream.writeBytes(string);
        }


        dataOutputStream.flush();
        dataOutputStream.close();

        FileInputStream fileInputStream = new FileInputStream("e:/output.txt");
        DataInputStream dataInputStream = new DataInputStream(fileInputStream);

        while(true)
        {
            try {
                short len = dataInputStream.readShort();
                byte[] bytes = new byte[len];
                dataInputStream.read(bytes);
                String string = new String(bytes,0,bytes.length);
                System.out.println(string);
            }
            catch (EOFException ex)
            {
                break;
            }

        }

    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,098评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,213评论 2赞 380
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,960评论 0赞 336
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,519评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,512评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,533评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,914评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,574评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,804评论 1赞 296
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,563评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,644评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,350评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,933评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,908评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,146评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,847评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,361评论 2赞 342

推荐阅读更多精彩内容