I/O相关　　　　　输入/输出　　流(数据流动)
数据流动的方向　读数据(输入Input)　写数据(输出output)
文件流　字符流　对象流　网络流…

File(文件)

一种电脑的存储形式
文件有不同的格式 .txt .doc .ppt .mp4 .jpg .rar …
文件夹?----目录路径
File----->与电脑上的文件或文件夹产生一一对应的映射关系
File是一个类

java.io包中
文件或目录路径名的抽象表示形式
File与真实硬盘中的文件或文件夹不是一个东西
　　File是在内存中的一个对象<—映射—>硬盘上的文件或文件夹
File类中的常用的方法
　　canRead()
　　canWrite()
　　isHidden()
　　isFile()
　　isDirectory()
　　length()　　　　获取文件中字节的个数
　　lastModified()　获取文件最后的修改时间—>毫秒值
　　*String path = getAbsolutePath() 获取文件的绝对路径 D://test//Test.txt
　　　绝对路径<---->相对路径
　　　绝对路径可以通过完整的字符串定位盘符文件夹文件
　　　相对路径没有盘符的写法　　　　当前工程(项目)所在的位置找寻
　　　　　C:\Users\Administrator\IdeaProjects\TestFile
　　String name = getName()　　　获取文件的名字 Test.txt
　　*boolean = createNewFile() 　　创建新的文件
　　*boolean = mkdir　　　　　创建新的文件夹外层没有不能创建
　　*boolean = mkdirs　　　　　创建新的文件夹外层没有可以自动创建
　　String pname = getParent()　　　获取当前file的父亲file名字
　　*File file = getParentFile() 　获取当前file的父亲file对象
　　String[] names = list()　　　　获取当前file的所有儿子名字
　　*File[] files = listFiles()　　　获取当前file的所有儿子对象
　　*boolean = delete() 删除文件或空的文件夹不能删除带元素的文件夹
　　文件的遍历和删除

文件流

流按照方向(功能)来区分
　in读取文件中的内容　　　 out(写入)向文件中写内容
　文件输入流　　　　　　　文件输出流
　字节型文件输入流　　　　字节型文件输出流
　字符型文件输入流　　　　字符型文件输出流

文件流示意图

操作的目标来区分
　文件流　数组流　字符串流　数据流　对象流　网络流。。。。

字节型文件流(1字节)

FileInputStream/FileOutputStream

字节型文件输入流 FileInputStream

包 java.io
了解一下继承关系 InputStream类字节型输入流的父类
创建对象
　　调用一个带File类型的构造方法
　　调用一个带String类型的构造方法
常用方法
　　int code = read();　每次从流管道中读取一个字节　　返回字节的code码
　　*int count = read(byte[] ) 　每次从流管道中读取若干个字节　存入数组内　返回有效元素个数
　　int count = available(); 返回流管道中还有多少缓存的字节数
　　skip(long n)　跳过几个字节　读取
　　　多线程—>利用几个线程同时读取文件
　　　10000字节　　5个小人同时读取
　　　1-2000　2001-4000　4001-6000　6001-8000　8001-10000
　　　D当做服务器 E当做客户端
　　　*close()　将流管道关闭—必须要做　最好放在finally里注意代码的健壮性判断严谨

字节型文件输出流 FileOutputStream

FileOutputStream　将数据写入文件中

java.io
继承OutputStream 所有字节型输出流的父类
创建对象
　　调用一个带File参数　　　还有File boolean重载
　　调用一个带String参数　　还有String boolean重载
　　带boolen的值为true表示追加的意思
常用方法
　　write(int code);　　将给定code对应的字符写入文件 ‘=’
　　write(byte[])　　　将数组中的全部字节写入文件 getByte()
　　flush();　　　　　将管道内的字节推入(刷新)文件
　　close();　　　　　注意在finally中关闭

字符型文件流(2字节–1字符)

FileReader　　　　FileWriter
只能操作纯文本文件(文件右键打开方式记事本打开能看懂)

FileReader 输入流

java.io包
继承　InputStreamReader　Reader
构造方法
常用
　　read()
　　read(char[])

FileWriter 输出流

java.io包
继承 OutputStreamWriter Writer
构造方法
　　带file参数　　带file,boolean参数
　　带String参数　带String,boolean参数
　　带boolen的值为true表示追加的意思
常用
write(int)
write(char[])
write(string)
flush close

缓冲流

在流管道内增加缓存的数据
让我们使用流读取的文字更加的流畅
高级流—>创建通过低级流
　　BufferedInputStream/BufferedOutputStream
　　BufferedReader/BufferedWriter
缓冲流示意图

BufferedInputStream

