滴水穿石-08IO

1.0 File

a:构造方法

package d8;

import java.io.File;

public class FileGouZao {
    public static void main(String[] args) {
        //方式一:根据一个路径得到一个一个file对象
        //File(String pathName)
        File fe = new File("D:\\aaa\\a.txt");
        
        //方式二,通过父路径的名字 + 子文件/目录得到一个File对象
        //File(String parent,String child)
        File fe2 = new File("D:\\aaa","a.txt");
        
        //方式三,通过父File对象 + 子文件/目录得到一个File对象
        //File(File parent,String child)
        File fe3 = new File("D:\\aaa");
        File fe4 = new File(fe3,"D:\\aaa");
    }
}

b:创建方法

package d8;

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

public class FileGouAdd {
    public static void main(String[] args) throws IOException {
        //方式一:创建文件
        //boolean createNewFile()
        File fe = new File("D:\\aaa\\a.txt");
        fe.createNewFile();
        //方式二,创建文件夹
        //boolean mkdir()
        File fe2 = new File("D:\\aaa","aa");
        fe2.mkdir();
        //方式三, 创建文件夹们,如果父文件夹不存在就创建
        //boolean mkdirs()
        File fe3 = new File("D:\\aaa");
        File fe4 = new File(fe3,"aa\\a");
        fe4.mkdirs();
        //注意如果没有写盘符,默认为项目路径
        File fe5 = new File("a.txt");
        fe5.createNewFile();
        
        //如果用方式一创建时,如果父目录不存在,会出现"系统找不到指定的路径"的错误
        //如果用方式二创建时,如果父目录不存在,返回false
        //如果用方式三创建时,如果父目录不存在,就创建上级目录
    }
}

c:删除方法

package d8;

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

public class FileDelete {
    public static void main(String[] args) throws IOException {
        //方式一:创建文件
        //boolean createNewFile()
        File fe = new File("D:\\aaa\\a.txt");
        fe.createNewFile();
        fe.delete();
         
        
        File fe2 = new File("D:\\aaa");
        System.out.println(fe2.delete());
        //--------false---------//
         
        
        //注意:删除不走回收站
        //如果是删除目录,则该目录必须为空才能删除
        
    }
}

package d8;

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

public class Filedelete2 {
    public static void main(String[] args) throws IOException {
        //获取F盘所有的.exe文件
         
        File fe = new File("D:\\aaa");
        deleteAllFile(fe);
         /* */
    }
    public static void deleteAllFile(File fe) {
        if( fe.isFile()|| fe==null ) {
            System.out.println(fe.getPath());
            fe.delete();
            
        }else if(fe.isDirectory()&& fe.list().length<1){
            System.out.println(fe.getPath());
            fe.delete();             
        }else {
            File [] files = fe.listFiles();
            if (files!=null) {
                for (File file : files) {
                    deleteAllFile(file);
                }
                deleteAllFile(fe);
            }
            
        }
        
    }
}
/*D:\aaa\a.txt
D:\aaa\aa\a
D:\aaa\aa
D:\aaa\b.txt
D:\aaa\d.txt
D:\aaa*/

d:修改方法

package d8;

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

public class FileRenameTo {
    public static void main(String[] args) throws IOException {
        //方式一:路径相同重命名    
        File fe = new File("D:\\aaa\\a.txt");
        fe.createNewFile();
        File f2 = new File("D:\\aaa\\b.txt");
        fe.renameTo(f2);
        
        //方式二:路径不同,相当于剪切功能
        File fe3 = new File("a.txt");//默认路径,也就是项目路径
        fe3.createNewFile();
        File f4 = new File("D:\\aaa\\d.txt");
        fe3.renameTo(f4);
        
        //方式一:路径相同重命名    
        //方式二:路径不同,相当于剪切功能
        
    }
}

 e:判断功能

package d8;

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

public class FileJudge {
    public static void main(String[] args) throws IOException {

        File fe = new File("D:\\aaa\\a.txt");

        boolean existsB = fe.exists();// 判断文件是否是存在
        boolean isFileB = fe.isFile();// 判断文件是否是一个标准文件
        boolean isDirectoryB = fe.isDirectory();// 判断文件是否是一个目录
        boolean isHiddenB = fe.isHidden();// 判断文件是否是隐藏
        boolean canReadB = fe.canRead();// 判断文件是否可读
        boolean canWriteB = fe.canWrite();// 判断文件是否是可写

        System.out.println(existsB);        //---true---/
        System.out.println(isFileB);        //---true---/
        System.out.println(isDirectoryB);    //---false---/
        System.out.println(isHiddenB);        //---false---/
        System.out.println(canReadB);        //---true---/
        System.out.println(canWriteB);        //---true---/
        
    }
}

 f:获取功能

package d8;

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

