Java基础-流

最新推荐文章于 2024-08-26 16:40:46 发布

Feidixun

最新推荐文章于 2024-08-26 16:40:46 发布

阅读量81

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/Feidixun/article/details/129302803

版权

本文详细介绍了Java中的流，包括流的分类、字节流与字符流的区别，以及字节缓冲流、字符缓冲流、打印流、对象流、字节数组流、数据流等的使用。此外，还探讨了转换流在不同流之间的转换作用，并讨论了文件分割、合并、压缩和解压缩的操作。

摘要由CSDN通过智能技术生成

流

流的分类

按方向【`重点`】

输入流 (Input)：将<存储设备>中的内容读入到<内存>中。硬盘->内存。

输出流 (Output)：将<内存>中的内容写入到<存储设备>中。内存->硬盘。

按单位

字节流：以字节为单位，可以读写所有数据。

字符流：以字符为单位，只能读写文本数据。

按功能

节点流：具有实际传输数据的读写功能。

过滤（处理）流：在节点流的基础之上增强功能。

字节抽象类

字节流

InputStream：字节输入流
OutputStream：字节输出流

import java.io.*;


/**
 * 字节输出输入流
 * 输出流：超类OutputStream，对文件的输出流使用子类FileOutputStream
 * 输入流：超类InputStream，对文件的的输入使用子类FileInputStream
 */
public class ByteStreamDemo {
   
    private static void in(){
   
        //目标文件
        File file = new File("F:\\CodeDemo\\demo.txt");
        //构建一个文件输入流对象
        try {
   
            InputStream in = new FileInputStream(file);

            byte[] bytes = new byte[1024];  //每次累计到1024字节数组再读取出来
            int len = -1;   //实际读取的长度，-1表示没有
            StringBuilder buf  = new StringBuilder();
            while ((len = in.read(bytes)) != -1) {
        //read（bytes）返回读取的字节数,直到len=-1
              //根据读取到的字符数组转换成字符串
                buf.append(new String(bytes,0,len));    //偏移量为0，读取长度为len，避免数据覆盖误读
            }
            System.out.println(buf);
            in.close();

         }  catch (IOException e) {
   
                e.printStackTrace();
         }

    }

    private static void out(){
   
        //目标文件
        File file = new File("F:\\CodeDemo\\demo.txt");
        //构建一个文件输出流对象
        try {
   
            OutputStream out = new FileOutputStream(file,true); //append参数为true表示追加内容
            //输出内容
            String info = "这是测试代码\r\n";
            //把内容写入到文件
            out.write(info.getBytes());
            //关闭流
            out.close();
            System.out.println("测试完毕！");
        }catch (FileNotFoundException e){
   
            e.printStackTrace();
        }catch (IOException e){
   
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
   
        out();
        in();
    }

}

字符抽象类

字符流

Reader：字符输入流

public int read(){}。

public int read(char[] c){}。

public int read(char[] b,int off,int len){}。

Writer：字符输出流

public void write(int n){}。

public void write(String str){}。

public void write(char[] c){}。

import java.io.*;

/**
 * 字符流
 * 字符输出流：Write，对文件的的操作使用子类：FileWriter
 * 字符输入流：Reader，对文件的操作使用子类：FileReader
 * 每次操作一个字符，中英文均为一个字符
 * 文件字符操作类自带缓存，默认1024字节，满、关闭或刷新后写入硬盘
 * 字节操作流，默认每次执行写入会直接写入文件，
 */
public class CharStreamDemo {
   

    private static void in(){
   
        File file = new File("F:\\CodeDemo\\demo.txt");
        try {
   
            StringBuilder buf = new StringBuilder();
            Reader in = new FileReader(file);
            int len  = -1;
            char[] chars = new char[1];
            while ((len=in.read(chars)) != -1){
   
                buf.append(new String(chars,0,len));
            }
            System.out.println(buf);
            in.close();

        } catch (FileNotFoundException e) {
   
            e.printStackTrace();
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }

    private static void out(){
   
        File file = new File("F:\\CodeDemo\\demo.txt");
        try {
   
            Writer out = new FileWriter(file,true);
            out.write(",这hai是测试代码！");
            out.close();    //执行完close之后写入硬盘
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
   
        out();
        in();
    }
}

练习

import java.io.*;

public class Demo {
   
        public static void main(String[] args) {
   
                CopyFile("C:\\Users\\asus\\Pictures\\Camera Roll\\pic.jpg","C:\\Users\\asus\\Pictures\\Screenshots\\pic1.jpg");
        }

    private static void CopyFile(String src,String target){
   
        File srcFile = new File(src);
        File targetFile = new File(target);

        try {
   
            FileInputStream fileInputStream = new FileInputStream(srcFile);
            FileOutputStream fileOutputStream = new FileOutputStream(targetFile);
            int len = -1;
            byte[] bytes = new byte[1024];  //数组用来接受读取到的数据
            while ((len=fileInputStream.read(bytes))!=-1) {
    //循环里读取源文件的数据，直到读取到文件末，将长度赋值len
                fileOutputStream.write(bytes,0,len);    //读取一个字节，就将其写入目标文件，直到长度为len
            }
        } catch (IOException e) {
   
            e.printStackTrace();
        }
        }
    }

字节字符转换流

转换流：

**InputStreamReader：**可将输入的字符流转换为字节流输入形式。字符->字节
OutputStreamWriter：可将输出的字节流转化成字符流输出形式。字节->字符

package 字节字符流;

import java.io.*;
import java.nio.charset.Charset;

/**
 * 转换流
 * 内存只认识字节
 */


public class ChangeStreamDemo {
   
    private static void write(OutputStream out) {
      //内存里是字节，写出去到硬盘转成字符才行
        Writer writer = new OutputStreamWriter(out,Charset.forName("UTF-8"));
        try {
   
            writer.write("继续测试");
            writer.close(); //close以后才开始写入
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }


    private static void read(InputStream in) {
     //参数为输入流，输入到内存进行读取，可能是文件格式
        Reader reader = new InputStreamReader(in, Charset.forName("UTF-8")); //输入的字符流，到内存转成字节流
        char [] cs = new char[1024];
        int len = -1;

        try{
   
             while ((len=reader.read(cs))!= -1) {
   
                 System.out.println(new String(cs,0,len)