A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

一、IO流
IO:上传下载,写入写出
        流: 一连串流动的数据,以先入先出的方式进行流动,管道,以程序为中心、程序与网络|文件|服务器|数组..
1.分类
1)按照流向:
                输入流:
                输出流:
2)操作单元分:
                字节流 (万能流):任何内容都可以转为字节,可以传输文本,图片,音频...
                字符流 :只能操作纯文本数据
3)按照功能:
                节点流 : 包裹源头,实现基本功能

2.字节流:
1)节点流
        (1)字节输入流 : InputStream         此抽象类是表示字节输入流的所有类的超类
                        FileInputStream                从文件系统中的某个文件中获得输入字节

//字节流输入 InputStream
//导包        导包快捷键: ctrl+shift+o
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo01 {
        public static void main(String[] args) throws IOException {
                //FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定
                //FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定
                InputStream is=new FileInputStream(new File("D:/test.txt"));//创建D盘符的根目录下的文件
                System.out.println(is);
                //方式1: int read() 读入数据 一个字节一个字节读入
                /*int num=is.read();
                System.out.println((char)num);
                num=is.read();
                System.out.println((char)num);
                System.out.println((char)(is.read()));*/
                //方式2:使用循环,循环读入,可以简化代码,重复代码只写一次,但还是一个字节一个字节的读入
                /*int num=-1;
                while((num=is.read())!=-1){
                        System.out.println((char)num);
                }*/
                //方式3:int read(byte[] b) 一个字节数组一个字节数组的读入
                //返回值: 返回读入到字节数组中数据的个数,没有读到返回-1
                byte[] car=new byte[1];
                //int len=is.read(car);
                int len=-1;
                while((len=is.read(car))!=-1){
                        System.out.println(new String(car,0,len));
                }
                //关闭
                is.close();
        }
}

        (2)字节输出流: OutputStream           此抽象类是表示输出字节流的所有类的超类
                        FileOutputStream                  文件输出流是用于将数据写入 File 的输出流

//字节输出流 OutputStream
//导包        导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo02 {
        public static void main(String[] args) {
                //FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流
                //FileOutputStream(String name,boolean append)  创建一个向具有指定 name 的文件中写入数据的输出文件流
                //FileOutputStream(File file,boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流
                //boolean append        返回值:true追加,false不追加(默认false)
                OutputStream os=null;
                //try...catch(){}        捕捉异常,处理异常
                try {
                        //1.选择流
                        os=new FileOutputStream("D:/hhh.txt",hhtrue); //文件不存在,系统会自动帮我们创建,但文件夹不会
                        //2.准备数据
                        String str="要好好学习,天天向上...";
                        byte[] c和=str.getBytes();
                        //3.写出 void write(byte[] b)  
                        os.write(ch);
                        //4.刷出
                        os.flush();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                } finally{
                        //5.关闭
                        try {//预防空指针异常
                                if(os!=null){
                                        os.close();
                                }
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }
}

3.字符流:
只能操作纯文本
1)节点流:
        (1)字符输入流:Reader         读取字符流的抽象类
                        FileReader                 用来读取字符文件的便捷类

//字符输入流 Reader
//导包        导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo03 {
        public static void main(String[] args) {
                //FileReader(String fileName)
                Reader rd=null;
                try {
                        //1.选择流
                        rd=new FileReader("D:/hehe.txt");//创建D盘符的根目录下的文件
                        //2.读入
                        //方法1:int read() 读取单个字符。
                        /*System.out.println((char)rd.read());
                        System.out.println((char)rd.read());
                        System.out.println((char)rd.read());
                        System.out.println((char)rd.read());*/
                        int len=-1;  //存储读到的数据  如果为-1,证明已达到末尾
                        //方法2:
                        /*while(-1!=(len=rd.read())){
                                System.out.println((char)len);
                        }*/
                        //方法3:int read(char[] cbuf)  将字符读入数组。
                        char[] car=new char[1024];
                        while((len=rd.read(car))!=-1){
                                System.out.println(new String(car,0,len));
                        }
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                } finally{
                        if(rd!=null){
                                try {
                                        //关闭功能
                                        rd.close();
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }
                }

        }
}

        (2)字符输出流: Writer         写入字符流的抽象类
                        FileWriter                用来写入字符文件的便捷类
