Java_IO_基础

字节输入输出流InputStream/OutputStream、与字符输入输出流Reader/Write

InputStream类的层次结构:

OutputStream类的层次结构:

Reader类的层次结构:

Writer类的层次结构:

基础:

InputStream

• InputStream类是字节输入流的抽象类,是所有字节输入流的父类。
• 它是以字节作为基本的单位输入

方法	说明
read()	返回int,从输入流中读取下一个字节,(0~255),文本结束返回-1
read(byte[] b)	从输入流读入指定的字节,返回int(字节数)
mark(int readlimit)	该输入流当前位置标记,readlimit在标记位置失效前允许读取的字节数
reset()	重置至当前输入流的mark位置
skip(long n)	跳过输入流上n个字节并返回实际跳过的字节数
markSupported()	当前输入流是否支持mark/reset方法
close()	关闭当前输入流

Reader

• Reader类是字符输入流的抽象类,是所有字符输入流的父类。
• 它是以字符作为基本的单位输入

方法	说明
read()	返回int,从输入流中读取下一个字符,(-1~0xffff),文本结束返回-1
read(char[] c)	从输入流读入指定的字符,返回int(字符数)
mark(int readlimit)	该输入流当前位置标记,readlimit在标记位置失效前允许读取的字符数
reset()	重置至当前输入流的mark位置
skip(long n)	跳过输入流上n个字符并返回实际跳过的字符数
markSupported()	当前输入流是否支持mark/reset方法
close()	关闭当前输入流

InputStream与Reader的区别

• InputStream是表示字节输入流的所有类的超类
• Reader是用于读取字符流的抽象类
• InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。
• 即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。

OutputStream

• OutputStream类是字节输入流的抽象类,是所有字节输出流的父类。
• 它是以字节作为基本的单位输出

方法	说明
write(int b)	将指定字节写入该流
write(byte[] b)	向该输出流写入指定的字节
flush()	彻底完成输出并清空缓存区
close()	关闭当前输出流

Writer

• Writer类是字符输入流的抽象类,是所有字符输入流的父类。
• 它是以字符作为基本的单位输出

方法	说明
write(int c)	将指定字符写入该流
write(char[] cbuf)	向该输出流写入指定的字符
write(char cbuf[], int off, int len)	向该输出流写入指定的字符
write(String str)	向该输出流写入指定的字符串
Writer append(char c)	向输出流append指定的char
flush()	彻底完成输出并清空缓存区
close()	关闭当前输出流

File

文件的创建与删除

构造函数

public File(String pathname);
private File(String child, File parent);
private File(String pathname, int prefixLength);
public File(URI uri);
public File(File parent, String child);
public File(String parent, String child);

方法	说明
getName()	获取文件的名称
getParent()	获得父文件的目录名
canRead()	判断文件是否位可读
canWrite()	判断文件是否为可写
exists()	判断文件是否存在
length()	判断文件的长度
getAbsolutePath()	获取文件的绝对路径
getParent()	获取文件的父路径
isFile()	是否为文件
isDirectory()	是否为目录
isHidden()	判断文件是否隐藏
lastModified()	最近修改时间

文件字节输入输出流

FileInputStream/FileOutputStream

