• 30.Java中的字节流【20220805】

    1.输入输出流

    输入输出流--读写文件
    输入--从文件中获取数据到自己的程序中接受处理【读】
    输出--将自己的程序中处理好的数据保存到文件中【写】
    流----数据的移动轨迹 

    2.流的分类

    按照数据的移动轨迹将流分为:输入流  输出流
    按照每一次读/写数据量的大小将流分为:字节流  字符流
    字节流：每一次可以读写一个字节的数据量,一个字节就是8位2进制，可以处理任何类型的文件【文本，图片，视频.......】
    字符流: 每一次可以读写一个字符的数据量，一个字符就是16位2进制，只能处理文本类型的数据。
    详细划分: 字节输入流  字节输出流  字符输入流  字符输出流

    3.字节流相关类的使用

    字节输出流---OutputStream---抽象类---不能new---子类

    FileOutputStream类

    FileOutputStream类构造方法：
    FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
    FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
    FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。  
    FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。

    1. package com.wangxing.test1;
    2.  
    3. import java.io.File;
    4. import java.io.FileOutputStream;
    5. import java.io.OutputStream;
    6.  
    7. public class TestFileOutputStream {
    8. 	public static void main(String[] args)throws Exception {
    9. 		String  filepath="F:"+File.separator+"mytest";
    10. 		File  file=new File(filepath);
    11. 		//FileOutputStream类构造方法：
    12. 		//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。
    13. 		FileOutputStream  out1=new FileOutputStream(file);
    14. 		OutputStream out11=new FileOutputStream(file);
    15. 		//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
    16. 		FileOutputStream  out2=new FileOutputStream(file,true);
    17. 		OutputStream out22=new FileOutputStream(file,true);
    18. 		//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。  
    19. 		FileOutputStream  out3=new FileOutputStream(filepath);
    20. 		OutputStream out33=new FileOutputStream(filepath);
    21. 		//FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。
    22. 		FileOutputStream  out4=new FileOutputStream(filepath,true);
    23. 		OutputStream out44=new FileOutputStream(filepath,true);
    24. 	}
    25. }

    FileOutputStream类实例方法:
    void    write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。 
    void    write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此        文件输出流。 
    void    write(int b) 将指定的字节写入此文件输出流。 
    void    close() 关闭此文件输出流并释放与此流相关联的任何系统资源。

    1. package com.wangxing.test1;
    2. import java.io.File;
    3. import java.io.FileOutputStream;
    4. public class TestFileOutputStream2 {
    5. 	public static void main(String[] args)throws Exception {
    6. 		//FileOutputStream类实例方法:
    7. 		//void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
    8. 		/*
    9. 		String data1="world";
    10. 		String  filepath1="F:"+File.separator+"mytest"+File.separator+"hello.txt";
    11. 		File  file1=new File(filepath1);
    12. 		FileOutputStream out1=new FileOutputStream(file1);
    13. 		out1.write(data1.getBytes());
    14. 		out1.close();
    15. 		*/
    16. 		
    17. 		//void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 
    18. 		/*
    19. 		String data2="hello,world";
    20. 		String  filepath2="F:"+File.separator+"mytest"+File.separator+"hello1.txt";
    21. 		File  file2=new File(filepath2);
    22. 		FileOutputStream out2=new FileOutputStream(file2,true);
    23. 		byte  bytearray[]=data2.getBytes();
    24. 		out2.write(bytearray,0,5);
    25. 		out2.close();
    26. 		*/
    27. 		
    28. 		//void	write(int b) 将指定的字节写入此文件输出流。
    29. 		/*
    30. 		String  filepath3="F:"+File.separator+"mytest"+File.separator+"hello2.txt";
    31. 		File  file3=new File(filepath3);
    32. 		FileOutputStream out3=new FileOutputStream(file3,true);
    33. 		out3.write(100);
    34. 		out3.close();
    35. 		*/
    36. 		String data3="hello,world";
    37. 		String  filepath3="F:"+File.separator+"mytest"+File.separator+"hello2.txt";
    38. 		File  file3=new File(filepath3);
    39. 		FileOutputStream out3=new FileOutputStream(file3,true);
    40. 		byte bytearray[]=data3.getBytes();
    41. 		for(int i=0;i
    42. 			out3.write(bytearray[i]);
    43. 		}
    44. 		out3.close();
    45. 		//void	close() 关闭此文件输出流并释放与此流相关联的任何系统资源。
    46. 	}
    47. }

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

    FileInputStream类

    FileInputStream类构造方法：
    FileInputStream(File file) 通过File对象创建一个字节输入流
    FileInputStream(String name) 通过String对象创建一个字节输入流

    1. package com.wangxing.test1;
    2. import java.io.File;
    3. import java.io.FileInputStream;
    4. import java.io.InputStream;
    5. public class TestFileInputStream1 {
    6. 	public static void main(String[] args)throws Exception {
    7. 		String  filepath="F:"+File.separator+"mytest"+File.separator+"hello2.txt";
    8. 		File  file=new File(filepath);
    9. 		//FileInputStream类构造方法：
    10. 		//FileInputStream(File file) 通过File对象创建一个字节输入流
    11. 		FileInputStream  in1=new FileInputStream(file);
    12. 		InputStream  in11=new FileInputStream(file);
    13. 		//FileInputStream(String name) 通过String对象创建一个字节输入流
    14. 		FileInputStream  in2=new FileInputStream(filepath);
    15. 		InputStream  in22=new FileInputStream(filepath);
    16. 	}
    17. }

    FileInputStream类实例方法
    int    read() 从该输入流读取一个字节的数据。 
    返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
    int    read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
    返回值:读取的总字节数， 如果到达文件末尾返回-1
    void    close() 关闭此文件输入流并释放与流相关联的任何系统资源。

     

    1. package com.wangxing.test1;
    2. import java.io.File;
    3. import java.io.FileInputStream;
    4. import java.io.InputStream;
    5. public class TestFileInputStream2 {
    6. 	public static void main(String[] args)throws Exception {
    7. 		//FileInputStream类实例方法
    8. 		//int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
    9. 		//返回值:读取的总字节数， 如果到达文件末尾返回-1
    10. 		/*
    11. 		String filepath1="F:"+File.separator+"mytest"+File.separator+"hello2.txt";
    12. 		File file1=new File(filepath1);
    13. 		FileInputStream  in1=new FileInputStream(file1);
    14. 		byte  bytearray[]=new byte[1024];
    15. 		int len=in1.read(bytearray);
    16. 		String  info=new String(bytearray,0,len);
    17. 		in1.close();
    18. 		System.out.println("info=="+info);
    19. 		*/
    20. 		
    21. 		//int	read() 从该输入流读取一个字节的数据。 
    22. 		//返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
    23. 		/*
    24. 		String filepath1="F:"+File.separator+"mytest"+File.separator+"hello2.txt";
    25. 		File file1=new File(filepath1);
    26. 		FileInputStream  in1=new FileInputStream(file1);
    27. 		int data=in1.read();
    28. 		in1.close();
    29. 		System.out.println("data=="+data);
    30. 		*/
    31. 		
    32. 		String filepath1="F:"+File.separator+"mytest"+File.separator+"hello2.txt";
    33. 		File file1=new File(filepath1);
    34. 		FileInputStream  in1=new FileInputStream(file1);
    35. 		byte  bytearray[]=new byte[100];
    36. 		int temp=0;
    37. 		int index=0;
    38. 		while((temp=in1.read())!=-1){
    39. 			bytearray[index]=(byte)temp;
    40. 			index++;
    41. 		}
    42. 		String info=new  String(bytearray,0,index);
    43. 		in1.close();
    44. 		System.out.println("info=="+info);
    45. 		//void	close() 关闭此文件输入流并释放与流相关联的任何系统资源。 
    46. 	}
    47. }

    DataOutputStream类

    DataOutputStream类的构造方法
    DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。 

    1. package com.wangxing.test2;
    2. import java.io.DataOutputStream;
    3. import java.io.File;
    4. import java.io.FileOutputStream;
    5. import java.io.OutputStream;
    6. public class TestDateOutputStream1 {
    7. 	public static void main(String[] args)throws Exception {
    8. 		//DataOutputStream类的构造方法
    9. 		//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。 
    10. 		String filepath="F:"+File.separator+"mytest"+File.separator+"data1.txt";
    11. 		File  file=new File(filepath);
    12. 		OutputStream out=new FileOutputStream(file,true);
    13. 		DataOutputStream  dataout=new DataOutputStream(out);
    14. 	}
    15. }

    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.wangxing.test2;
    2. import java.io.DataOutputStream;
    3. import java.io.File;
    4. import java.io.FileOutputStream;
    5. import java.io.OutputStream;
    6. public class TestDateOutputStream2 {
    7. 	public static void main(String[] args)throws Exception {
    8. 		//DataOutputStream类的实例方法
    9. 		String filepath="F:"+File.separator+"mytest"+File.separator+"data1.txt";
    10. 		File  file=new File(filepath);
    11. 		OutputStream out=new FileOutputStream(file,true);
    12. 		DataOutputStream  dataout=new DataOutputStream(out);
    13. 		int age=23;
    14. 		dataout.writeInt(age);
    15. 		double height=168.5;
    16. 		dataout.writeDouble(height);
    17. 		boolean sex=true;
    18. 		dataout.writeBoolean(sex);
    19. 		String  name="zhangsan";
    20. 		dataout.writeUTF(name);
    21. 		dataout.flush();
    22. 		dataout.close();
    23. 	}
    24. }

    DataInputStream类

    DataInputStream类构造方法
    DataInputStream(InputStream  in)创建使用指定的底层InputStream的DataInputStream。

    1. package com.wangxing.test2;
    2. import java.io.DataInputStream;
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.InputStream;
    6. public class TestDateInputStream1 {
    7. 	public static void main(String[] args)throws Exception {
    8. 		//DataInputStream类的构造方法
    9. 		//DataInputStream(InputStream out) 创建一个新的数据输入流，以将数据读取到指定的底层输入流。 
    10. 		String filepath="F:"+File.separator+"mytest"+File.separator+"data1.txt";
    11. 		File  file=new File(filepath);
    12. 		InputStream in=new FileInputStream(file);
    13. 		DataInputStream  datain=new DataInputStream(in);
    14. 	}
    15. }

    DataInputStream类实例方法
    boolean    readBoolean() 
    byte    readByte() 
    char    readChar() 
    double    readDouble() 
    float    readFloat() 
    int    readInt() 
    long    readLong() 
    short    readShort() 
    String    readUTF() 
    void    close() 

    1. package com.wangxing.test2;
    2. import java.io.DataInputStream;
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.InputStream;
    6. public class TestDateInputStream2 {
    7. 	public static void main(String[] args)throws Exception {
    8. 		//DataInputStream类实例方法
    9. 		String filepath="F:"+File.separator+"mytest"+File.separator+"data1.txt";
    10. 		File  file=new File(filepath);
    11. 		InputStream in=new FileInputStream(file);
    12. 		DataInputStream  datain=new DataInputStream(in);
    13. 		int age=datain.readInt();
    14. 		double height=datain.readDouble();
    15. 		boolean sex=datain.readBoolean();
    16. 		String name=datain.readUTF();
    17. 		datain.close();
    18. 		System.out.println("age=="+age+",height="+height+
    19. 				",sex="+sex+",name="+name);
    20. 	}
    21. }

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

    序列化和反序列化

    如果我们将一台计算机中的java对象，发送给另一台计算机识别，可能会因为不同的计算机中安装了不同JDK版本，从而造成java对象无法识别。所以就需要对传递的java对象进行序列化和反序列化。

    序列化---将一个java对象转换成2进制流数据过程。

    完成一个序列化需要创建对象的java类实现一个序列化接口【Serializable】
    序列化接口的定义 ： public interface Serializable
    这个接口的特殊之处就在于该接口中一个方法都没有。
    这个接口被视为是功能性接口，当某一个类实现了这个接口之后，就意味着具备序列化功能。

    ObjectOutputStream类

    ObjectOutputStream的构造方法
    ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream

    1. package com.wangxing.test3;
    2. import java.io.File;
    3. import java.io.FileOutputStream;
    4. import java.io.ObjectOutputStream;
    5. import java.io.OutputStream;
    6. public class TestObjectOutputStream1 {
    7. 	public static void main(String[] args)throws Exception {
    8. 		//ObjectOutputStream的构造方法
    9. 		//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream
    10. 		String  filepath="F:"+File.separator+"mytest"+File.separator+"object1.txt";
    11. 		File  file=new File(filepath);
    12. 		OutputStream out=new FileOutputStream(file);
    13. 		ObjectOutputStream objout=new ObjectOutputStream(out);
    14. 	}
    15. }

    序列化操作步骤:
    1.创建java类，实现序列化接口【Serializable】
    2.创建这个java类对象
    3.创建ObjectOutputStream字节输出流类对象
    4.使用ObjectOutputStream字节输出流类对象调用void    writeObject(Object obj) 将对象写出

    1. package com.wangxing.test3;
    2. import java.io.Serializable;
    3. public class Student implements Serializable{
    4. 	public void  testStudent(){
    5. 		System.out.println("Student类的实例方法");
    6. 	}
    7. }
    8.  
    9. package com.wangxing.test3;
    10. import java.io.File;
    11. import java.io.FileOutputStream;
    12. import java.io.ObjectOutputStream;
    13. import java.io.OutputStream;
    14. public class TestObjectOutputStream2 {
    15. 	public static void main(String[] args)throws Exception {
    16. 		//创建java类对象
    17. 		Student  student=new Student();
    18. 		//创建ObjectOutputStream类对象
    19. 		String filepath="F:"+File.separator+"mytest"+File.separator+"object.txt";
    20. 		File  file=new File(filepath);
    21. 		OutputStream  out=new FileOutputStream(file);
    22. 		ObjectOutputStream  objout=new ObjectOutputStream(out);
    23. 		//使用ObjectOutputStream字节输出流类对象调用writeObject(Object obj)将对象写出
    24. 		objout.writeObject(student);
    25. 		objout.close();
    26. 	}
    27. }

    反序列化---将2进制流数据转换成一个java对象的过程

    创建ObjectInputStream字节输入流类对象
    使用ObjectInputStream字节输入流类对象调用Object readObject()将数据读取成java对象

    ObjectInputStream类

    ObjectInputStream字节输入流类构造方法
    ObjectInputStream(InputStream  in) 创建一个读取指定的InputStream的ObjectInputStream

    1. package com.wangxing.test3;
    2. import java.io.File;
    3. import java.io.FileInputStream;
    4. import java.io.InputStream;
    5. import java.io.ObjectInputStream;
    6. public class TestObjectInputStream1 {
    7. 	public static void main(String[] args)throws Exception {
    8. 		//ObjectInputStream字节输入流类构造方法
    9. 		//ObjectInputStream(InputStream  in) 创建一个读取指定的InputStream的ObjectInputStream
    10. 		String  filepath="F:"+File.separator+"mytest"+File.separator+"object.txt";
    11. 		File file=new File(filepath);
    12. 		InputStream  in=new FileInputStream(file);
    13. 		ObjectInputStream objin=new ObjectInputStream(in);
    14. 	}
    15. }
    16.  
    17. package com.wangxing.test3;
    18. import java.io.File;
    19. import java.io.FileInputStream;
    20. import java.io.InputStream;
    21. import java.io.ObjectInputStream;
    22. public class TestObjectInputStream2 {
    23. 	public static void main(String[] args)throws Exception {
    24. 		//读取object.txt文件中的2进制数据成为一个Student类对象
    25. 		String  filepath="F:"+File.separator+"mytest"+File.separator+"object.txt";
    26. 		File file=new File(filepath);
    27. 		InputStream  in=new FileInputStream(file);
    28. 		ObjectInputStream objin=new ObjectInputStream(in);
    29. 		Object obj=objin.readObject();
    30. 		Student stu=(Student)obj;
    31. 		objin.close();
    32. 		stu.testStudent();
    33. 	}
    34. }
  • 相关阅读:
    前大厂员工谈中美企业区别，中企不用单元测试，仅靠QA检查代码？
    入坑机器学习：三，非监督学习
    python打包相关
    【Vue】vue2上传Excel表格到后台 实战教程（接上一篇下载Excel模板表格到本地）
    MATLAB画图分辨率、图像大小研究
    B03_02可转债转股
    信安软考 第十八章 网络安全测评技术与标准
    JavaWeb复习
    聊一聊Elasticsearch的一些基本信息
    【C++】316 去除重复字母
  • 原文地址：https://blog.csdn.net/guizhaiteng/article/details/126173652