1
2
//字符输出流:Writer
//导包        导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class CharDemo02 {
        public static void main(String[] args) {
                //FileWriter(File file)                                                                 //默认不追加
                //FileWriter(File file, boolean append)         
                //FileWriter(String file)  
                //FileWriter(String file, boolean append)  
                Writer rt=null;
                try {
                        //1.选择流
                        rt=new FileWriter("D:/houhou.txt",true);
                        //2.写出
                        /*        void write(char[] cbuf)  写入字符数组
                                void write(char[] cbuf, int off, int len) 写入字符数组的某一部分
                                void write(int c) 写入单个字符
                                void write(String str)  写入字符串
                                void write(String str, int off, int len) 写入字符串的某一部分
                        */
                        rt.write(97);
                        rt.write("\r\n");                                                                  //换行
                        rt.write("你真好看!!!!");
                        rt.write("\r\n");
                        rt.write("你真好看!!!!",2,2);
                        rt.write("\r\n");
                        char[] ch={'a','b','c','d','e'};
                        rt.write(ch);
                        rt.write("\r\n");
                        rt.write(ch,2,3);
                        //3.刷出
                        rt.flush();               
                } catch (IOException e) {
                        e.printStackTrace();
                } finally{
                        //4.关闭
                        if(null!=rt){
                                try {
                                        rt.close();
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
}

4.功能流(节点流):
        缓冲流: 增强功能,提高性能,加快读写效率
1)字节流:
        BufferedInputStream         字节输入流缓冲流
        BufferedOutputStream         字节输出流缓冲流
                没有新增方法,可以发生多态使用

//导包
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.InputStream;
import java.io.OutputStream;

public class BufferedInputStream01 {
        public static void main(String[] args) throws IOException {
                //1.选择流
                //BufferedInputStream(InputStream in)
                InputStream is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
                OutputStream os=new BufferedOutputStream(new FileOutputStream("E:/hengheng.txt") );
                //2.读写
                byte[] car=new byte[1024];
                int len=-1;
                while((len=is.read(car))!=-1){
                        os.write(car,0,len);
                }
                //3.刷出
                os.flush();
                //4.关闭
                os.close();
                is.close();
        }
}

2)字符流:       
        BufferedReader        字符输入流缓冲流                       
                        新增方法:        String readLine()        读取一个文本行
        BufferedWriter        字符输出流缓冲流
                        新增方法:        void newLine()                写入一个行分隔符

//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedReader02 {
        public static void main(String[] args) throws IOException {
                //1.选择流  导包快捷键: ctrl+shift+o
                BufferedReader br=new BufferedReader(new FileReader("D:/hehe.txt"));
                BufferedWriter bw=new BufferedWriter(new FileWriter("D:/ccc.txt"));
                //2.读写
                String msg=null;
                while((msg=br.readLine())!=null){
                        bw.write(msg);
                        bw.newLine();
                }
                //3.刷出
                bw.flush();
                //4.关闭
                bw.close();
                br.close();
        }
}

5.Data流(字节节点流)
Data流(字节节点流):
        读写基本数据类型+String类型数据,是字节流功能流的一种
                DataInputStream                新增方法: readXxx()
                DataOutputStream         新增方法: writeXxx()
        存在新增方法不能发生多态,先写出再写入
可能碰到的异常:EOFException 文件有,内容读入不到,必须读入的是写出的源文件

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Data01 {
        public static void main(String[] args) throws IOException {
                //调用方法
                write("D:/data.txt");
                read("D:/data1.txt");
        }
        //读入
        public static void read(String path) throws IOException{
                //1.输入流 数据类型+数据
                DataInputStream in=new DataInputStream(new  BufferedInputStream(new FileInputStream(path)));
                //2.读入
                int i=in.readInt();
                boolean b=in.readBoolean();
                String s=in.readUTF();
                System.out.println(i+"-->"+b+"-->"+s);
                //3.关闭
                in.close();
        }
        //写出
        public static void write(String path) throws IOException{
                //1.输出流
                DataOutputStream out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
                //2.准备数据
                int i=101;
                boolean f=false;
                String s="哈哈";
                //3.写出  写出和读入的顺序要保持一致
                out.writeInt(i);
                out.writeBoolean(f);
                out.writeUTF(s);
                //4.刷出
                out.flush();
                //5.关闭
                out.close();
        }
}

6.对象流:
Object 保存数据类型+数据
        字节的功能流:当想要传输|读写对象类型数据的时候,可以使用一个对象流
        序列化: 把对象类型的数据转化为可存储|可传输的状态的过程
                ObjectInputStream()    反序列化输入流   新增方法: readObject()
                ObjectOutputStream()   序列化输出流       新增方法: writeObject()
注意:
        1)先序列化后反序列化
        2)序列化反序列读写顺序一致
        3)不是所有的类都能序列化                 java.io.Serializable 空接口
        4)不是所有的属性都需要序列化                 transient
        5)static内容不会被序列化
        6)如果父类实现Serializable接口,子类中可以序列化所有内容
如果子类实现Serializable接口,但是父类没有实现,子类只能序列化子类独有的内容

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;
public class ObjectDemo02 {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
                write("D:/object.txt");
                read("D:/object.txt");
        }
        //反序列化输入
        public static void read(String path) throws IOException, ClassNotFoundException{
                //1.输入流
                ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
                //2.读入
                Object p= is.readObject();
                int[] arr= (int[]) is.readObject();
                if(p instanceof Person){
                        Person person=(Person)p;
                        System.out.println(person.getName());
                }
                System.out.println(p);
                System.out.println(Arrays.toString(arr));
                //3,关闭
                is.close();
        }
        //序列化输出
        public static void write(String path) throws IOException{
                //1.输出对象信息
                ObjectOutputStream os=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
                //2.准备数据
                Person p=new Person("aaa",18);
                int[] arr={1,2,3,4};
                //3.输出
                os.writeObject(p);
                os.writeObject(arr);
                //4.刷出
                os.flush();
                //5.关闭
                os.close();
        }
}
//接口
class Person implements Serializable{
        private  String name;
        private static int age;
        public Person() {
        }
        public Person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }
        @Override
        public String toString() {
                return "Person [name=" + name + ", age=" + age + "]";
        }
}


二、File 类
File 类:文件和目录路径名的抽象表示形式
        提供的功能:操作文件外部的能力,不能操作文件内部的内容
        能够定义真实存在的路径|文件,不在的也可以定义,所以抽象表现形式
        构造器:        File(File parent, String child)   根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例
                          File(String pathname)  通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
                         File(String parent, String child)   根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马