public class FileGet {
    public static void main(String[] args) throws IOException {

        File fe = new File("D:\\aaa\\a.txt");

        String strAbsolutePath = fe.getAbsolutePath();// 获取文件绝对路径
        String strPath = fe.getPath();// 获取文件路径
        String strName = fe.getName();// 获取文件名
        Long length = fe.length();// 获取文件大小
        Long strLastModified = fe.lastModified();// 获取文件最后的修改时间
        Date d = new Date(strLastModified);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(strAbsolutePath); // ---D:\aaa\a.txt----/
        System.out.println(strPath); // ---D:\aaa\a.txt----/
        System.out.println(strName); // ---a.txt-----/
        System.out.println(length); // ---12-----/
        System.out.println(strLastModified); // ---1517184516189---/
        System.out.println(s); // ---2018-01-29 20:10:41----/

    }
}

package d8;

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

public class FileGet2 {
    public static void main(String[] args) throws IOException {

        File fe = new File("D:\\");

         String [] nameArray = fe.list();
         for (String s : nameArray) {
            System.out.println(s);
        }
         
         File [] fileArray = fe.listFiles();
         for (File f : fileArray) {
            System.out.println(f.getName());
        }
         
         /*
$RECYCLE.BIN
00002109030000000000000000F01FEC.reg
aaa
API文档
BaiduNetdiskDownload
Config.Msi
Develop
java(1)
JavaWorkspace
LuceneNet测试文件
midnds
MyDrivers
pagefile.sys
Program Files
Program Files (x86)
StormMedia
System Volume Information
Unity3D5.0
Users
博客资料
迅雷下载
黑马JavaEE32*/
    }
}

package d8;

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

public class FileTest {
    public static void main(String[] args) throws IOException {
        //找出D盘下所有以.reg结尾的文件
        File fe = new File("D:\\");
        
        //方法一:取出所有文件然后筛选
        File [] files = fe.listFiles();
        for (File f : files) {
            if (f.isFile()&&f.getName().endsWith(".reg")) {
                System.out.println(f.getName());
            }
        }
        //-----------00002109030000000000000000F01FEC.reg----------//
      
        
        //方法二: 通过过滤器先过滤一下 listFiles(FileFilter filter) 
        File [] files2 = fe.listFiles(new FileFilter() {            
            @Override
            public boolean accept(File pathname) {
                // TODO Auto-generated method stub
                return pathname.isFile()&&pathname.getName().endsWith(".reg");
            }
        });
        for (File f : files2) { 
                System.out.println(f.getName()); 
        }
        //-----------00002109030000000000000000F01FEC.reg----------//
        
        //方法三:方法二可能消耗的资源有点大 list(FilenameFilter filter) 
        String [] files3 =  fe.list(new FilenameFilter() {
            
            @Override
            public boolean accept(File dir, String name) {
                if (name.endsWith(".reg")) {
                    File fnew = new File(dir, name);
                    return fnew.isFile();
                }
                return false;
            }
        });
        for (String f : files3) { 
                System.out.println(f); 
        }
        //-----------00002109030000000000000000F01FEC.reg----------//
    }
}

 

 2.0 IO

 

2.1　InputStream

　　2.1.1 FileInputStream

　　a:构造方法　　

package d8;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class FileInputStreamGouZao {
    public static void main(String[] args) throws FileNotFoundException {
        
        
        // 方式一:根据一个路径得到一个读取数据的写入文件流对象
        // FileOutputStream(String name)
        FileInputStream fos = new FileInputStream("D:\\aaa\\a.txt");

        // 方式二,通过File对象 得到一个读取数据的写入文件流对象
        // FileOutputStream(File file)
        File fe = new File("D:\\aaa", "a.txt");
        FileInputStream fos2 = new FileInputStream(fe);

         
    }
}

　　b:读取方法

package d8;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileInputStreamRead {
    public static void main(String[] args) throws IOException {
 
        // 方式一:
        // read()  从此输入流中读取一个数据字节。

        FileInputStream fis = new FileInputStream("D:\\aaa\\a.txt");
        int b = 0;
        while((b=fis.read())!=-1) {
            System.out.println((char)b);
        } 
        fis.close();
        

        // 方式二
        //read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
        FileInputStream fis2 = new FileInputStream("D:\\aaa\\a.txt");
        byte[] bs = new byte[5];      
        while(( fis2.read(bs))!=-1) {
            System.out.println(new String(bs));
        } 
        fis2.close();
         

        // read(byte[] b, int off, int len)
        // 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
        FileInputStream fis3 = new FileInputStream("D:\\aaa\\a.txt");
        byte[] bs2 = new byte[5];    
        int len = 0;
        while(( len = fis3.read(bs2))!=-1) {
            System.out.println(new String(bs2,0,len));
        } 
        fis3.close();
    }
}
/* 方式一
H
e
l
l
o




W
o
r
l
d
 




j
a
v
a    */

/* 方式二

Hello

Wor
ld 

java 

va 
*/
/* 方式三
Hello

Wor
ld 

java 
*/

