java笔记23 IO流2 字节流与转换流

来源：互联网发布：js 判断invalid date 编辑：程序博客网时间：2024/05/20 05:04

1. 字节流写入和读取

基本原理与字符流相同，不仅可以操作字符，还可以操作其他媒体文件。

示例

import java.io.*;
public class H_11IOOutPutStream {
    public static void main(String[] args) throws IOException {
        writeFile();
        readerFile_1();//一次读取一个字符
        readerFile_2();//自定义大小的数组
        readerFile_3();//用一个刚好的字节数组
    }
    public static void readerFile_3() throws IOException
    {
        FileInputStream fis=new FileInputStream("fos.txt");
        //int num=fis.available();//返回字节流的个数
        byte[] buf=new byte[fis.available()];//定义一个刚刚好的数组
        //慎用，如果文件过大，内存溢出。
        fis.read(buf);//缓冲写入该数组
                System.out.print(new String(buf));//变成字符串打印
        fis.close();
    }
    public static void readerFile_2() throws IOException
    {
        FileInputStream fis=new FileInputStream("fos.txt");
        byte[] buf=new byte[1024];
        int len=0;
        int count=0;
        while((len=fis.read(buf))!=-1)
                {
                    count++;
                    System.out.print(count+new String(buf,0,len));
                    //count=1，说明该循环只被读取了一次
                }
        fis.close();
    }
    public static void readerFile_1() throws IOException
    {
        FileInputStream fis=new FileInputStream("fos.txt");
        int ch=0;
        while((ch=fis.read())!=-1)//一次读取一个字符
                {
                    System.out.print(ch+"+");
                    System.out.print((char)ch+"  ");
                }
        fis.close();
    }
    public static void writeFile() throws IOException
    {
        FileOutputStream fos=new FileOutputStream("fos.txt");
        fos.write("ceshifijieliu".getBytes());//不需要刷新动作      
        fos.close();       
    }
}

2. 用字节流复制图片

/*
    需求：
    复制一个图片
    分析：
    1、用字节读取流对象 和图片关联
    2、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
    3、通过循环读写，完成数据的存储
    4、关闭资源
 */
package day19;
import java.io.*;
public class H_12IOCopyPicture {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        FileInputStream fis=null;
   
        try {
            fos=new FileOutputStream("D:\\shakespace\\Pictures\\TBBT_copy.png");
            fis=new FileInputStream("D:\\shakespace\\Pictures\\TBBT.png");
            byte[] buf=new byte[1024];
            int len=0;
            while((len=fis.read(buf))!=-1)
            {
                fos.write(buf, 0, len);            
            }          
        }
        catch (IOException e) {
            throw new RuntimeException("复制文件失败");
        }
        finally
        {
            try {
                if(fis!=null)
                    fis.close();
            } catch (IOException e) {
                throw new RuntimeException("读取文件失败");
            }
            try {
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                throw new RuntimeException("写入文件失败");
            }
        }      
    }
}

3. 复制文件测试效率

import java.io.*;
public class H_13BufferedOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        long start=System.currentTimeMillis();
        copy_2();
        long end=System.currentTimeMillis();      
        System.out.println(end-start);     
    }
    public static void copy_1() throws IOException
    {
        BufferedInputStream bis=new BufferedInputStream(newFileInputStream("D:\\shakespace\\Pictures\\TBBT.png"));
        BufferedOutputStream bos=new BufferedOutputStream(newFileOutputStream("D:\\shakespace\\Pictures\\TBBT_copy2.png"));
        int by=0;
        while((by=bis.read())!=-1)
        {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
    public static void copy_2() throws IOException
    {
        FileInputStream fis=newFileInputStream("D:\\shakespace\\Pictures\\TBBT.png");
        FileOutputStream fos=newFileOutputStream("D:\\shakespace\\Pictures\\TBBT_copy2.png");
        int by=0;
        while((by=fis.read())!=-1)
        {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}

结果加了缓冲只需要200ms左右，不加缓冲需要20000ms，差异巨大。

4. 读取键盘录入

System.out:对应的是标准输出设备，控制台

System.in:对应的是标准输入设备，键盘

通过System类的setIn，setOut方法可以对默认设备进行改变。
System.setIn(new FileInputStream(“1.txt”));//将源改成文件1.txt。
System.setOut(new PrintStream(“2.txt”));//将目的改成文件2.txt

需求：读取键盘录入，在控制台上打印

import java.io.*;
public class H_15ReadIn {
    public static void main(String[] args) throws IOException {
        in_2();
    }
    public static void in_2() throws IOException
    {
        InputStream in=System.in;
        StringBuilder sb=new StringBuilder();
        while(true)
        {
            int ch=in.read();
            if(ch=='\r')
                continue;
            if(ch=='\n')//类似于readline方法
            {
                String s=sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0,sb.length());//每次清空
            }
            else
                sb.append((char)ch);                  
        }      
    }
}

5. 转换流

将字节流转换为字符流，并加入缓冲提高效率。

键盘录入最常见写法：

BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));

