理解IO流并学习使用几种常用的读写方式

数据最终表示出来是流的形式，就像水流一样。
流：
输入端 InputStream 读
输出端 OutputStream 写

从文件里读和写

File file=new File("测试目录\测试文件.txt");
file.createNewFile();

//读  read()
一.
InputStream is=new FileInputStream(file);
//is.available() 估计流中的字节数
int b;
while((b=is.read())!=-1){  //is.read()==-1表示读到结尾
System.out.println(b);
}
二.
InputStream is=new FileInputStream(file);
Byte[] buf=new byte[1024];
int len=is.read(buf);
String s=new String(buf,0,len,"GB18030");
System.out.println(s);

//写  write()
OutputStream os=new FileOutputStream(file);

os.write(97); //写入a
os.write(98); //写入b
os.write(99); //写入c

byte[] buf="我是中国人".getBytes();//把文本转换成二进制流，默认UTF-8编解码
//byte[] buf="我是中国人".getBytes("UTF-8");
//byte[] buf="我是中国人".getBytes("GB18030");
os.write(buf);

按来源不同分为：
文件流，字符流，对象流
FileInputStream（源是文件）
ByteArrayInputStream（源是内存中的一个段Byte [ ]）
按字节流和字符流分为：
InputStream、OutputStream
Reader、Writer 四个接口

从文件中读和写

File file=new File("D:JavaIO测试目录\测试文件.txt");
//读
一.reader
InputStream is=new FileInputStream(file);
InputStreamReader isReader=new InputStreamReader(is,"UTF-8");
char[] buf=new char[10];
int len=isReader.read(buf);
System.out.println(Arrays.toString(buf));

二.BufferedReader
//使用Buffered减少和硬盘交换次数，读写效率提高
BufferdReader reader=new BufferedReader(
new InputStreamReader(
new FileInputStream(file),"GB18030"));
//reader.readLine()  //可以一次读一行

Scanner和流

InputStream is=new FileInputStream(file);
Scanner sc=new Scanner(is);

进程被启动时，默认带有三个流
1.标准输入 System.in
2.标准输出 System.out
3.标准错误 System.error

练习：拷贝文件

public class Copy{
public static void main(String[] args) throws IOException{
String sc="D:\Java\测试文件.txt";
String dest="D:\Java\目标文件.txt";
InputStream is=new FileInputStream(sc);
OutputStream os=new FileOutputStream(dest);
int b;
while((b=is.read()!=-1){
os.write(b);
}
}
}

UTF-8是可变长编码，一个中文是3个字节，一个英文是1个字节
GB18030 编码，一个中文是2个字节

对照上图，下面列出读数据的几种常用方式：

package io.pp;

import java.io.*;

public class IODemo {
    /**
     *1.可以从文件中读
     * 2.可以从网络中读
     * 3.可以从内存读
     * 4.可以从标准输入读
     */
    /**
     * 1.直接通过字节读，手动编码
     * 2.转化为字符读
     * 3.Scanner读
     */

 private static InputStream 获取一个输入流() throws IOException {
 //从文件读
        InputStream inputStream;
        inputStream=new FileInputStream("文本文件.txt");  //这是个相对路径
        return inputStream;
    }
//字节数组读
        byte[] bytes="我是一句话rn".getBytes("UTF-8");
        inputStream=new ByteArrayInputStream(bytes);
        return inputStream;
//从网络读
       Socket socket=new Socket("www.baidu.com",80);
       OutputStream os=socket.getOutputStream();
       Writer writer=new OutputStreamWriter(os,"UTF-8");
       PrintWriter printWriter=new PrintWriter(writer,false);
       printWriter.printf("CET / HTTP/1.0rnrn");
       printWriter.flush();
       inputStream=socket.getInputStream();
       return inputStream;        

 private static String 从字节流中最终获得字符数据(InputStream is) throws IOException {
        /* 
        第一种：字节读-直接读
        byte[] buffer=new byte[1024];
        int len=is.read(buffer); //buffer有多大就尝试读多大
        String message=new String(buffer,0,len,"UTF-8");
        System.out.println(message);
        return message;
        */
        
        /*
        第二种：字符读-reader读
        Reader reader=new InputStreamReader(is,"UTF-8");
        char[] buffer=new char[1024];
        int len=reader.read(buffer);
        String message=new String(buffer,0,len);
        return message;
        */
        
        /*
        第三种：字符读-StringBuilder读
       StringBuilder sb=new StringBuilder();
       Reader reader=new InputStreamReader(is,"UTF-8");
       char[] buffer=new char[10];
       int len;
       while((len=reader.read(buffer))!=-1){
           sb.append(buffer,0,len);
       }
       return sb.toString();
       */
        
        /*
        四种：字符读-BufferedReader读
         */
        Reader reader=new InputStreamReader(is,"UTF-8");
        BufferedReader bufferedReader=new BufferedReader(reader);
        String line;
        StringBuilder sb=new StringBuilder();
        while((line=bufferedReader.readLine())!=null){   //readLine()会自动去掉rn
            sb.append(line+"rn");
        }
        return sb.toString();
    }

 public static void main(String[] args) throws IOException {
        InputStream is=获取一个输入流();
        String message=从字节流中最终获得字符数据(is);
        System.out.println(message);
    }
}

BufferedReader 内部有一个char类型的数组，默认大小是4096（size）

写数据的几种方式

     private static OutputStream 获取一个输出流() throws IOException {
        //OutputStream os=new FileOutputStream("本地输出文件.txt"); //写入文件
        Socket socket=new Socket("www.baidu.com",88);    //写入网络
        OutputStream os=socket.getOutputStream();
       // OutputStream os=new ByteArrayOutputStream();   //写入字节数组
        return os;
    }
     private static void 输出一段文字(OutputStream os,String message) throws IOException{
        byte[] buffer=message.getBytes("UTF-8");
        os.write(buffer);
        Writer writer=new OutputStreamWriter(os,"UTF-8");
        writer.append(message);
        writer.flush();

        PrintWriter printWriter=new PrintWriter(os,false);
        printWriter.printf("%s",message);
        printWriter.flush();
    }
     public static void main(String[] args) throws IOException {
        OutputStream os=获取一个输出流();
        输出一段文字(os,"我是输出rn");
}

最后

以上就是魁梧高山为你收集整理的理解IO流并学习使用几种常用的读写方式的全部内容，希望文章能够帮你解决理解IO流并学习使用几种常用的读写方式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。