　　2.1.2 BufferedInputStream

 a:构造方法

package d8;

 
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamGouZao {
    public static void main(String[] args) throws IOException   {
         
        // 方式一:根据一个路径得到一个写入数据的输出文件流对象
        //BufferedInputStream(InputStream out) 
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"));

        // 方式二,通过Buffered对象 得到一个写入数据的输出文件流对象
        // BufferedInputStream(InputStream out, int size) 
        BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"),1024);

    }
}

b:读取方法

package d8;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamReade{
    public static void main(String[] args) throws IOException {

        // 方式一
        // read(int b) 将指定字节写入此文件输出流。
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"));
         int b =0;
         while ((b=fis.read())!=-1) {
             System.out.println(b);
        }
         /*
97
32
119
111*/

        // read(byte[] b, int off, int len)
        // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
        BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"), 1024);
         byte [] by = new byte[5];
         int len =0;
         while ((len = fis2.read(by,0,2))!=-1) {
             System.out.println(new String(by,0,len));
        }
         
         //------------a -----------//
        //------------wo-----------//
    }
}    

 

2.2 OutPutStream

　　2.2.1 FileOutputStream

　　a:构造方法

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileOutputStreamGouZao {
    public static void main(String[] args) throws FileNotFoundException {
        
        //创建字节输出流对象做了3件事情
        //01 调用系统功能创建文件
        //02 创建fos对象
        //03 将字节输出流对象指向对应的文件

        // 方式一:根据一个路径得到一个写入数据的输出文件流对象
        // FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt");

        // 方式二,通过File对象 得到一个写入数据的输出文件流对象
        // FileOutputStream(File file)
        File fe = new File("D:\\aaa", "a.txt");
        FileOutputStream fos2 = new FileOutputStream(fe);

        // 方式三:根据一个路径得到一个写入数据的输出文件流对象,如为 true，则将字节写入文件末尾处
        // FileOutputStream(String name,boolean append)
        FileOutputStream fos3 = new FileOutputStream("D:\\aaa\\a.txt", true);

        // 方式四,通过File对象 得到一个写入数据的输出文件流对象,如为 true，则将字节写入文件末尾处
        // FileOutputStream((File file,boolean append)
        File fe2 = new File("D:\\aaa", "a.txt");
        FileOutputStream fos4 = new FileOutputStream(fe2, true);
    }
}

　　b:写入方法

package d8;

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

public class FileOutputStreamWrite {
    public static void main(String[] args) throws IOException {

        // 创建字节输出流对象做了3件事情
        // 01 调用系统功能创建文件
        // 02 创建fos对象
        // 03 将字节输出流对象指向对应的文件

        // close()方法的作用
        // 1:让流对象变成垃圾,方便被垃圾回收站回收
        // 2:通知系统去释放掉该文件相关的资源

        // 方式一:
        // write(byte[] b) 根据一个路径将指定 byte 数组写入此文件输出流中

        FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt");
        fos.write("Hello World !".getBytes());
        fos.close();
        // -------Hello World !---------//

        // 方式二
        // write(int b) 将指定字节写入此文件输出流。
        FileOutputStream fos2 = new FileOutputStream("D:\\aaa\\b.txt");
        fos2.write(97);
        fos2.close();
        // -------a---------//

        // write(byte[] b, int off, int len)
        // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
        FileOutputStream fos3 = new FileOutputStream("D:\\aaa\\c.txt");
        fos3.write("Hello World !".getBytes(), 0, 5);
        fos3.close();
        // -------Hello---------//
    }
}

package d8;

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

public class FileOutputStreamWrite2 {
    public static void main(String[] args) throws IOException {

        // 创建字节输出流对象做了3件事情
        // 01 调用系统功能创建文件
        // 02 创建fos对象
        // 03 将字节输出流对象指向对应的文件

         
        // 方式一:
        // write(byte[] b) 根据一个路径将指定 byte 数组写入此文件输出流中

        FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt",true);
        fos.write('\r');
        fos.write('\n');
        fos.write("Hello World !".getBytes());
        fos.close();
        //-------Hello World !---------//
        //--------Hello World ! ---------//
        // 方式二
        // write(int b) 将指定字节写入此文件输出流。
        File fe2 = new File("D:\\aaa", "b.txt");
        FileOutputStream fos2 = new FileOutputStream(fe2, true);
         
        fos2.write(97);
        fos2.close();
        //-------aa---------//
        
     
    }
}

　　2.2.2 BufferedOutputStream

　　a:构造方法

package d8;

 
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamGouZao {
    public static void main(String[] args) throws IOException   {
         
        // 方式一:根据一个路径得到一个写入数据的输出文件流对象
        //BufferedOutputStream(OutputStream out) 
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"));

        // 方式二,通过Buffered对象 得到一个写入数据的输出文件流对象
        // BufferedOutputStream(OutputStream out, int size) 
        BufferedOutputStream fos2 = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"),1024);

    }
}