控制台输出：

BufferedWriter bufosw=new BufferedWriter(new OutputStreamWriter(System.out));//可以使用newLine方法

import java.io.*;
public class H_15TransStream {
    public static void main(String[] args) throws IOException
    {
        //获取键盘录入对象
        //InputStream in=System.in;
        //将字节流对象转换成字符流对象，使用转换流
        //InputStreamReader isr=new InputStreamReader(in);
        //为了提高效率，将字符流进行缓冲区计数的高效操作
        //BufferedReader bufr=new BufferedReader(isr);
       
        BufferedReader bufr=new BufferedReader(newInputStreamReader(System.in));
        //OutputStreamWriter osw=new OutputStreamWriter(System.out);
        BufferedWriter bufosw=new BufferedWriter(newOutputStreamWriter(System.out));//可以使用newLine方法      
       
        String line=null;
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            //System.out.println(line.toUpperCase());
            bufosw.write(line.toUpperCase());
            bufosw.newLine();
            bufosw.flush();                
        }
        bufosw.close();    
    }
}

6. 流的操作规律

四个明确

1、明确源和目的
      源：InputStream Reader
      目的：OutputStream Writer
2、明确数据是否是纯文本数据
      源：是纯文本：Reader
              否：InputStream
      目的：是纯文本：Writer
              否：OutputStream
      到这里，就可以明确需求中具体要使用哪个体系。

3、明确具体的设备
      源设备：
      硬盘：File
      键盘：System.in
      内存：数组
      网络：Socket流
      目的设备：
      硬盘：File
      控制台：System.out
      内存：数组
      网络：Socket流

4、是否需要其他额外功能
是否需要高效（缓冲区）：
是，就加上buffer

6.1   需求1：复制一个文本文件
1、明确源和目的。
      源：InputStream Reader
      目的：OutputStream Writer
2、是否是纯文本？
      是！
      源：Reader
      目的：Writer
3、明确具体设备。
      源：硬盘：File
      目的：硬盘：File
      FileReader fr = new FileReader("a.txt");
      FileWriter fw = new FileWriter("b.txt");
4、需要额外功能吗？
      需要，高效
      BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
      BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
   ============================================

6.2    需求2：读取键盘录入信息，并写入到一个文件中
1、明确源和目的。
      源：InputStream Reader
      目的：OutputStream Writer
2、是否是纯文本？
      是！
      源：Reader
      目的：Writer
3、明确具体设备。
      源：键盘：System.in
      目的：硬盘：File
      FileReader fr = new System.in;
      FileWriter fw = new FileWriter("b.txt");
  这样做可以完成，但是麻烦。将读取的字节数据转成字符串，再由字符流操作。
4、需要额外功能吗？
      需要，转换。将字节流转成字符流，因为明确的源是Reader，这样操作文本数据更快捷。
      InputStreamReader isr = new InputStreamReader(System.in);
      FileWriter fw = new FileWriter("b.txt");
      还需要功能吗？
      需要,高效。
      BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
      BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
============================================

6.3   需求3：将一个文本文件数据显示在控制台上
1、明确源和目的。
      源：InputStream Reader
      目的：OutputStream Writer
2、是否是纯文本？
      是！
      源：Reader
      目的：Writer
3、明确具体设备。
      源：硬盘：File
      目的：屏幕：System.out
   FileReader fr = new FileReader("a.txt");
   FileWriter fw = System.out;//PrintStream
4、需要额外功能吗？
      需要，转换。
      FileReader fr = new FileReader("a.txt");
      OutputStreamWriter osw = new OutputStreamWriter(System.out);
      需要,高效。
      BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
      BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
============================================

6.4   需求4：读取键盘录入数据，显示在控制台上
1、明确源和目的。
      源：InputStream Reader
      目的：OutputStream Writer
2、是否是纯文本？
      是！
      源：Reader
      目的：Writer
3、明确具体设备。
      源：键盘：System.in
      目的：屏幕：System.out
      InputStream in = System.in;
      OutputStream out = System.out;
4、明确额外功能？
      需要，转换。因为都是字节流，但是操作的却是文本数据。所以使用字节流操作起来更为便捷。
      InputSreamReader isr = new InputStreamReader(System.in);
      OutputStreamWriter osw = new OutputStreamWriter(System.out);
      需要,高效。
      BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
      BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

7. 打印系统信息

import java.util.*;
import java.io.*;
public class H_22SystemInfo {
    public static void main(String[] args) throws IOException {
                Properties prop=System.getProperties();
        prop.list(new PrintStream("systeminfo.txt"));
    }
}

0 0