Java IO

最新推荐文章于 2024-11-10 08:43:33 发布

郑博文

最新推荐文章于 2024-11-10 08:43:33 发布

阅读量1.9k

点赞数 21

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_77687181/article/details/137398399

版权

File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录
File类的常用方法

方法   说明
boolean canWrite()
判断文件是否可以写入,可以返回true,否则返回false
String getAbsoluteFile()
获取文件绝对地址
boolean isHidden()
判断文件是否是隐藏文件,是返回true,否则返回false
boolean isFile()   判断是否是文件,是返回true,否则返回false
boolean isDirectory()
判断是否是文件夹,如果是返回true,否则返回false
String getName()   获取文件的名字
boolean createNewFile()
创建文件,创建成功返回true,否则返回false
boolean delete()
删除文件,删除成功返回true,否则返回false
public String[] list()   将目录下的子目录及文件的名字,返回到String数组中
public File[] listFiles()   将目录下的子目录及文件的实例,返回到File数组中
mkdir()   创建单级目录
mkdirs()   创建多级目录
boolean delete();也可以删除文件夹,但是要求文件夹中无其他内容
输入与输出
输入输出（I/O）把电脑硬盘上的数据读到程序中，称为输入,即input,进行数据的read 操作从程序往外部设备写数据，称为输出，即output，进行数据的write 操作
输入流与输出流
● 流按着数据的传输方向分为：
● 输入流：往程序中读叫输入流。
● 输出流：从程序中往外写叫输出流。
● InputStream和OutputStream的子类都是字节流可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。
● Reader和Writer的子类都是字符流主要处理字符或字符串，字符流处理单元为1个字符。字节流将读取到的字节数据，去指定的编码表中获取对应文字字符。
package day13.stream;

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

public class StreamDemo1 {
    public static void main(String[] args) throws IOException {
        //创建一个输入流对象
        FileInputStream in=new FileInputStream("D:/a.txt");
        FileOutputStream out=new FileOutputStream("D:/b.txt");//输出流会自动创建文件
        System.out.println(in.read());//97
        System.out.println(in.read());//98
        System.out.println(in.read());//99
        System.out.println(in.read());//100
        System.out.println(in.read());//-1   当文件内容读完了之后,返回-1
    }
}

字节流与字符流
● 字节流中常用类
字节输入流 FileInputStream
字节输出流 FileOutputStream
● 字符流中常用类
字符输入流 FileReader
字符输出流 FileWriter
输入输出字节流
● InputStream 的基本方法
读取一个字节并以整数的形式返回 (0~255),如果返回-1已到输入流的末尾。
int read() throws IOException
读取一系列字节并存储到一个数组buffer，返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
int read(byte[] buffer) throws IOException
关闭流释放内存资源
void close() throws IOException
● OutputStream的基本方法
向输出流中写入一个字节数据,该字节数据为参数b的低8位
void write(int b) throws IOException
将一个字节类型的数组中的从指定位置（off）开始的 len个字节写入到输出流
void write(byte[] b, int off, int len) throws IOException
关闭流释放内存资源
void close() throws IOException
package day13.stream;

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

/*
int read() 默认一次读一个字节,返回的是独到的字节的编码效率低
int read(byte[] b) 默认一次读一个指定大小数组个字节, 返回的是数组中一次实际输入的字节个数
相同之处:
读完后返回-1
*/

public class StreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("D:/1.png");
        FileOutputStream out=new FileOutputStream("D:/2.png");//输出流会自动创建文件
                int t=0;
                while((t=in.read())!=-1){
                    System.out.println(t);
                    out.write(t);
                }
                /*
                byte[] bytes=new byte[100];
                int size=0;
                while((size=in.read(bytes))!=-1){
                    out.write(bytes,0,size);
                }
                */
                //关闭流对文件的占用
                in.close();
                out.close();
    }
}

节点流与处理流
● 根据封装类型不同流又分为
节点流处理流
● 节点流：
如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，则称为节点流。
● 处理流:
如果流封装的是其它流对象，称为处理流。处理流提供了缓冲功能，提高读写效率,同时增加了一些新的方法
● 节点流中常用类
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
● 处理流中常用类
缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter

package day13.stream;
 
import java.io.*;
 