　　b:写入方法

package d8;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamWrite {
    public static void main(String[] args) throws IOException {

        // 方式一
        // write(int b) 将指定字节写入此文件输出流。
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"));
        fos.write(97);
        fos.close();
        // -------a---------//

        // write(byte[] b, int off, int len)
        // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
        BufferedOutputStream fos2 = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt",true), 1024);
        fos2.write("hello world java".getBytes(), 5, 3);
        fos2.close();
         //------------a wo-----------//
    }
}

 练习：4钟操作的复制文件

package d8;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class CopyTest {
    public static void main(String[] args) throws IOException {
        Long start = System.currentTimeMillis();
        method1();
        Long end = System.currentTimeMillis();
        System.out.println("方法一：耗时"+(end-start));
        Long start2 = System.currentTimeMillis();
        method2();
        Long end2 = System.currentTimeMillis();
        System.out.println("方法二：耗时"+(end2-start2));
        
        Long start3 = System.currentTimeMillis();
        method3();
        Long end3 = System.currentTimeMillis();
        System.out.println("方法三：耗时"+(end3-start3));
        
        Long start4 = System.currentTimeMillis();
        method4();
        Long end4 = System.currentTimeMillis();
        System.out.println("方法四：耗时"+(end4-start4));
    }

    private static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a4.avi"));
        byte [] by = new byte[1024];
        int len =0;
        while ((len=bis.read(by))!=-1) {
            bos.write(by,0,len);
            bos.flush();
        } 
        bis.close();
        bos.close();
    }
    //高效字节流，一次读写一个字节
    private static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a3.avi"));
        int b =0;
        while ((b=bis.read())!=-1) {
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
    //基本字节流，一次读写一个数组长度
    private static void method2() throws IOException {
        FileInputStream fi2 = new FileInputStream("D:\\aaa\\a.avi");
        FileOutputStream fo2 = new FileOutputStream("D:\\aaa\\a2.avi");
        byte [] by = new byte[1024];
        int len =0;
        while ((len=fi2.read(by))!=-1) {
            fo2.write(by,0,len);
        } 
        fi2.close();
        fo2.close();
    }
    
    //基本字节流，一次读写一个字节
    private static void method1() throws IOException {
        FileInputStream fi = new FileInputStream("D:\\aaa\\a.avi");
        FileOutputStream fo = new FileOutputStream("D:\\aaa\\a1.avi");
        int b =0;
        while ((b=fi.read())!=-1) {
            fo.write(b);
        } 
        fi.close();
        fo.close();
    }
}
/*
 方法一：耗时243369
方法二：耗时302
方法三：耗时416
方法四：耗时270
*/

字符流 = 字节流+编码表 

3.1 Reader

　　3.1.1 InputStreamReader

　　a:构造方法　　

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class InputStreamReaderGouZao {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 字符输入流：字节输入流+编码

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
        // InputStreamReader(InputStream In)
        InputStreamReader isw = new InputStreamReader(new FileInputStream("D:\\aaa\\a.txt"));

        // 方式二：根据一个字节输入流 + 指定编码 得到一个字符输入对象
        // InputStreamReader(InputStream In, String charsetName)
        InputStreamReader isw2 = new InputStreamReader(new FileInputStream("D:\\aaa\\a.txt"), "utf-8");

    }
}

　　b:read方法 

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class InputStreamReaderRead {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 字符输入流：字节输入流+编码

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
        // InputStreamReader(InputStream In)
        InputStreamReader osw = new InputStreamReader(new FileInputStream("D:\\aaa\\b.txt"));

        int b = 0;
        while ((b=osw.read())!=-1) {
            System.out.print((char)b);
        }
        // 方式二：根据一个字节输入流 + 指定编码 得到一个字符输入对象
        // InputStreamReader(InputStream In, String charsetName)
        InputStreamReader osw2 = new InputStreamReader(new FileInputStream("D:\\aaa\\b.txt"), "utf-8");
        char [] by =new char[5];
        int len=0;
        while ((len=osw2.read(by, 0, 3))!=-1) {
            System.out.println(new String(by,0,len));
        }
    }
}
/*浣犲ソ涓栫晫你好世
界*/

3.1.2 FileReader

 a：构造方法

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileReader;
import java.io.UnsupportedEncodingException;

public class FileReaderGouZao {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
        // FileReader(File file)
        FileReader isw = new FileReader("D:\\aaa\\a.txt");

        // 方式二：在给定从中读取数据的文件名的情况下创建一个新 FileReader。
        // FileReader( String fileName)
        FileReader isw2 = new FileReader(new File("D:\\aaa\\a.txt"));

    }
}

