Java中的IO流

Posted 2022-05-18 嫚嫚_

2、IO流，什么是IO？

I : Input
O : Output
通过IO可以完成硬盘文件的读和写。

3、IO流的分类？

有多种分类方式：

	一种方式是按照流的方向进行分类：
		以内存作为参照物，
			往内存中去，叫做输入(Input)。或者叫做读(Read)。
			从内存中出来，叫做输出(Output)。或者叫做写(Write)。

	另一种方式是按照读取数据方式不同进行分类：
		有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。
		这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件等....
			假设文件file1.txt，采用字节流的话是这样读的：
				a中国bc张三fe
				第一次读：一个字节，正好读到'a'
				第二次读：一个字节，正好读到'中'字符的一半。
				第三次读：一个字节，正好读到'中'字符的另外一半。

		有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取
		普通文本文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯
		文本文件，连word文件都无法读取。
			假设文件file1.txt，采用字符流的话是这样读的：
				a中国bc张三fe
				第一次读：'a'字符（'a'字符在windows系统中占用1个字节。）
				第二次读：'中'字符（'中'字符在windows系统中占用2个字节。）

综上所述：流的分类
	输入流、输出流
	字节流、字符流

4、Java中的IO流都已经写好了，我们程序员不需要关心,我们最主要还是掌握，

在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有
哪些？？？？
java中所有的流都是在：java.io.*;下。

java中主要还是研究：
	怎么new流对象。
	调用流对象的哪个方法是读，哪个方法是写。

5、java IO流这块有四大家族：

四大家族的首领：
	java.io.InputStream  字节输入流
	java.io.OutputStream 字节输出流

	java.io.Reader		字符输入流
	java.io.Writer		字符输出流

	四大家族的首领都是抽象类。(abstract class)

	所有的流都实现了：
		java.io.Closeable接口，都是可关闭的，都有close()方法。
		流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，
		不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。

	所有的输出流都实现了：
		java.io.Flushable接口，都是可刷新的，都有flush()方法。
		养成一个好习惯，输出流在最终输出之后，一定要记得flush()
		刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据
		强行输出完（清空管道！）刷新的作用就是清空管道。
		注意：如果没有flush()可能会导致丢失数据。


注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

FileInputStream

package com.company;

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

public class FileInputStreamTest04 
    public static void main(String[] args) 
        FileInputStream fis=null;
        try 
            fis=new FileInputStream("tempfile");
            //准备一个Byte数组
            byte[] bytes=new byte[4];
            /*
            while (true)
               int count= fis.read(bytes);
               if(count==-1)
                   break;
               
               System.out.print(new String(bytes,0,count));
            
             */

            int readCount=0;
            while((readCount= fis.read(bytes))!=-1)
                System.out.print(new String(bytes,0,readCount));
            
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         finally 
            if(fis!=null)
                try 
                    fis.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
        
    

FileInputStream其他常用方法

package com.company;

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

public class FileInputStreamTest05 
    public static void main(String[] args) 
        //其他常用方法

        //int available（）剩余的字节数量
        //long skip(long n) 跳过几个字节不读
        FileInputStream fis=null;
        try 
            fis=new FileInputStream("tempfile");
            /*
            //读一个字节
            int readByte=fis.read();
            //还剩下的字节数量
            System.out.println("还剩下几个字节数量"+fis.available());
            //这个方法有什么用
            //1：总字节数量

             */
            /*
            byte[] bytes=new byte[fis.available()];
            //这种方式不合适大文件，因为Byte不能太大
            int read=fis.read(bytes);
            System.out.println(new String(bytes));

             */

            fis.skip(1);
            byte[] byt=new byte[1];
            int co=fis.read(byt);
            System.out.println(new String(byt));
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         finally 
            try 
                fis.close();
             catch (IOException e) 
                e.printStackTrace();
            
        
    

FileOuputStream类

package com.company;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOuputStreamTest01 
    public static void main(String[] args) 
        FileOutputStream fos=null;
        try 
            //文件不存在自动新建
            //这种方式会将文件先清空在创建
            fos=new FileOutputStream("myfil",true);

            //开始写
            byte[] bytes=98,97,96;
            fos.write(bytes);
            fos.write(bytes,0,2);
            //字符串
            String s="我是一个中国人";
            byte[] bs=s.getBytes();
            fos.write(bs);


            //刷新
            fos.flush();
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         finally 
            if(fos!=null)
                try 
                    fos.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
        
    