public class StreamDemo4 {
    public static void main(String[] args) throws IOException {
        //创建一个输入流对象
        FileInputStream in=new FileInputStream("D:/1.png");//节点流,直接包含文件(数据)
        BufferedInputStream bin=new BufferedInputStream(in);//处理流-->带缓冲功能的流
 
        FileOutputStream out=new FileOutputStream("D:/2.png");
        BufferedOutputStream bout=new BufferedOutputStream(out);
 
                byte[] bytes=new byte[1024];
                int size=0;
                while((size=bin.read(bytes))!=-1){
                    bout.write(bytes,0,size);
                }
 
                bin.close();
                bout.flush();
                bout.close();
 
    }
}

输入输出字符流
●Reader 的基本方法
读取一个字符并以整数的形式返回, 如果返回-1已到输入流的末尾。
int read() throws IOException
读取一系列字符并存储到一个数组buffer，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read( char[] cbuf) throws IOException
关闭void close() throws IOException
• Writer 的基本方法
向输出流中写入一个字符数据,该字节数据为参数b的16位
void write(int c) throws IOException
一个字符类型的数组中的数据写入输出流
void write( char[] cbuf) throws IOException
将一个字符类型的数组中的从指定位置（off set）开始的 length个字符写入到输出流
void write( char[] cbuf, int off set, int length) throws IOException
关闭void close() throws IOException

package day13.chardemo;
 
import java.io.*;
 
public class CharDemo4 {
    public static void main(String[] args) throws IOException {
        FileReader reader=new FileReader("D:/a.txt");
        BufferedReader bufferedReader=new BufferedReader(reader);
                                                                //输出时保留文件中已存在的内容,将新内容追加到原有内容后面
        FileWriter writer=new FileWriter("D:/b.txt",true);
        BufferedWriter bufferedWriter=new BufferedWriter(writer);
 
        String line=null;//一次可以读入一行数据,读完返回null
        while((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);//一次向外输出一个字符串
            bufferedWriter.newLine();//插入一个换行符
        }
        bufferedReader.close();
        bufferedWriter.flush();
        bufferedWriter.close();
 
    }
}

对象输入输出流--对象序列化
● 对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。
● 对象的输入输出流 :
主要的作用是用于写入对象信息与读取对象信息。对象信息一旦写到文件上那么对象的信息就可以做到持久化了.
对象的输出流:ObjectOutputStream
对象的输入流:ObjectInputStream
● 在ObjectInputStream 中用readObject()方法可以直接读取一个对象， ObjectOutputStream 中用writeObject()方法可以直接将对象保存到输出流中。

package day13.chardemo;
 
import java.io.Serializable;
 
/*
        一旦一个类实现了Serializable接口,会自动的为每一个类生成一个序列化编号(唯一的)
        虽然实现了Serializable接口,可以生成一个序列化id号,但是一旦类信息发生了修改,序列化编号就会变
        如果重新输入对象时,两次序列化的版本号就不一致了
        解决办法:
            显示的在类中生成一个序列化版本号
 */
public class User implements Serializable {
    private static final long serialVersionUID = 3804224065283861154L;
    //类的序列化id
 
    private String account;
    //添加了transient关键字的属性,不会被保存到文件中
    private transient String password;
 
    public User(String account, String password) {
        this.account = account;
        this.password = password;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "account='" + account + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
package day13.chardemo;
 
import java.io.*;
import java.util.Date;
 
public class ObjectStream1 {
    /*
       对象输入输出流:
            有时候,需要将运行中的对象信息持久保存起来,因为对象在内存中,程序如果终止,对象信息就不存在了
            将对象信息输出到文件的过程,称为对象的序列化,使用ObjectOutputStream(处理流)
            将对象信息从文件中输入到java程序的过程,称为对象反序列化,使用ObjectInputStream
            对象的序列化,会在内存中重新创建的对象保存数据,所以,也是java中创建对象的一种方式
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
            当我们把一个类的对象用输出流向外输出时,要求这个类必须实现序列化接口,否则会报错
            NotSerializableException
         */
        User user=new User("123456", "654321");
 
        FileOutputStream out=new FileOutputStream("D:/obj.txt");
        ObjectOutputStream outputStream=new ObjectOutputStream(out);
                            outputStream.writeObject(user);
 
                            outputStream.flush();
                            outputStream.close();
 
        FileInputStream in=new FileInputStream("D:/obj.txt");
        ObjectInputStream objectInputStream=new ObjectInputStream(in);
 
        User s=(User)objectInputStream.readObject();
        System.out.println(s);
 
        objectInputStream.close();
    }
}