b:read方法 

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class FileReaderRead {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
        // FileReader(File file)
        FileReader fr = new FileReader("D:\\aaa\\a.txt");
        int b = 0;
        while ((b = fr.read()) != -1) {
            System.out.print((char) b);
        }

        // 方式二：在给定从中读取数据的文件名的情况下创建一个新 FileReader。
        // FileReader( String fileName)
        FileReader fr2 = new FileReader(new File("D:\\aaa\\a.txt"));
        char[] by = new char[5];
        int len = 0;
        while ((len = fr2.read(by, 0, 3)) != -1) {
            System.out.println(new String(by, 0, len));
        }
    }
}
/*
 * aaabcdefaaa
bcd
ef
 */

3.1.3 BufferedReader

 a：构造方法

package d8;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderGouZao {
    public static void main(String[] args) throws  IOException {

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
        // BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader("D:\\aaa\\a.txt"));

        // 方式二：BufferedReader(Reader in, int sz) 
        // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
        BufferedReader br2 = new BufferedReader(new FileReader("D:\\aaa\\a.txt"),1024);

    }
}

 b：read方法 

package d8;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class BufferedReaderRead {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一：BufferedReader(Reader in)
        // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
        BufferedReader br = new BufferedReader(new FileReader("D:\\aaa\\a.txt"));
        int b = 0;
        while ((b = br.read()) != -1) {
            System.out.print((char) b);
        }

        // 方式二：BufferedReader(Reader in, int sz)
        // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
        BufferedReader br2 = new BufferedReader(new FileReader("D:\\aaa\\a.txt"), 1024);
        char[] by = new char[5];
        int len = 0;
        while ((len = br2.read(by, 0, 3)) != -1) {
            System.out.println(new String(by, 0, len));
        }
    }
}
/*
 * aaaa
 */

 

3.2 Writer

　　3.2.1 OutputStreamWriter

 

 a：构造方法

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class OutputStreamWriterGouZao {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 字符输出流：字节输出流+编码

        // 方式一:根据一个字节输出流 + 默认编码 得到一个字符输出对象
        // OutputStreamWriter(OutputStream out)
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"));

        // 方式二：根据一个字节输出流 + 指定编码 得到一个字符输出对象
        // OutputStreamWriter(OutputStream out, String charsetName)
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"), "utf-8");

    }
}

b: Write方法

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class OutputStreamWriterWrite {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一： 写入单个字符 write(int c)
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"));
        osw.write(97);
        osw.write('a');
        osw.close();

        // 方式二：写入字符数组。 write(char[] cbuf)
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\b.txt"), "utf-8");
        char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };
        osw2.write(che);
        osw2.flush();
        osw2.close();

        // 方式三：写入字符数组的某一部分。 write(char[] cbuf, int off, int len)
        OutputStreamWriter osw3 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\c.txt"));
        char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };
        osw3.write(che2, 2, 3);
        osw3.write("Hello world".toCharArray());
        
        osw3.close();

        // 方式四： 写入字符串 。 write(String str)
        OutputStreamWriter osw4 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\d.txt"), "utf-8");
        String str = "Hello World Java";
        osw4.write(str);
        osw4.flush();
        osw4.close();

        // 方式五： 写入字符串的某一部分。 write(String str, int off, int len)
        OutputStreamWriter osw5 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\e.txt"), "utf-8");
        String str2 = "Hello World Java";
        osw5.write(str2,3,4);
        osw5.flush();
        osw5.close();
    }
}

/*
 * aa
 * abcdef
 * cdeHello world
 * Hello World Java
 * lo W
 */

 3.2.2 FileWriter

 a:构造方法

package d8;

import java.io.File;
import java.io.FileNotFoundException;

import java.io.IOException;
import java.io.FileWriter;
import java.io.UnsupportedEncodingException;

public class FileWriterGouZao {
    public static void main(String[] args) throws FileNotFoundException, IOException {
 
        // 方式一: 根据给定的文件名值来构造 FileWriter 对象
        // FileWriter(String fileName) 
        FileWriter fw = new FileWriter("D:\\aaa\\a.txt");

        // 方式二： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
        // FileWriter(String fileName, boolean append) 
        FileWriter fw2 = new FileWriter(("D:\\aaa\\a.txt"),true);
        

        // 方式三: 根据给定的文件名值来构造 FileWriter 对象
        // FileWriter(File file) 
        FileWriter fw3 = new FileWriter(new File("D:\\aaa\\a.txt") );

        // 方式四： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
        //FileWriter(File file, boolean append) 
        FileWriter fw4 = new FileWriter(new File("D:\\aaa","a.txt"),true);

    }
}

b: Write方法