构建方式使用低级流构建
基本使用与低级流的方法完全一致
read()
skip()
available()
close()

BufferedOutputStream

构建方式使用低级流构建注意缓冲流构建的时候没有boolean类型的参数
基本使用与低级流的方法完全一致
write()
flush()
close()

import java.io.*;

public class TestBufferedStream {

    public static void main(String[] args){
        try {
            //创建一个流  string  file
            File file = new File("D://test//Test.txt");
            FileInputStream fis = new FileInputStream(file);
            BufferedInputStream bis = new BufferedInputStream(fis);
            bis.read(int);
            bis.read(byte[])
            bis.available();
            bis.skip(long);
            bis.close();

            FileOutputStream fos = new FileOutputStream("",true);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            bos.write(int);
            bos.write(byte[]);
            bos.flush();
            bos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

BufferedReader

String value = readLine();

BufferedWriter

write(String)
newLine()

import java.io.*;

public class TestBufferedReaderAndWriter {

    //设计一个方法  用来用户登录认证
    public String login(String username,String password){
        //真实的名字和密码 永久的存在数据库---->数据持久化
        //文件我们采用.txt形式的纯文本   文本中的内容  以行为单位  每一行记录一个人的信息
        try {
            BufferedReader br = new BufferedReader(new FileReader("D://test//User.txt"));
            String user = br.readLine();//user表示一行记录  记录着账号和密码 郑中拓-123
            while(user!=null){
                System.out.println("找到信息了么");
                //将user的信息 按照-拆分  分别与方法的参数进行比较
                String[] value = user.split("-");//value[0]账号  value[1]密码
                System.out.println(value.length);
                System.out.println(value[0]+"---"+username);
                if(value[0].equals(username)){
                    System.out.println("名字对啦");
                    if(value[1].equals(password)){
                        return "登录成功";
                    }
                }
                user = br.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "用户名或密码错误";
    }

    public static void main(String[] args){
/*        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("D://test//User.txt",true));
            bw.newLine();
            bw.write("Java-888");
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }*/


/*        TestBufferedReaderAndWriter test = new TestBufferedReaderAndWriter();
        String result = test.login("渡一教育","666");
        System.out.println(result);

        try {
            //创建一个字符形式的缓冲流  输入流  读取文件
            FileReader fr  = new FileReader("D://test//User.txt");
            BufferedReader br = new BufferedReader(fr);
            String value = br.readLine();//读取文件中一行的信息   read  int
            while(value!=null){
                System.out.println(value);
                value = br.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }*/





        try {
            //创建字符输入流  file  String
            File file = new File("D://test//Test.txt");
            FileReader fr = new FileReader(file);
            BufferedReader br = new BufferedReader(fr);
            int code = br.read();
            System.out.println(code);//65279
            while(code!=-1) {
                System.out.print((char)code);
                code = br.read();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

对象流

import java.io.*;

public class TestObjectStream {

    public static void main(String[] args){
//        try {
//            //将对象直接记录在文件中
//            //对象的序列化
//            Person p1 = new Person("郑中拓",18);
//            //对象输出流
//            FileOutputStream fos = new FileOutputStream("D://test//Person.txt");
//            ObjectOutputStream oos = new ObjectOutputStream(fos);//高级流
//            oos.writeObject(p1);//将对象拆分成字节碎片  序列化到文件里
//            oos.flush();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }

        //需要一个对象输入流
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D://test//Person.txt"));
            Person p = (Person)ois.readObject();
            System.out.println(p);
            p.eat();//EOFException说明没有对象  通常会将所有记录的对象存在一个集合
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}

import java.io.Serializable;

public class Person implements Serializable {

    private long serialVersionUID = -440948515215806088L;
    private String name;
    private int age;

    public Person(){}
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String toString(){
        return "{"+this.name+","+this.age+"}";
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public void eat(){
        System.out.println(this.name+"的吃饭方法");
    }
}

对比

		File
		InputStream	OutputStream
		Reader		Writer

*文件流
	低级
		字节型	FileInputStream  FileOutputStream
		字符型	FileReader  FileWriter	字符集65279
	*缓冲
		字节型	BufferedInputStream  BufferedOutputStream
		字符型	BufferedReader	BufferedWriter
数组流
	byte数组		ByteArrayInputStream	ByteArrayOutputStream
	char数组		CharArrayReader		CharArrayWriter
数据流			DataInputStream		DataOutputStream
字符串流			StringReader		StringWriter
*对象流			ObjectInputStream		ObjectOutputStream

来源：CSDN

作者：萧李

链接：https://blog.csdn.net/qq_37710756/article/details/104024446

标签

绝对路径

io流

IO流