• Java 字节流

    一、输入输出流

            输入输出 ------- 读写文件

            输入 ------- 从文件中获取数据到自己的程序中，接收处理【读】

            输出 ------- 将自己程序中处理好的数据保存到文件中【写】

            流 ------- 数据移动的轨迹

    二、流的分类

            按照数据的移动轨迹分为：输入流   输出流

            按照每一次读写/数据量的大小将流分成：字节流    字符流

            字节流：每一次可读写一个字节的数据量，一个字节就是8位2进制，可处理任何类型的文

                          件【文本、图片、视频........】

            字符流：每一次可读写一个字符的数据量，一个字符就是16位2进制，只能处理文本类型的

                           文件

    三、字节流相关类的使用

            字节输出流 --------- OutPutStream ------- 抽象类 ---------- 不能new --------- 需要找子类

            1.FileOutputStream类

            构造方法：

            FileOutputStream (File file) 通过File 对象创建一个不可追加的字节输出流

            FileOutoutStream (File file,boolean append) 通过File 对象创建一个可追加的字节输出流

            FileOutoutStream (String name) 通过字符串创建一个不可追加的字节输出流

            FileOutoutStream (String name,boolean append) 通过字符串创建一个可追加的字节输出流

    1. public class FileOutputStreamDemo1 {
    2.  
    3. 	public static void main(String[] args)throws Exception {
    4. 		String  path="F:"+File.separator+"test"+File.separator+"student.txt";
    5. 		//字节输出流--OutputStream--抽象类--FileOutputStream
    6. 		//FileOutputStream类的构造方法
    7. 		//FileOutputStream(String name) 通过String对象创建一个不可追加的字节输出流。  
    8. 		//参数String name--表示文件路劲【目标位置】
    9. 		OutputStream  out1=new FileOutputStream(path);
    10. 		FileOutputStream  out11=new FileOutputStream(path);
    11. 		//FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。
    12. 		//参数1String name--表示文件路劲【目标位置】
    13. 		//参数2boolean append--是否允许追加【true-追加，false-不追加】
    14. 		OutputStream  out2=new FileOutputStream(path,true);
    15. 		FileOutputStream  out22=new FileOutputStream(path,true);
    16. 		//推荐使用
    17. 		File  file=new File(path);
    18. 		//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
    19. 		//参数File file--表示文件路劲【目标位置】
    20. 		OutputStream  out3=new FileOutputStream(file);
    21. 		FileOutputStream  out33=new FileOutputStream(file);
    22. 		//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
    23. 		//参数1File file--表示文件路劲【目标位置】
    24. 		//参数2boolean append--是否允许追加【true-追加，false-不追加】
    25. 		OutputStream  out4=new FileOutputStream(file,true);
    26. 		FileOutputStream  out44=new FileOutputStream(file,true);
    27. 	}
    28. }

            实例方法：

            void write (byte[ ]  b) 将b.length个字节从字节数组写入此文件输出流

            void write (byte[ ] b,int off , int len) 将 len字节从位于偏移量 off的指定字节数组写入

            void write (int b) 将指定的字节写入此文件输出流

            void close( ) 关闭文件输出流并释放与此相关的任何系统资源

    1. public class TestFileOutputStream {
    2.     public static void main(String[] args) throws Exception{
    3.         String filepath = "F:"+         File.separator+"wangxinghomework"+File.separator+"20230902"+File.separator+"test.txt";
    4.         File file = new File(filepath);
    5.         FileOutputStream fileOutputStream = new FileOutputStream(file,true);
    6.         String data = "hello,zhaomin";
    7.         byte bytearray[] = data.getBytes();
    8.         fileOutputStream.write(bytearray);
    9.         fileOutputStream.close();
    10. //
    11.         fileOutputStream.write(bytearray,5,8);
    12.         fileOutputStream.write(97);
    13.         fileOutputStream.close();
    14.  
    15.     }
    16. }

           2. 字节输入流 ------ InputStream ------ 抽象类 ------- 不能new ------- 找子类

            FileInputStream 构造方法：

            FileInputStream(File file) 通过File对象创建一个字节输入流

            FileInputStream(String name) 通过String对象创建一个字节输入流

    1. public class TestFileInputStream {
    2.     public static void main(String[] args) throws Exception{
    3. //        FileInputStream类构造方法：
    4. //        	FileInputStream(File file) 通过File对象创建一个字节输入流
    5. //        	FileInputStream(String name) 通过String对象创建一个字节输入流
    6.         String filepath = "F:"+ File.separator+"wangxinghomework"+File.separator+"20230902"+File.separator+"test.txt";
    7.         File file = new File(filepath);
    8.         FileInputStream fileInputStream = new FileInputStream(file);
    9.         FileInputStream fileInputStream1 = new FileInputStream(filepath);
    10.     }
    11. }

           FileInputStream 实例方法：

           int read () 从该输入流读取一个字节的数据  ，返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1

            int read (byte[ ]  b) 从该输入流读取最多 b.length个字节的数据为字节数组 ，返回值:读取的总字节数， 如果到达文件末尾返回-1

            void    close() 关闭此文件输入流并释放与流相关联的任何系统资源

    1. public class TestFileInputStream {
    2.     public static void main(String[] args) throws Exception{
    3.     String filepath = "F:"+ File.separator+"wangxinghomework"+File.separator+"20230902"+File.separator+"test.txt";
    4.         File file = new File(filepath);
    5.         FileInputStream fileInputStream = new FileInputStream(file);
    6.         //读取一个字节read()
    7.         int value = fileInputStream.read();
    8.         String str1 = String.valueOf(value);//转成字符串String类型
    9.         fileInputStream.close();
    10.         System.out.println(str1+"ok");
    11.  
    12. //	int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组
    13.         //定义一个字节型数组，用来保存读出的数据
    14.         byte bytearray[] = new byte[(int) file.length()];
    15.         //定义一个临时保存读取来的数据
    16.         int temp = 0;
    17.         //定义一个数组下标
    18.         int index = 0;
    19.         while ((temp=fileInputStream.read()) != -1){
    20.             bytearray[index] = (byte)temp;
    21.             index++;
    22.         }
    23.         String str = new String(bytearray);
    24.         System.out.println(str);
    25.         fileInputStream.close();
    26.     }
    27. }

         3.DataOutputStream

            DataOutputStream 构造方法：

            DataInputStream(InputStream  in) 创建使用指定的底层InputStream的DataInputStream

            DataOutputStream 实例方法：

    void    writeBoolean(boolean v)将 boolean写入底层输出流作为1字节值
    void    writeByte(int v)将 byte作为1字节值写入底层输出流
    void    writeChar(int v)将 char写入底层输出流作为2字节值，高字节优先
    void    writeDouble(double v)双参数传递给转换 long使用 doubleToLongBits方法在类 Double，然后写入该 long值基础输出流作为8字节的数量，高字节
    void    writeFloat(float v)浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入 该 int值基础输出流作为一个4字节的数量，高字节。 
    void    writeInt(int v)将底层输出流写入 int作为四字节，高位字节
    void    writeLong(long v)将 long写入底层输出流，为8字节，高字节为首
    void    writeShort(int v)将 short写入底层输出流作为两个字节，高字节优先
    void    writeUTF(String str)使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
    void    flush()刷新此数据输出流
    void    close()关闭此输出流并释放与此流相关联的任何系统资源
    1. package com.homework.inouttest;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.File;
    5. import java.io.FileOutputStream;
    6.  
    7. public class TestDataOutputStream {
    8.     public static void main(String[] args) throws Exception{
    9.         //构造方法
    10.         //DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
    11.         String filepath = "F:"+ File.separator+"wangxinghomework"+File.separator+"20230902"+File.separator+"test1.txt";
    12.         File file = new File(filepath);
    13.         FileOutputStream out = new FileOutputStream(file,true);
    14.         DataOutputStream dataOutputStream = new DataOutputStream(out);
    15.  
    16.  
    17.         //DataOutputStream类的实例方法
    18.         //	void	writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
    19.         dataOutputStream.writeBoolean(true);
    20.  
    21.         //	void	writeByte(int v) 将 byte作为1字节值写入底层输出流。
    22.         dataOutputStream.writeByte(97);
    23.         //	void	writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
    24.         dataOutputStream.writeChar('b');
    25.         //	void	writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，		然后写入该 long值基础输出流作为8字节的数量，高字节。
    26.         dataOutputStream.writeDouble(16.2);
    27.         //	void	writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入		该 int值基础输出流作为一个4字节的数量，高字节。
    28.         dataOutputStream.writeFloat(17.2f);
    29.         //	void	writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
    30.         dataOutputStream.writeInt(23);
    31.         //	void	writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。
    32.         //	void	writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。
    33.         //	void	writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
    34.         dataOutputStream.writeUTF("wo ai ni");
    35.         //	void	flush() 刷新此数据输出流。
    36.         dataOutputStream.flush();
    37.         //	void	close() 关闭此输出流并释放与此流相关联的任何系统资源。
    38.         dataOutputStream.close();
    39.     }
    40. }

             4.DataInputStream类

                DataInputStream类构造方法

                DataInputStream(InputStream  in)创建使用指定的底层InputStream的DataInputStream。

                DataInputStream类实例方法

    boolean    readBoolean() 
    byte    readByte()
    char    readChar()
    double    readDouble() 
    float    readFloat()
    int    readInt()
    long    readLong()
    short    readShort()
    String    readUTF()
    void    close()
    1. package com.homework.inouttest1;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.File;
    5. import java.io.FileInputStream;
    6.  
    7. public class TestDataInputStream {
    8.     public static void main(String[] args) throws Exception{
    9.         //构造方法
    10.         //DataInuptStream(InputStream in)
    11.         String filepath = "F:"+ File.separator+"wangxinghomework"+File.separator+"20230902"+File.separator+"test1.txt";
    12.         File file = new File(filepath);
    13.         FileInputStream inputStream = new FileInputStream(file);
    14.         DataInputStream dataInputStream = new DataInputStream(inputStream);
    15.  
    16.         //实例方法
    17.         //boolean	readBoolean()
    18.         boolean flag = dataInputStream.readBoolean();
    19.         //byte	readByte()
    20.         byte byt = dataInputStream.readByte();
    21.         //	char	readChar()
    22.         char cha = dataInputStream.readChar();
    23.         //	double	readDouble()
    24.         double dou = dataInputStream.readDouble();
    25.         //	float	readFloat()
    26.         float flo = dataInputStream.readFloat();
    27.         //	int	readInt()
    28.         int in = dataInputStream.readInt();
    29.         //	long	readLong()
    30.         //	short	readShort()
    31.         //	String	readUTF()
    32.         String str = dataInputStream.readUTF();
    33.         //	void	close()
    34.         dataInputStream.close();
    35.         System.out.println(flag+","+byt+","+cha+","+dou+","+flo+","+in+","+str);
    36.     }
    37. }

            优点:可以直接写出基本数据类型的数据和String，且不需要转换成字节数组
            缺点:保存到文件中的数据是乱码

          5.序列化

            将一个java对象转换成2进制流数据过程，因为我们做操作的java对象可能需要在多台计算机之间传递

            如何实现序列化？

            (1).为被序列化的java对象的生成类实现一个序列化接口【Serializable】
                public interface Serializable特殊----该接口中一个方法都没有，类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化。
    可序列化类的所有子类型都是可序列化的。

            (2).通过java提供ObjectOutputStream类的writeObject(Object obj)

                 ObjectOutputStream的构造方法
                 ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。 
                 实例方法
                  void    writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

            6.反序列化

               将2进制流数据转换成java对象的过程，需要ObjectInputStream类的Object  readObject()方法读取对象

               ObjectInputStream类的构造方法
                        ObjectInputStream(InputStream  in)
                ObjectInputStream类的实例方法
                        Object    readObject() 从ObjectInputStream读取一个对象

    1. package com.homework.inouttest1;
    2.  
    3. import java.io.Serializable;
    4.  
    5. public class Student implements Serializable {
    6.     //实例方法，测试用
    7.     public void learn(){
    8.         System.out.println("Student类的实例方法");
    9.     }
    10. }
    1. package com.homework.inouttest;
    2.  
    3. import com.homework.inouttest1.Student;
    4.  
    5. import java.io.File;
    6. import java.io.FileOutputStream;
    7. import java.io.ObjectOutputStream;
    8.  
    9. //ObjectOutputStream(Object obj)
    10. public class ObjectOutTest {
    11.     public static void main(String[] args) throws Exception{
    12.         String filepath = "F:"+ File.separator+"student.txt";
    13.         File file = new File(filepath);
    14.         FileOutputStream outputStream = new FileOutputStream(file);
    15.         ObjectOutputStream out = new ObjectOutputStream(outputStream);
    16.  
    17.         Student student = new Student();
    18.         out.writeObject(student);
    19.         out.close();
    20.         outputStream.close();
    21.  
    22.     }
    23. }
    1. package com.homework.inouttest1;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.ObjectInputStream;
    6.  
    7. public class ObjectInputTest {
    8.     public static void main(String[] args) throws Exception{
    9.         String filepath =  "F:"+ File.separator+"student.txt";
    10.         File file = new File(filepath);
    11.         FileInputStream fileInputStream = new FileInputStream(file);
    12.         ObjectInputStream in = new ObjectInputStream(fileInputStream);
    13.         Object objstudent=in.readObject();
    14.         Student studentst = (Student)objstudent;
    15.         in.close();
    16.         fileInputStream.close();
    17.         studentst.learn();
    18.     }
    19. }

    从D盘复制jpg类型文件到H盘

    1. package com.homework.inouttest;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileOutputStream;
    6.  
    7. public class CopyTest {
    8.     public static void main(String[] args)throws Exception {
    9.         //定义D盘路径
    10.         String filepath = "D:"+ File.separator;
    11.         //创建文件对象
    12.         File file = new File(filepath);
    13.         //获取D盘所有文件名称
    14.         File myfilelist[] = file.listFiles();
    15.         for (File d_file:myfilelist) {
    16.             String filename = d_file.getName();
    17.             int houzhui = filename.lastIndexOf(".");
    18.             if (houzhui != -1){
    19.                 String houzhuiname = filename.substring(houzhui);
    20.                 if (houzhuiname.equals(".jpg")) {
    21.                     //拼接文件路径
    22.                     String jpgpath = filepath + filename;
    23.                     FileInputStream fileInputStream = new FileInputStream(jpgpath);
    24.                     //定义H盘路径
    25.                     String newpath = "H:"+filename;
    26.                     File newfile = new File(newpath);
    27.                     FileOutputStream fileOutputStream = new FileOutputStream(newfile);
    28.                     int temp = 0;
    29.                     while ((temp = fileInputStream.read()) != -1) {
    30.                         fileOutputStream.write(temp);
    31.                     }
    32.                     fileInputStream.close();
    33.                     fileOutputStream.close();
    34.                 }
    35.             }
    36.         }
    37.     }
    38. }

  • 相关阅读:
    python 读取文件 下载文件
    vue jsx 封装Table 表格+Tree 树形控件 jsx自定义el-table-column
    第一个ABAP ALV报表程序构建流程
    c++多线程（一）线程管理
    QML控件类型：TabBar
    ajax 接口上传
    Win10下使用WinSCP+PuTTY实现远程文件操作和终端访问
    虚拟摄像头之八: 从 Camera api2 角度看摄像头框架
    不同架构的详细分析VIP架构
    微信小程序会议OA系统其他页面
  • 原文地址：https://blog.csdn.net/zqm_1994/article/details/133123170