package d8;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class FileWriterWrite {
    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一: 根据给定的文件名值来构造 FileWriter 对象
        // FileWriter(String fileName)
        FileWriter fw = new FileWriter("D:\\aaa\\a.txt");
        // 方式一： 写入单个字符 write(int c)
        fw.write(97);
        fw.write('a');
        fw.close();
        
        
        // 方式二： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
        // FileWriter(String fileName, boolean append)
        FileWriter fw2 = new FileWriter(("D:\\aaa\\a.txt"), true);
        // 方式二：写入字符数组。 write(char[] cbuf)
        char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };
        fw2.write(che);
        fw2.flush();
        fw2.close();
        

        
        // 方式三: 根据给定的文件名值来构造 FileWriter 对象
        // FileWriter(File file)
        FileWriter fw3 = new FileWriter(new File("D:\\aaa\\b.txt"));
        // 方式三：写入字符数组的某一部分。 write(char[] cbuf, int off, int len)
        char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };
        fw3.write(che2, 2, 3);
        fw3.close();
        

        // 方式四： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
        // FileWriter(File file, boolean append)
        FileWriter fw4 = new FileWriter(new File("D:\\aaa", "b.txt"), true); 
        // 方式四： 写入字符串 。 write(String str)         
        String str = "Hello World Java";
        fw4.write(str);
        fw4.flush();
        fw4.close();
        

        // 方式一: 根据给定的文件名值来构造 FileWriter 对象
        // FileWriter(String fileName)
        FileWriter fw5 = new FileWriter("D:\\aaa\\c.txt");
        // 方式五： 写入字符串的某一部分。 write(String str, int off, int len)
        String str2 = "Hello World Java";
        fw5.write(str2, 3, 4);
        fw5.flush();
        fw5.close();
    }
}

/*
 *aaabcdef
 *cdeHello World Java
 *lo W
 */

 3.2.3 BufferedWwriter

 

 a:构造方法

package d8;


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterGouZao {
    public static void main(String[] args) throws  IOException {
 
        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out) 
        BufferedWriter bw = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"));

        // 方式二：  创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out, int sz)  
        BufferedWriter bw2 = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"),1024);
         
    }
}

b: Write方法

package d8;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class BufferedWriterWrite {
    public static void main(String[] args) throws FileNotFoundException, IOException {


        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out) 
        BufferedWriter bw = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"));
        // 方式一： 写入单个字符 write(int c)
        bw.write(97);
        bw.write('a');
        bw.close();
                
                
        // 方式二：  创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out, int sz)  
        BufferedWriter bw2 = new BufferedWriter( new FileWriter("D:\\aaa\\b.txt"),1024);
        // 方式二：写入字符数组。 write(char[] cbuf)
        char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };
        bw2.write(che);
        bw2.flush();
        bw2.close();

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out) 
        BufferedWriter bw3 = new BufferedWriter( new FileWriter("D:\\aaa\\c.txt"));
        // 方式三：写入字符数组的某一部分。 write(char[] cbuf, int off, int len)
        char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };
        bw3.write(che2, 2, 3);
        bw3.close();
        

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out) 
        BufferedWriter bw4 = new BufferedWriter( new FileWriter("D:\\aaa\\d.txt"));
        // 方式四： 写入字符串 。 write(String str)         
        String str = "Hello World Java";
        bw4.write(str);
        bw4.flush();
        bw4.close();
        

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
        // BufferedWriter(Writer out) 
        BufferedWriter bw5 = new BufferedWriter( new FileWriter("D:\\aaa\\e.txt"));
        // 方式五： 写入字符串的某一部分。 write(String str, int off, int len)
        String str2 = "Hello World Java";
        bw5.write(str2, 3, 4);
        bw5.flush();
        bw5.close();
    }
}

/*
 *aa
 *abcdef
 *cde
 *Hello World Java
 *lo W
 */

 

 3.3 练习

练习1:5中方法复制文本文件