文件的赋值

package com.company;

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

public class Copy01 
    public static void main(String[] args) 
        //使用FileInputStream和OutStream完成文件的拷贝
        //应该是一边读一边写
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try 
            fis = new FileInputStream("D:\\\\KEIL\\\\1.c");
            fos=new FileOutputStream("D:\\\\java代码\\\\IO流\\\\aaa");

            byte[] bytes=new byte[1024*1024];//1MB
            int read=0;
            while((read=fis.read(bytes))!=-1)
                fos.write(bytes,0,read);
            
            //刷新
            fos.flush();
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         finally 
            if(fos!=null)
                try 
                    fos.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
            if(fis!=null)
                try 
                    fis.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
        
    

FileReader

package com.company;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReadTest01 
    //文件字符输入流，只能读取普通文本
    public static void main(String[] args) 
        FileReader reader=null;
        try 
            reader =new FileReader("tempfile");
            char[] c=new char[4];
            //一次读取4个字符
            int count=0;
            while ((count=reader.read(c))!=-1)
                System.out.print(new String(c,0,count));
            

         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         finally 
            if(reader!=null)
            
                try 
                    reader.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
        
    

BufferdeReader

package com.company;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class BufferdeReader 
    public static void main(String[] args) throws Exception
        //节点流
        FileInputStream in=new FileInputStream("11.txt");
        //转换流
        InputStreamReader reader=new InputStreamReader(in);
        //字符流
        BufferedReader br=new BufferedReader(reader);
        String line=null;
        while ((line= br.readLine())!=null) 
            System.out.println(line);
        

        br.close();
    

BufferedWriter

package com.company;

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class BufferedWriterTest 
    public static void main(String[] args) throws Exception 
        //带有缓存的字符输出流
        BufferedWriter out=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("c",true)));
    out.write("hello");
    out.write("\\n");
    out.write("hello kitty");
    out.flush();
    out.close();
    

File

判断文件
package com.company;

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

public class FileTest 
    public static void main(String[] args) throws IOException 
        //File 跟四大家族没关系 不能完成文件的读和写
        //创建一个File对象
        File f1=new File("D:\\\\file");
        //判断是否从存在
        System.out.println(f1.exists());
        //不存在以文件形式创建
        /*
        if(!f1.exists())
            f1.createNewFile();
        

         */
        //以目录的形式创建
        if(!f1.exists())
          // f1.mkdir();
        

        //获取文件的父路径
        File f3=new File("D:\\\\java代码\\\\IO流\\\\src\\\\com\\\\company\\\\FileTest.java");
       String path= f3.getParent();
       System.out.println(path);
       System.out.println(f3.getAbsolutePath());
    

6、java.io包下需要掌握的流有16个：

	文件专属：
	java.io.FileInputStream（掌握）
	java.io.FileOutputStream（掌握）
	java.io.FileReader
	java.io.FileWriter

转换流：（将字节流转换成字符流）
	java.io.InputStreamReader
	java.io.OutputStreamWriter

缓冲流专属：
	java.io.BufferedReader
	java.io.BufferedWriter
	java.io.BufferedInputStream
	java.io.BufferedOutputStream

数据流专属：
	java.io.DataInputStream
	java.io.DataOutputStream

标准输出流：
	java.io.PrintWriter
	java.io.PrintStream（掌握）

对象专属流：
	java.io.ObjectInputStream（掌握）
	java.io.ObjectOutputStream（掌握）

IO和properties文件的联合使用

package com.company;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Properties;

public class IOPropertiesTest01 
    public static void main(String[] args) throws Exception 

        /*
        Properties 是一个Map集合，都是String类型
        将userinfo文件加载到Properties文件中
         */
        //新建输入流对象
        FileReader reader = new FileReader("userinfo");

        //新建一个Map集合
        Properties pro=new Properties();
        //将文件中的数据加载到Map集合中，文件中的数据顺着管道加载到Map集合中
        //等号左边zuokey，右边value
        pro.load(reader);
        //通过key来获取valu
        System.out.println(pro.getProperty("username"));