IO操作,io操作是指什么

摘要：

=null){fileReader.close();}}catch{e.printStackTrace();}}}/***模拟一个文件拷贝**/privatestaticvoidcopy(){FileWriterfileWriter=null;FileReaderfileReader=null;try{fileWriter=newFileWriter;fileReader=newFileReader;//字符数组方式读取char[]buff=newchar[1024];intlen=0;while((len=fileReader.read(buff))!=-1){fileWriter.write;fileWriter.flush();System.out.println;}//逐个字符读取//intch=0;//while((ch=fileReader.read())!

IO流

1.IO用来处理设备之间的数据传输
2.Java对数据的操作通过流的方式
3.Java用于操作流的对象都在IO中
4.流操作数据分两种，字节流和字符流
5.流按流向可以分为：输入流和输出流

IO流常用基类

字节流的抽象基类
InputStream OutputStream

字符流的抽象基类
Reader Writer

注：由这四个派生出来额子类名称都是以其父类作为子类名的后缀

packagecn.soldier.oop;

importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;

public classFileWriteAndReadDemo {
    private static String filePath = "E:\ProgramCode\demo.txt";

    public static voidmain(String[] args) {
        //标准的文件流输出处理
write();

        //标准的文件流读入处理
read();

        //模拟一个文件拷贝
copy();

    }

    /*** 标准的文件流输出处理
     * */
    private static voidwrite() {
        FileWriter fileWriter = null;
        try{
            //为true时追加写入字符
            fileWriter = new FileWriter(filePath, true);
            fileWriter.write("呵呵");
            fileWriter.flush();
        } catch(IOException e) {
            e.printStackTrace();
        } finally{
            try{
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }

    /*** 标准的文件流读入处理
     */
    private static voidread() {
        FileReader fileReader = null;
        try{
            fileReader = newFileReader(filePath);
            char[] buff = new char[5];
            try{
                int num = 0;
                //读取字符数组，每次读的个数是字符数组的长度，如果有足够的字符的话。
                while ((num = fileReader.read(buff)) != -1) {
                    System.out.println("num=" + num + "..."
                            + new String(buff, 0, num));
                }
                //逐个字符读取
                //int ch = 0;
                //while ((ch = fileReader.read()) != -1) {
                //System.out.println((char) ch);
                //}
            } catch(IOException e) {
                e.printStackTrace();
            }
        } catch(FileNotFoundException e) {
            e.printStackTrace();
        } finally{
            try{
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }

    /*** 模拟一个文件拷贝
     * */
    private static voidcopy() {
        FileWriter fileWriter = null;
        FileReader fileReader = null;
        try{
            fileWriter = new FileWriter("FileWriteAndReadDemo.txt", true);
            fileReader = newFileReader(
                    "E:\ProgramCode\Java\MyEclipse 10\oop\src\cn\soldier\oop\FileWriteAndReadDemo.java");

            //字符数组方式读取
            char[] buff = new char[1024];
            int len = 0;
            while ((len = fileReader.read(buff)) != -1) {
                fileWriter.write(buff, 0, len);
                fileWriter.flush();
                System.out.println(len + "");
            }

            //逐个字符读取
            //int ch = 0;
            //while ((ch = fileReader.read()) != -1) {
            //fileWriter.write(ch);
            //fileWriter.flush();
            //}
            System.out.println("读完了");

        } catch(IOException e) {
            e.printStackTrace();
        } finally{
            try{
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
            try{
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }

        }
    }

}

fileRead fileWrite

packagecn.soldier.oop;

importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;

public classBufferedWriterAndReaderDemo {
    private static String filePath = "E:\ProgramCode\demo.txt";

    public static voidmain(String[] args) {
        buffWrite();
        buffRead();
        buffCopy();
    }

    private static voidbuffCopy() {
        FileWriter fileWriter = null;
        BufferedWriter bufw = null;
        FileReader fileReader = null;
        BufferedReader bufr = null;

        try{
            fileWriter = new FileWriter("BufferedWriterAndReaderDemo.txt");
            bufw = newBufferedWriter(fileWriter);
            fileReader = newFileReader(
                    "E:\ProgramCode\Java\MyEclipse 10\oop\src\cn\soldier\oop\BufferedWriterAndReaderDemo.java");
            bufr = newBufferedReader(fileReader);

            String line = null;

            while ((line = bufr.readLine()) != null) {
                bufw.write(line);
                bufw.newLine();
                bufw.flush();
            }
            System.out.println("end the copy");

        } catch(IOException e) {
            e.printStackTrace();
        } finally{
            try{
                if (bufr != null) {
                    bufr.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }

            //关闭缓冲区就是关闭流
            try{
                if (bufw != null) {
                    bufw.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
        }

    }

    private static voidbuffRead() {
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        try{
            fileReader = newFileReader(filePath);
            bufferedReader = newBufferedReader(fileReader);

            String line = null;
            try{
                while ((line = bufferedReader.readLine()) != null) {
                    System.out.println(line);
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
        } catch(FileNotFoundException e) {
            e.printStackTrace();
        } finally{
            if (bufferedReader != null) {
                try{
                    bufferedReader.close();
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static voidbuffWrite() {
        FileWriter fileWriter = null;
        BufferedWriter bufw = null;
        try{
            fileWriter = newFileWriter(filePath);

            bufw = newBufferedWriter(fileWriter);

            for (int i = 1; i <= 1024; i++) {
                bufw.write('c');
                if (i % 100 == 0) {
                    bufw.newLine();
                }
            }

            bufw.flush();
            System.out.println("写入结束");
        } catch(IOException e) {
            e.printStackTrace();
        } finally{
            //关闭缓冲区就是关闭流
            if (bufw != null) {
                try{
                    bufw.close();
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

buff

装饰设计模式，
当想要对已有的对象进行功能增强时，
可以自定义类，将已有的对象传入，基于已有的功能，并提供增强工功能。
那么自定义的该类成为装饰类。

装饰模式和继承的区别
装饰模式比继承要灵活，避免了继承体系的臃肿。而且降低了类与类之间的关系。。
装饰类因为增强已有对象，具备的功能和已有的相同，只不过提供了更强的功能。
所以装饰类和被装饰类通常都是属于同一个体系中的。

/*****************************************************************************************************/

字符流读写

packagecn.soldier.oop;

importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;

public classInputAndOutputStream {
    private static final String filePath = "OutputStream.txt";

    public static void main(String[] args) throwsFileNotFoundException,
            IOException {
        //output();
        //input();
        //copy();
        //buffOutput();
        //buffInput();
        //buffCoyp();
}

    private static void buffCoyp() throwsFileNotFoundException, IOException {
        BufferedInputStream bis = newBufferedInputStream(
                newFileInputStream(
                        "E:\ProgramCode\Java\MyEclipse 10\oop\bin\cn\soldier\oop\个人.jpg"));

        BufferedOutputStream bos = newBufferedOutputStream(
                new FileOutputStream("个人.jpg"));

        int len = 0;
        while ((len = bis.read()) != -1) {
            bos.write(len);
        }
        System.out.println("拷贝结束");

        try{
            if (bis != null) {
                bis.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
        try{
            if (bos != null) {
                bos.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

    private static void buffInput() throwsFileNotFoundException, IOException {
        BufferedInputStream bis = new BufferedInputStream(newFileInputStream(
                filePath));

        byte[] buff = new byte[100];
        int len = 0;
        while ((len = bis.read(buff)) != -1) {
            System.out.println(new String(buff, 0, len));
        }
        try{
            if (bis != null) {
                bis.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }

    }

    private static void buffOutput() throwsFileNotFoundException, IOException {
        BufferedOutputStream bos = newBufferedOutputStream(
                newFileOutputStream(filePath));
        for (int i = 0; i < 1000; i++) {
            bos.write('f');
        }
        bos.flush();
        System.out.println("输出结束");
        try{
            if (bos != null) {
                bos.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

    private static void copy() throwsFileNotFoundException, IOException {

        FileInputStream fis = newFileInputStream(
                "E:\ProgramCode\Java\MyEclipse 10\oop\bin\cn\soldier\oop\个人.jpg");
        FileOutputStream fos = new FileOutputStream("个人.jpg");
        byte[] buff = new byte[1024];
        int len = 0;
        while ((len = fis.read(buff)) != -1) {
            fos.write(buff, 0, len);
            System.out.println(len);
        }
        System.out.println("输出完成");

        try{
            if (fis != null) {
                fis.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
        try{
            if (fos != null) {
                fos.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

    private static void input() throwsFileNotFoundException, IOException {
        FileInputStream fis = newFileInputStream(filePath);
        //读取到字节数组
        byte[] buff = new byte[1024];
        int len = 0;
        while ((len = fis.read(buff)) != -1) {
            System.out.println(new String(buff, 0, len));
        }
        //逐个字节读取
        //int ch = 0;
        //while ((ch = fin.read()) != -1) {
        //System.out.println(ch);
        //}
        try{
            if (fis != null) {
                fis.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

    private static void output() throwsFileNotFoundException, IOException {
        FileOutputStream fos = newFileOutputStream(filePath);
        fos.write("呵呵".getBytes());
        fos.flush();
        System.out.println("输出完成");
        try{
            if (fos != null) {
                fos.close();
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream InputStream

转换流 system.in system.out

packagecn.soldier.oop;

importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.OutputStreamWriter;

public classSystemIn {
    public static void main(String[] args) throwsIOException {

        //method();
        //简写
method1();
    }

    private static void method() throwsIOException {
        InputStream in =System.in;
        //
        InputStreamReader isr = newInputStreamReader(in);
        //
        BufferedReader bufr = newBufferedReader(isr);
        //
        OutputStream out =System.out;
        //
        OutputStreamWriter osw = newOutputStreamWriter(out);
        //
        BufferedWriter bufw = newBufferedWriter(osw);

        String line = null;
        while ((line = bufr.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            } else{
                bufw.write(line);
                bufw.flush();
                bufw.newLine();
            }
        }
        in.close();
    }

    private static void method1() throwsIOException {
        BufferedReader bufr = new BufferedReader(newInputStreamReader(
                System.in));
        //
        BufferedWriter bufw = new BufferedWriter(newOutputStreamWriter(
                System.out));
        //
        String line = null;
        while ((line = bufr.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            } else{
                bufw.write(line);
                bufw.newLine();
                bufw.flush();
            }
        }
    }
}

System in out

File类
用来将文件或者文件夹封装成对象。
方便对文件与文件夹操作
file对象可以作为参数传递给流的构造函数。

packagecn.soldier.oop;

importjava.io.BufferedWriter;
importjava.io.File;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.util.ArrayList;
importjava.util.List;

public classFileDemo {
    public static voidmain(String[] args) {
        File dir = new File("G:\cj2");
        //showDir(dir, 0);
        //removeDir(dir);
List<File> list = new ArrayList<File>();
        fileTolist(dir, list);
        writeToFile(list, "G:\cj2\path.txt");
    }

    public static String getLevel(intlevel) {

        StringBuilder sb = newStringBuilder();
        sb.append("|--");
        for (int i = 0; i < level; i++) {
            sb.insert(0, "|  ");
        }
        returnsb.toString();
    }

    public static void showDir(File dir, intleverl) {
        System.out.println(getLevel(leverl) +dir.getName());
        leverl++;
        File[] files =dir.listFiles();
        for (int i = 0; i < files.length; i++) {

            if(files[i].isDirectory()) {
                showDir(files[i], leverl);
            } else{
                System.out.println(getLevel(leverl) +files[i]);
            }
        }
    }

    public static voidremoveDir(File dir) {
        File[] files =dir.listFiles();
        for (int i = 0; i < files.length; i++) {
            if(files[i].isDirectory()) {
                removeDir(files[i]);
            } else{
                System.out.println(files[i].toString() + "::"
                        +files[i].delete());
            }
            System.out.println(dir + "::" +dir.delete());
        }
    }

    public static void fileTolist(File dir, List<File>list) {
        File[] files =dir.listFiles();
        for(File file : files) {
            if(file.isDirectory()) {
                fileTolist(file, list);
            } else{
                if (file.getName().endsWith(".java")) {
                    list.add(file);
                }
            }
        }
    }

    public static void writeToFile(List<File>list, String filePath) {

        BufferedWriter bufw = null;
        try{
            bufw = new BufferedWriter(newFileWriter(filePath));
            for(File file : list) {
                String path =file.getAbsolutePath();
                bufw.write(path);
                bufw.newLine();
                bufw.flush();
            }
        } catch(IOException e) {
        } finally{
            try{
                if (bufw != null) {
                    bufw.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

File

Properties 配置文件

packagecn.soldier.oop;

importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.util.Properties;

public classPropertiesDemo {

    public static void main(String[] args) throwsIOException {
        Properties prop = newProperties();

        File file = new File("count.ini");
        if (!file.exists())
            file.createNewFile();

        FileInputStream fis = newFileInputStream(file);
        prop.load(fis);

        int count = 0;
        String value = prop.getProperty("times");
        if (value != null) {
            count =Integer.parseInt(value);
        }
            //
System.out.println(count);
            count++;
            prop.setProperty("times", count+"");
            
            FileOutputStream fos = newFileOutputStream(file);
            prop.store(fos, "");
            fos.close();
            fis.close();

    }

}

Properties

免责声明：文章转载自《IO操作》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

IO操作

相关文章

WebBench简介

springcloud-服务发现Discovery

springCloud 后端使用webSocket向前端推送消息

音频拼接的简单实现方法（python一种，java两种）

让程序在崩溃时体面的退出转

Java 反射原理

最新文章

随机推荐

思享工具箱导航

JSON工具

格式化转换

加解密编码

文本数字

网络

站长

计算

其他

对照列表