package d8;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTxt {

    public static void main(String[] args) throws IOException {
        Long start = System.currentTimeMillis();
        method1();
        Long end = System.currentTimeMillis();
        System.out.println("方法一：耗时"+(end-start));
        Long start2 = System.currentTimeMillis();
        method2();
        Long end2 = System.currentTimeMillis();
        System.out.println("方法二：耗时"+(end2-start2));
        
        Long start3 = System.currentTimeMillis();
        method3();
        Long end3 = System.currentTimeMillis();
        System.out.println("方法三：耗时"+(end3-start3));
        
        Long start4 = System.currentTimeMillis();
        method4();
        Long end4 = System.currentTimeMillis();
        System.out.println("方法四：耗时"+(end4-start4));
        
        Long start5 = System.currentTimeMillis();
        method5();
        Long end5 = System.currentTimeMillis();
        System.out.println("方法五：耗时"+(end5-start5));

    }

    private static void method5() throws IOException {
        // Buffered 一次读取一个字符数组
        FileReader fr = new FileReader("D:\\aaa\\a.txt");
        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("--方法五，FileXXX 开始");
        bw.newLine();
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);;
        }
        bw.newLine();
        bw.write("--方法五，FileXXX 结束");
        bw.newLine();
        // 释放资源
        br.close();
        bw.close();
    }

    private static void method4() throws IOException {
        // Buffered 一次读取一个字符数组
        FileReader fr = new FileReader("D:\\aaa\\a.txt");
        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("--方法四，FileXXX 开始");
        bw.newLine();
        int len = 0;
        char[] ch = new char[5];
        while ((len = br.read(ch)) != -1) {
            bw.write(ch, 0, len);
        }
        bw.newLine();
        bw.write("--方法四，FileXXX 结束");
        bw.newLine();
        // 释放资源
        br.close();
        bw.close();
    }

    private static void method3() throws IOException {
        // Buffered 一次读取一个字符
        FileReader fr = new FileReader("D:\\aaa\\a.txt");
        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("--方法三，FileXXX 开始");
        bw.newLine();
        int i = 0;
        while ((i = br.read()) != -1) {
            bw.write((i));
        }
        bw.newLine();
        bw.write("--方法三，FileXXX 结束");
        bw.newLine();
        // 释放资源
        br.close();
        bw.close();
    }

    private static void method2() throws IOException {
        // File 一次读取一个字符数组
        FileReader fr = new FileReader("D:\\aaa\\a.txt");
        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
        fw.write("--方法二，FileXXX 开始");
        fw.write("\r\n");
        int len = 0;
        char[] ch = new char[5];
        while ((len = fr.read(ch)) != -1) {
            fw.write(ch, 0, len);
        }
        fw.write("\r\n");
        fw.write("--方法二，FileXXX 结束");
        fw.write("\r\n");
        // 释放资源
        fr.close();
        fw.close();
    }

    private static void method1() throws IOException {
        // File 一次读取一个字符
        FileReader fr = new FileReader("D:\\aaa\\a.txt");
        FileWriter fw = new FileWriter("D:\\aaa\\b.txt");
        fw.write("--方法一，FileXXX 开始");
        fw.write("\r\n");
        int i = 0;
        while ((i = fr.read()) != -1) {
            fw.write((i));
        }
        fw.write("\r\n");
        fw.write("--方法一，FileXXX 结束");
        fw.write("\r\n");
        // 释放资源
        fr.close();
        fw.close();

    }
/*
 * 方法一：耗时3
方法二：耗时2
方法三：耗时2
方法四：耗时1
方法五：耗时1

*
*
*
*--方法一，FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法一，FileXXX 结束
--方法二，FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法二，FileXXX 结束
--方法三，FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法三，FileXXX 结束
--方法四，FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法四，FileXXX 结束
--方法五，FileXXX 开始
aabbccddeeffgg
--方法五，FileXXX 结束
*/
}

 4:综合练习

1:复制单级文件夹

package d8;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopySingeFolder {
    public static void main(String[] args) throws IOException {
        // 需求：将单层文件夹例如：aaa文件下内容（只有文件）复制到bbb文件

        // 根据文件路径获取文件集合
        File srcFolder = new File("D:\\aaa");// 源文件
        File destFolder = new File("D:\\bbb");// 目标文件

        // 如果目标路径不存在,就创建,如果存在,就清空
        if (destFolder.exists()) {
            //清空文件夹
            clearFolder(destFolder);
        }
        destFolder.mkdir();
        // 获取源文件夹中的文件
        CopyFolder(srcFolder,destFolder);
        
        
    }

    //复制文件
    private static void CopyFolder(File srcFolder, File destFolder) throws IOException {
        File[] srcFiles = srcFolder.listFiles();
        if (srcFiles.length > 0) {            
            for (File file : srcFiles) {
                CopyFile(file,destFolder);
            }
        }
    }

     

    private static void CopyFile(File file, File destFolder) throws IOException {
        BufferedInputStream bis= new BufferedInputStream(new FileInputStream(file));
        String destName = file.getName();
        BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream(new File(destFolder,destName)));
        int len=0;
        byte [] by=new byte[1024];
        while ((len=bis.read(by))!=-1) {
            bos.write(by,0,len);
        }
        bos.close();
        bis.close();
    }

    //清空目标文件夹
    private static void clearFolder(File destFolder) {
        // TODO Auto-generated method stub
        File [] destFiles =destFolder.listFiles();
        if (destFiles!=null&&destFiles.length>0) {
            for (File file : destFiles) {
                file.delete();
            }
        }
        destFolder.delete();
    }
 
}

 2:复制文件

