本文主要是介绍JavaIO编程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

IO流

1.文件

1.1文件流

• 文件在程序中是以流的形式来操作的，
• 流：数据在数据源（文件）和程序（内存）之间经历的路径

1.2常用文件操作

创建文件相关构造器和方法

new File(String pathname)//根据路径构建一个File对象
new File(File parent,String child)//根据父目录文件+子路径构建
new File(String parent,String chile)//根据父目录+子路径构建

package IOstream;

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

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/28 9:02
 * @Version 1.0
 */
public class files {
    public static void main(String[] args) {
        files files = new files();
        files.create01();
        files.creat02();
    }

    public void create01(){
        String filePath = "F:\\test/news1.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void creat02(){
        File parentFile = new File("F:\\test/");
        String filename = "news.txt";
        File file = new File(parentFile, filename);
        try {
            file.createNewFile();
            System.out.println("创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void creat01(){
        String parentPath = "F:\\test/";
        new File("F:\\test/");
    }
}

获取文件的相关信息

package IOstream;

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

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/28 9:02
 * @Version 1.0
 */
public class filesCreat {
    public static void main(String[] args) {
        filesCreat files = new filesCreat();
        files.info();
    }
    public void info(){
        //创建文件路径
        File file = new File("F:\\test/news.txt");
        System.out.println(file.getName());//文件名称
        System.out.println(file.length());//文件大小（按照字节来计算）
        System.out.println(file.exists());//判断文件是否存在
        System.out.println(file.getAbsolutePath());//文件绝对路径
        System.out.println(file.getParent());//文件父级目录
        System.out.println(file.isFile());//判断是否是一个文件
        System.out.println(file.isDirectory());//判断是否是一个目录
    }
}

目录操作和文件删除

package IOstream;

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

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/28 9:02
 * @Version 1.0
 */
public class filesCreat {
    public static void main(String[] args) {
        filesCreat files = new filesCreat();
        files.m1();
        files.m2();

    }
    public void m1(){//判断文件是否存在，若是存在，则删除
        String filePath = "F:\\test/news.txt";
        File file = new File(filePath);
        if (file.exists()){
            System.out.println("文件存在，进行删除");
            if (file.delete()){
                System.out.println("删除成功！");
            }else {
                System.out.println("删除失败！");
            }
        }else {
            System.out.println("文件不存在");
        }

    }

    public void m2(){//判断目录是否存在，若是存在，则删除
        String filePath = "F:\\test";
        File file = new File(filePath);
        if (file.exists()){
            System.out.println("该目录存在，进行删除");
            if (file.delete()){
                System.out.println("删除成功！");
            }else {
                System.out.println("删除失败！");
            }
        }else {
            System.out.println("目录不存在");
        }

    }
}

2.IO流原理及流的分类

2.1Java IO流原理

• IO是Input和Output，I/O技术非常实用，用于处理数据传输，读/写文件，网络通讯等操作；

• java.io包提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据

• 输入input：读取外部数据到程序（内存）中；

• 输出output：将程序（内存）数据输出到磁盘，光盘等存储设备中

• 流的分类：

  • 字节流（8bit）、字符流
  • 输入流、输出流
  • 节点流、处理流/包装流

Java的IO 流涉及40多个类，都是由删除四个抽象类派生，这些子类名称都以其父类名作为子类名后缀

2.2InputStream字节输入流

FileInputStream：文件输入流

package IOstream;

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

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/29 10:28
 * @Version 1.0
 */
public class ioStream {
    public static void main(String[] args) {
        ioStream ioStream = new ioStream();
        ioStream.readFile01();
    }

    public void readFile01(){
        String filePath = "F:\\test/hello.txt";
        int readData;
        FileInputStream fileInputStream = null;//扩大作用于
        try {
            //创建FileInputStream对象，用户读取文件
            fileInputStream = new FileInputStream(filePath);
            while ((readData = fileInputStream.read()) != -1){//从输入流读取一个字节的数据，如果返回-1，就是到达文件末尾则读取截止
                System.out.print((char)readData);//将readData 转成 char类型 进行显示
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.3OutputStream：字节输出流

FileOutputStream：文件输出流

package IOstream;

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

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/29 10:28
 * @Version 1.0
 *
 * 将hello world写入文件中，如果文件不存在，则创建文件
 */
public class ioStream {
    public static void main(String[] args) {
        ioStream ioStream = new ioStream();
        ioStream.writeFile01();
    }

    public void writeFile01(){
        String filePath = "F:\\test/world.txt";
        //创建对象
        FileOutputStream fileOutputStream = null;
        try {
            /**
             * 覆盖
             * 追加
             */
            fileOutputStream = new FileOutputStream(filePath,true);//通过定义append的值来确定输入的形式是 覆盖 还是 追加
            //写入一个字节
//            fileOutputStream.write('a');
            //写入字符串
            String str = "hello world";
            fileOutputStream.write(str.getBytes());//getBytes()将字符串转换成字节数组


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4文件拷贝

package IOstream;

import java.io.*;

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/29 10:28
 * @Version 1.0
 *
 * 文件拷贝
 */
public class ioStream {
    public static void main(String[] args) {
        ioStream ioStream = new ioStream();
        ioStream.copyJpg();
    }

    public void copyJpg(){
        //创建文件路径
        String srcPath = "F:\\hhh.jpg";
        String destPath = "F:\\test/1.jpg";

        //创建文件输入流，将文件输入到程序
        //在完成程序时，通过循环操作，读取部分的数据就写入指定的文件
        FileInputStream fileInputStream = null;
        //创建文件输出流，将读取到的文件数据写入到指定文件
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream(srcPath);
            fileOutputStream = new FileOutputStream(destPath);
            //定义字节数组，提高读取效率
            byte[] buf = new byte[1024];
            int readlen = 0;//暂存值
            while ((readlen = fileInputStream.read(buf)) != -1){
                System.out.println("读取到1024的数据，进行写入");
                fileOutputStream.write(buf,0,readlen);
                System.out.println("拷贝成功");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

2.5 FileReader和FileWriter

FileReader和FileWriter是字符流，即按照字符来操作IO

FileReader相关方法

package IOstream;

import java.io.*;

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/29 10:28
 * @Version 1.0
 */
public class ioStream {
    public static void main(String[] args) throws IOException {
        ioStream ioStream = new ioStream();
        ioStream.read();
    }

    public void read() throws IOException {
        String filePath = "F:\\test/hello.txt";//创建文件路径
        FileReader fileReader = null;//创建对象

        try {
            fileReader = new FileReader(filePath);
            int data = 0;
            while ((data = fileReader.read())!= -1){//循环读取数据（单个字符读取）
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null){
                fileReader.close();
            }
        }
    }

}

package IOstream;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.*;

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/29 10:28
 * @Version 1.0
 */
public class ioStream {
    public static void main(String[] args) throws IOException {
        ioStream ioStream = new ioStream();
        ioStream.read();
    }

    public void read() throws IOException {
        String filePath = "F:\\test/hello.txt";//创建文件路径
        FileReader fileReader = null;//创建对象

        try {
            fileReader = new FileReader(filePath);
            int data = 0;
            char[] buf = new char[8];
            while ((data = fileReader.read(buf))!= -1){//使用字符数组读取文件
                System.out.print(new String(buf,0,data));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null){
                fileReader.close();
            }
        }
    }

}

FileWriter相关方法

package IOstream;


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

@SuppressWarnings({"all"})
/**
 * @Author Blueshadow
 * @Date 2021/7/29 10:28
 * @Version 1.0
 */
public class ioStream {
    public static void main(String[] args) {
        ioStream ioStream = new ioStream();
        ioStream.write();
    }

    public void write(){
        String filePath = "F:\\test/hello.txt";
        FileWriter fileWriter = null;
        char[] abc = {'a','c','c'};
        try {
            fileWriter = new FileWriter(filePath);
            fileWriter.write('h');//写入单个字符
            fileWriter.write(abc);//写入指定数组
            fileWriter.write("hello world".toCharArray(),0,5);//写入指定数组的指定部分
            fileWriter.write(" hello world");//写入字符串
            fileWriter.write("你好 世界",0,2);//写入指定字符串的指定部分
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

2.6节点流和处理流

节点流可以从一个特定的数据源读写数据，如FileReader,FileWriter。

处理流（也叫包装流），是“连接”已经存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader,BufferedWriter。

这篇关于JavaIO编程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！