代码示例

     public static void main(String[] args) throws IOException{
        File file=new File("coincidance.txt");
        FileOutputStream fileOutputStream=null;
        FileInputStream fileInputStream=null;
        if(!file.isFile())
        {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(!file.canWrite()&&!file.canRead())
            return;
        try {
            fileOutputStream=new FileOutputStream(file);
            String str="Wow, you can really dance!!!";
            byte[] contents=str.getBytes();
            fileOutputStream.write(contents);
            fileInputStream=new FileInputStream(file);
            int length= (int) file.length();
            if(length>100)
            {
                length=100;
            }
            byte[] readBuffer=new byte[length];
            int actuallyLen=0;
            StringBuilder builder=new StringBuilder();
            while ((actuallyLen=fileInputStream.read(readBuffer))!=-1)
            {
                builder.append(new String(readBuffer,0,actuallyLen));
            }
            System.out.println(builder.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                fileOutputStream.flush();
                fileOutputStream.close();
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
                throw e;
            }
        }
    }

文件字符输入输出流

FileReader/FileWriter

代码示例

 public static void main(String[] args)throws IOException{
       File file=new File("我蠢.txt");
       String poem= "我蠢\n俺没有文化,\n我智商很低,\n要问我是谁,\n一头大蠢驴,\n俺是驴,\n俺是头驴,\n俺是头呆驴。" ;
       if(!file.exists())
       {
           file.createNewFile();
       }
       if(!file.canRead()&&!file.canWrite())return;
        FileWriter fileWriter=null;
        FileReader fileReader=null;
        try {
            fileWriter=new FileWriter(file);
            fileWriter.write(poem);
            fileWriter.flush();
            fileReader=new FileReader(file);
            int fileLen= (int) file.length();
            if(fileLen>32)
            {
                fileLen=32;
            }
            char[] buffer=new char[fileLen];
            int actuallyLen=0;
            StringBuilder builder=new StringBuilder();
            while ((actuallyLen=fileReader.read(buffer))!=-1)
            {
                builder.append(buffer,0,actuallyLen);
            }
            System.out.println(builder.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            fileWriter.close();
            fileReader.close();
        }
    }

带缓存的文件字节输入输出流

BufferedInputStream/BufferedOutputStream

代码示例

 public static void main(String[] args) throws IOException{
        File file=new File("我蠢.txt");
        FileOutputStream fileOutputStream=null;
        FileInputStream fileInputStream=null;
        BufferedOutputStream bufferedOutputStream=null;
        BufferedInputStream bufferedInputStream=null;
        if(!file.isFile())
        {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(!file.canWrite()&&!file.canRead())
            return;
        try {
            fileOutputStream=new FileOutputStream(file);
            String str="我蠢\\n俺没有文化,\\n我智商很低,\\n要问我是谁,\\n一头大蠢驴,\\n俺是驴,\\n俺是头驴,\\n俺是头呆驴。";
            byte[] contents=str.getBytes();
            bufferedOutputStream=new BufferedOutputStream(fileOutputStream);
            bufferedOutputStream.write(contents);
            bufferedOutputStream.flush();
            bufferedOutputStream.close();
            fileInputStream=new FileInputStream(file);
            bufferedInputStream=new BufferedInputStream(fileInputStream);
            int length= (int) file.length();
            if(length>64)
            {
                length=64;
            }
            byte[] readBuffer=new byte[length];
            int actuallyLen=0;
            StringBuilder builder=new StringBuilder();
            while ((actuallyLen=bufferedInputStream.read(readBuffer))!=-1)
            {
                builder.append(new String(readBuffer,0,actuallyLen));
            }
            bufferedInputStream.close();
            System.out.println(builder.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                fileOutputStream.flush();
                fileOutputStream.close();
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
                throw e;
            }
        }
    }

数据输入输出流

DataInputStream/DataOutputStream

代码示例

public static void main(String[] args) throws IOException{
        File file=new File("我蠢.txt");
        String poem= "我蠢\n俺没有文化,\n我智商很低,\n要问我是谁,\n一头大蠢驴,\n俺是驴,\n俺是头驴,\n俺是头呆驴。" ;
        if(!file.isFile())
        {
            file.createNewFile();
        }
        if(!file.canRead()&&!file.canWrite())return;
        FileOutputStream fileOutputStream=null;
        FileInputStream fileInputStream=null;
        DataOutputStream dataOutputStream=null;
        DataInputStream dataInputStream=null;
        try
        {
            fileOutputStream=new FileOutputStream(file);
            dataOutputStream=new DataOutputStream(fileOutputStream);
            dataOutputStream.writeUTF(poem);
            dataOutputStream.flush();
            dataOutputStream.close();
            fileInputStream=new FileInputStream(file);
            dataInputStream=new DataInputStream(fileInputStream);
            String s=dataInputStream.readUTF();
            System.out.println(s);
        }catch (IOException e)
        {
            e.printStackTrace();
        }
    }

DataOutputStream的问题,写入到文件时会写入字数
不是UTF编码的字符使用readUTF会报java.io.EOFException

Zip压缩

ZipInputStream/ZipOutputStream

代码示例

 public static void main(String[] args) throws IOException{
        Main m=new Main();
        String path="";
        if(args.length!=0)
        {
            path=args[0];
        }
        m.zip(path+".zip",new File(path));
    }
    private void zip(String zipFileName,File inputFile)throws IOException {
        File file=new File(zipFileName);
        FileOutputStream fileOutputStream=new FileOutputStream(file);
        ZipOutputStream zipOutputStream=new ZipOutputStream(fileOutputStream);
        zip(zipOutputStream,inputFile,inputFile.getName());
        System.out.println("压缩中");
        zipOutputStream.close();
    }

    private void zip(ZipOutputStream zipOutputStream,File file,String base) throws  IOException{
        if(file.isDirectory())
        {
            File[] files=file.listFiles();
            if(base.length()!=0)
            {
                zipOutputStream.putNextEntry(new ZipEntry(base+"/"));
            }
            for(File f:files)
            {
                zip(zipOutputStream,f,base+"/"+f.getName());
            }
        }
        else
        {
            zipOutputStream.putNextEntry(new ZipEntry(base));
            FileInputStream fileInputStream=new FileInputStream(file);
            int b=0;
            while ((b=fileInputStream.read())!=-1)
            {
                zipOutputStream.write(b);
            }
            fileInputStream.close();
        }
    }