package d8;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyMultistageFolder {
    public static void main(String[] args) throws IOException {
        // 需求：文件夹复制

        // 根据文件路径获取文件集合
        File srcFolder = new File("D:\\aaa");// 源文件
        File destFolder = new File("D:\\bbb");// 目标文件

        // 如果目标路径不存在,就创建,如果存在,就清空
        if (destFolder.exists()) {
            //清空文件夹
            clearFolder(destFolder);
        }
        destFolder.mkdir();
        // 获取源文件夹中的文件
        CopyFolder(srcFolder,destFolder);
        
        
    }

    //复制文件
    private static void CopyFolder(File srcFolder, File destFolder) throws IOException {
        File[] srcFiles = srcFolder.listFiles();
        if (srcFiles.length > 0) {            
            for (File file : srcFiles) {
                if (file.isFile()) {
                    CopyFile(file,destFolder);
                }
                else if (file.isDirectory()) {
                    //创建一个文件夹
                    File newFolder = new File(destFolder.getAbsolutePath(),file.getName());// 目标文件
                    newFolder.mkdir();
                    CopyFolder(file,newFolder);
                }
            }
        }
    }

     

    private static void CopyFile(File file, File destFolder) throws IOException {
        BufferedInputStream bis= new BufferedInputStream(new FileInputStream(file));
        String destName = file.getName();
        BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream(new File(destFolder,destName)));
        int len=0;
        byte [] by=new byte[1024];
        while ((len=bis.read(by))!=-1) {
            bos.write(by,0,len);
        }
        bos.close();
        bis.close();
    }

    //清空目标文件夹
    private static void clearFolder(File destFolder) {
        //级联删除
        if (destFolder.isFile()||destFolder == null ) {
            destFolder.delete();
        }else if(destFolder.isDirectory()&&destFolder.listFiles().length<1) {
            destFolder.delete();
        }else {
            File [] destFiles =destFolder.listFiles();
            if (destFiles!=null&&destFiles.length>0) {
                for (File file : destFiles) {
                    clearFolder(file);
                }
            }
            destFolder.delete();
        }
        
        
        destFolder.delete();
    }
 
}

 3:模拟BufferedReader的readLine()+ BufferedWriter的newLine()+LineNumberReader的getLineNumber()和setLineNumber()

package d8;

import java.io.IOException;
import java.io.Reader;

public class MyBufferedReader {
    private Reader r;

    public MyBufferedReader(Reader r) {
         this.r =r;
    }

    public String readLine() throws IOException {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        while ((i = r.read()) != -1) {
            if (i == '\r') {
                continue;
            } 
            if (i == '\n') {
                return sb.toString();
            }else {
                sb.append((char)i);
            }
        }
        if (sb.toString().length()>0) {
            return sb.toString();
        }
        return null;
    }

    // close方法
    public void close() throws IOException {
        r.close();
    }
}

package d8;

import java.io.IOException;
import java.io.Writer;

public class MyBufferedWriter {
    //首先需要一個屬性Writer 
    private Writer w;
     //創建一個構造方法
    public MyBufferedWriter( Writer w) {
        this.w =w;
    }
    public void newLine () throws IOException {
        w.write('\r');
        w.write('\n');
    }
    public void write (String str) throws IOException {
        w.write(str);         
    }
    public void close() throws IOException {
        w.close();
    }
}

 

package d8;

import java.io.IOException;
import java.io.Reader;

public class MyLineNumberReader {
    private Reader r;
    private int lineNumber;
    public MyLineNumberReader(Reader r) {
         this.r =r;
    }

    public String readLine() throws IOException {
        lineNumber++;
        StringBuilder sb = new StringBuilder();
        int i = 0;
        while ((i = r.read()) != -1) {
            if (i == '\r') {
                continue;
            } 
            if (i == '\n') {
                return sb.toString();
            }else {
                sb.append((char)i);
            }
        }
        if (sb.toString().length()>0) {
            return sb.toString();
        }
        return null;
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }

    // close方法
    public void close() throws IOException {
        r.close();
    }
}

package d8;

import java.io.IOException;
import java.io.Reader;

public class MyLineNumberReader2 extends MyLineNumberReader {

    private Reader r;
    private int lineNumber;
    public MyLineNumberReader2(Reader r) {
        super(r); 
    }
    public String readLine() throws IOException {
        lineNumber++;
        return super.readLine();
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }
}

package d8;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class MyBufferedTest {
     public static void main(String[] args) throws IOException {
        MyBufferedReader mbr = new MyBufferedReader(new FileReader("D:\\aaa\\a.txt"));
        MyBufferedWriter mbw = new MyBufferedWriter(new FileWriter("D:\\aaa\\b.txt"));
        String line = "";
        while ((line = mbr.readLine())!=null) {
            System.out.println(line);
            mbw.write(line);
            mbw.newLine();
            mbw.write("哈哈");
            mbw.newLine();
        }
        mbr.close();
        mbw.close();
        
        MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader("D:\\aaa\\a.txt"));
        mlnr.setLineNumber(100);
        while ((line = mlnr.readLine())!=null) {
            System.out.println(mlnr.getLineNumber()+":"+line);
            }
        mlnr.close();
        
        MyLineNumberReader2 mlnr2 = new MyLineNumberReader2(new FileReader("D:\\aaa\\a.txt"));
        mlnr2.setLineNumber(10);
        while ((line = mlnr2.readLine())!=null) {
            System.out.println(mlnr2.getLineNumber()+":"+line);
            }
        mlnr2.close();
    }
}