Input / output stream in java

Input / output stream in java (2)

1, Commonly used byte input and byte output stream classes

1. Byte output stream - top class OutputStream

Definition - public abstract class OutputStream - cannot be new

Byte output stream ----- FileOutputStream class

Definitions - public class fileoutputstream extensions OutputStream

Construction method

1.FileOutputStream(File file) creates a non appendable byte output stream through the File object.

2. Fileoutputstream (File, Boolean append) creates a whether to trace through the File object
Added byte output stream.

3.FileOutputStream(String name) creates a non appendable byte output stream through a String object.

4.FileOutputStream(String name, boolean append) creates a byte output stream whether to append or not through a String object
For example:

package com.shuchu.gouzao.java;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//1.FileOutputStream(File file) creates a non appendable byte output stream through the File object. 
		String path = "E:"+File.separator+"test"+"name.txt";
		File le = new File(path);
		FileOutputStream out = new FileOutputStream(le);
		OutputStream outt = new FileOutputStream(le);
		//2. Fileoutputstream (File, Boolean append) creates a whether to trace through the File object
		//Added byte output stream.
		FileOutputStream out2 = new FileOutputStream(le,true);
		//3.FileOutputStream(String name) creates a non appendable byte output stream through a String object.  
		FileOutputStream out3 = new FileOutputStream(path);
		OutputStream out4 = new FileOutputStream(path);
		//4.FileOutputStream(String name, boolean append) creates a byte output stream whether to append or not through a String object
		FileOutputStream out5 = new FileOutputStream(path,true);
	}
}

Example method

1.void write(byte[] b) writes b.length bytes from the specified byte array to the file output stream.

2.void write(byte[] b, int off, int len) writes len bytes to the file output stream from the specified byte array at offset off.

3.void write(int b) writes the specified bytes to this file output stream.

4.void close() closes the file output stream and frees any system resources associated with the stream.

For example:

package com.shuchu.fangfa.java;
import java.io.File;
import java.io.FileOutputStream;
public class Test {
	public static void main(String[] args) throws Exception{
		//Output the data to a file by writing out the output stream
		//Prepare the data to be written out
		String hl = "Hello,World";
		//Create byte output stream object
		String wj = "E:"+File.separator+"text"+File.separator+"name.txt";
		File le = new File(wj);
		FileOutputStream out = new FileOutputStream(le,true);
		/*
		//1.void	write(byte[] b) Writes b.length bytes from the specified byte array to this file output stream.
		out.write(hl.getBytes());
		//4.void	close() Close this file output stream and free up any system resources associated with this stream.
		out.close();
		*/
		/*
		//2.void	write(byte[] b, int off, int len) Writes len bytes to this file output stream from the specified byte array at offset off.
		byte b[] = hl.getBytes();
		out.write(b,6,5);
		//Close flow
		out.close();
		*/
		//3.void 	 write(int b) writes the specified bytes to this file output stream. [write out only one byte at a time]
		byte arry[] = hl.getBytes(); 
		for(byte te:arry) {
			out.write(te);
		}
		//Close flow
		out.close();
	}
}

Execution result:

Note: you can only write out the basic data type of the above stream, but not the bytes

Public class dataoutputstream extensions filteroutputstream implements dataoutput class

The data output stream enables applications to write raw Java data types to the output stream in a portable manner

Construction method

1.DataOutputStream(OutputStream out) creates a new data output stream to write data to the specified underlying output stream.

For example:

package com.DataOutputStream.gouzao.java;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//1.DataOutputStream(OutputStream out) creates a new data output stream to write data to the specified underlying output stream.
		String path = "E:"+File.separator+"text"+File.separator+"id.txt";
		File le = new File(path);
		FileOutputStream out = new FileOutputStream(le);
		OutputStream outt = new FileOutputStream(le);
		DataOutputStream out2 = new DataOutputStream(out);
	}
}

Example method:
1.void writeBoolean(boolean v) writes boolean to the underlying output stream as a 1-byte value.

2.void writeByte(int v) writes byte as a 1-byte value to the underlying output stream.

3.void writeChar(int v) writes char to the underlying output stream as a 2-byte value, with the high byte taking precedence.

4.void The writeDouble(double v) Double parameter is passed to the conversion long. Use the doubleToLongBits method in the class Double, and then write the long value to the basic output stream as the number of 8 bytes, high bytes.

5.void writeFloat(float v) the conversion int of the Float parameter uses the floatToIntBits method in the class Float, and then writes the int value to the basic output stream as a 4-byte quantity, high byte.

6.void writeInt(int v) writes the underlying output stream to int as a four byte, high-order byte.

7.void writeLong(long v) writes long to the underlying output stream, which is 8 bytes, with the high byte first.

8.void writeShort(int v) writes short to the underlying output stream as two bytes, with the high byte taking precedence.

9.void writeUTF(String str) writes a string to the underlying output stream in a machine independent manner using modified UTF-8 encoding.

10.void flush() refreshes this data output stream.

11.void close() closes the output stream and frees any system resources associated with the stream.
For example:

package com.DataOutputStream.fangfa.java;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//DataOutputStream(OutputStream out) creates a new data output stream to write data to the specified underlying output stream. 
		String path = "E:"+File.separator+"chen"+File.separator+"id.txt";
		File le = new File(path);
		FileOutputStream out = new FileOutputStream(le);
		DataOutputStream outt = new DataOutputStream(out);
		//1.void 	 writeBoolean(boolean v) writes boolean to the underlying output stream as a 1-byte value.
		outt.writeBoolean(true);
		//3.void 	 writeChar(int v) writes char to the underlying output stream as a 2-byte value, with the high byte taking precedence.
        outt.writeChar('\t');
        //2.void 	 writeByte(int v) writes byte as a 1-byte value to the underlying output stream. 
        outt.writeByte(30);
        outt.writeChar('\t');
       //4.void 	 The writeDouble(double v) Double parameter is passed to the conversion long. Use the doubleToLongBits method in the class Double, and then write the long value to the basic output stream as the number of 8 bytes, high bytes. 
        outt.writeDouble(123.1);
        outt.writeChar('\t');
        //5.void 	 writeFloat(float v) the conversion int of the Float parameter uses the floatToIntBits method in the class Float, and then writes the int value to the basic output stream as a 4-byte quantity, high byte. 
        outt.writeFloat(12.5f);
        outt.writeChar('\t');
        //6.void 	 writeInt(int v) writes the underlying output stream to int as a four byte, high-order byte. 
        outt.writeInt(200);
        outt.writeChar('\t');
        //7.void 	 writeLong(long v) writes long to the underlying output stream, which is 8 bytes, with the high byte first.
        outt.writeLong(80000);
        outt.writeChar('\t');
        //8.void 	 writeShort(int v) writes short to the underlying output stream as two bytes, with the high byte taking precedence. 
        outt.writeShort(30);
        outt.writeChar('\t');
        //9.void 	 writeUTF(String str) writes a string to the underlying output stream in a machine independent manner using modified UTF-8 encoding. 
        outt.writeUTF("lisi");
        outt.writeChar('\t');
        //10.void 	 flush() refreshes this data output stream.
        outt.flush();
        //11.void 	 close() closes the output stream and frees any system resources associated with the stream. 
        outt.close();
        out.close();
	}
}

2. Byte output stream - top class InputStream

public abstract class InputStream - cannot new

Public class FileInputStream extensions InputStream class
Construction method

1.FileInputStream(File file) creates a byte input stream through the File object

2.FileInputStream(String name) creates a byte input stream through a String object
For example:

package com.FileInputStream.gouzao.java;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//1.FileInputStream(File file) creates a byte input stream through the File object
		String path = "E:"+File.separator+"text"+"name.txt";
		File le = new File(path);
		FileInputStream in = new FileInputStream(le);
		InputStream  intt = new FileInputStream(le);
		//2.FileInputStream(String name) creates a byte input stream through a String object
		FileInputStream in2 = new FileInputStream(path);
		InputStream  inttt = new FileInputStream(path);
	}
}

Example method
1.int read() reads one byte of data from the input stream.
Return value: the int type of the specific byte data read. If it reaches the end of the file, it returns - 1

2.int read(byte[] b) reads up to b.length bytes of data from the input stream, which is a byte array.
Return value: the total number of bytes read. If it reaches the end of the file, it returns - 1

3.void close() closes the file input stream and frees any system resources associated with the stream.
For example:

package com.FileInputStream.fangfa.java;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//Read name Txt into our program
		String path ="E:"+File.separator+"text"+File.separator+"name.txt";
		//Create the corresponding field object according to the file path
		File le = new File(path);
		//Create byte input stream object
		FileInputStream in = new FileInputStream(le);
		/*
		//1.int	read() Read one byte of data from the input stream. Return value: the int type of the specific byte data read. If it reaches the end of the file, it returns - 1
		byte arry[] = new byte[(int)le.length()];
		int len = in.read(arry);
		//Close flow
		in.close();
		String name = new String(arry,0,len);
		System.out.println(name);
		*/
		//2.int 	 read(byte[] b) reads up to b.length bytes of data from the input stream, which is a byte array. Return value: the total number of bytes read. If it reaches the end of the file, it returns - 1
		byte arry2[] = new byte[(int)le.length()];
		//Save the data value read each time
		int data = 0;
		//Array subscript
		int len2 = 0;
		while((data = in.read())!=-1) {
			arry2[len2]=(byte)data;
			len2++;
		}
		//Close flow
		in.close();
		String name2 = new String(arry2,0,len2);
		System.out.println(name2);
	}
}

Public class datainputstream extensions filterinputstream implements datainputstream class

Construction method
1.DataInputStream(InputStream in) creates a DataInputStream that uses the specified underlying InputStream.
For example:

package com.DataInputStream.gouzao.java;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//1.DataInputStream(InputStream in) creates a DataInputStream that uses the specified underlying InputStream.
		String path = "E:"+File.separator+"chen"+"id.txt";
		File le = new File(path);
		FileInputStream in = new FileInputStream(le);
		DataInputStream inn = new DataInputStream(in);
	}
}

Example method
1.void readBoolean(boolean v) reads boolean into the underlying output stream as a 1-byte value.

2.void readByte(int v) reads byte as a 1-byte value into the underlying output stream.

3. Void readchar (int V) reads char into the underlying output stream as a 2-byte value, with high byte taking precedence.

4.void The readDouble(double v) Double parameter is passed to the conversion long. Use the doubleToLongBits method in the class Double, and then read the long value into the basic output stream as the number of 8 bytes, high bytes.

5.void readFloat(float v) the conversion int of Float parameter uses the floatToIntBits method in the class Float, and then reads the int value into the basic output stream as a 4-byte quantity, high byte.

6.void readInt(int v) reads the underlying output stream into int as four bytes and high-order bytes.

7.void readLong(long v) reads long into the underlying output stream, which is 8 bytes, with the high byte first.

8.void readShort(int v) reads short into the underlying output stream as two bytes, and the high byte takes precedence.

9.void readUTF(String str) reads strings into the underlying output stream in a machine independent manner using modified UTF-8 encoding.

10.void close() closes the output stream and frees any system resources associated with the stream.
For example:

package com.DataInputStream.fangfa.java;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		//DataInputStream(InputStream in) creates a DataInputStream that uses the specified underlying InputStream.
		String path = "E:"+File.separator+"chen"+File.separator+"id.txt";
		File le = new File(path);
		FileInputStream in = new FileInputStream(le);
		DataInputStream inn = new DataInputStream(in);
		//1.void 	 readBoolean(boolean v) reads boolean into the underlying output stream as a 1-byte value.
		boolean vau = inn.readBoolean();
		//3. Void readchar (int V) reads char into the underlying output stream as a 2-byte value, with high byte taking precedence. 
		char  zf = inn.readChar();
		//2.void 	 readByte(int v) reads byte as a 1-byte value into the underlying output stream. 
		 byte zj = inn.readByte();
		char  zf1 = inn.readChar();
		//4.void 	 The readDouble(double v) Double parameter is passed to the conversion long. Use the doubleToLongBits method in the class Double, and then read the long value into the basic output stream as the number of 8 bytes, high bytes. 
		double v = inn.readDouble();
		char  zf2 = inn.readChar();
		//5.void 	 readFloat(float v) the conversion int of Float parameter uses the floatToIntBits method in the class Float, and then reads the int value into the basic output stream as a 4-byte quantity, high byte. 
        float dan = inn.readFloat();
        char  zf3 = inn.readChar();
        //6.void 	 readInt(int v) reads the underlying output stream into int as four bytes and high-order bytes. 
        int num = inn.readInt();
        char  zf4 = inn.readChar();
        //7.void 	 readLong(long v) reads long into the underlying output stream, which is 8 bytes, with the high byte first.
        long chang = inn.readLong();
        char  zf5 = inn.readChar();
        //8.void 	 readShort(int v) reads short into the underlying output stream as two bytes, and the high byte takes precedence. 
        short duan = inn.readShort();
        char  zf6 = inn.readChar();
        //9.void 	 readUTF(String str) reads strings into the underlying output stream in a machine independent manner using modified UTF-8 encoding. 
        String str = inn.readUTF();
        char  zf7 = inn.readChar();
        //10.void 	 close() closes the output stream and frees any system resources associated with the stream. 
        inn.close();
        in.close();
        System.out.println(vau);
        System.out.println(zf);
        System.out.println(zj);
        System.out.println(zf1);
        System.out.println(v);
        System.out.println(zf2);
        System.out.println(dan);
        System.out.println(zf3);
        System.out.println(num);
        System.out.println(zf4);
        System.out.println(chang);
        System.out.println(zf5);
        System.out.println(duan);
        System.out.println(zf6);
        System.out.println(str);
        System.out.println(zf7);   
	}
}

Execution result:

2, What is serialization? How to implement serialization?

Because the java objects we operate on may need to be passed between multiple computers.

Serialization ---- the process of converting a java object into binary stream data.

Deserialization - the process of converting binary stream data into a java object.

How to implement serialization?
1. Implement a Serializable interface for the generated class of the serialized java object
public interface Serializable
Special - there is no method in this interface.

Class serialization is implemented by Java io. The class of the serializable interface is enabled. Classes that do not implement this interface will not serialize or deserialize any state. All subtypes of a serializable class are serializable.

2. Provide writeObject(Object obj) of ObjectOutputStream class through java
Construction method of ObjectOutputStream

ObjectOutputStream(OutputStream out) creates an ObjectOutputStream that writes to the specified OutputStream.

Example method
void writeObject(Object obj) writes the specified object to ObjectOutputStream.

For example:

package com.ObjectOutputStream.java;
import java.io.Serializable;
public class Student implements Serializable{
	public void shiLi() {
		System.out.println("This is Student Example method of");
	}
}

Write Student object to Notepad

package com.ObjectOutputStream.java;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class Test {
	public static void main(String[] args) throws Exception {
		Student stu = new Student();
		//ObjectOutputStream(OutputStream out) creates an ObjectOutputStream that writes to the specified OutputStream. 
		String path = "E:"+File.separator+"lianxi"+File.separator+"student.txt";
		File le = new File(path);
		FileOutputStream out = new FileOutputStream(le);
		ObjectOutputStream outt = new ObjectOutputStream(out);
		//void 	 writeObject(Object obj) writes the specified object to ObjectOutputStream. 
		outt.writeObject(stu);
		outt.flush();
		outt.close();
		out.close();
	}
}

Execution result:

Serialize the above java object into the notepad file and deserialize it back into a usable java object. At this point, you need the object readObject () method of ObjectInputStream class to read the object.

ObjectInputStream class

Construction method

ObjectInputStream(InputStream in) creates an ObjectInputStream read from the specified InputStream.

Example method

Object readObject() reads an object from ObjectInputStream.
For example:

package com.ObjectInputStream.java;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import com.ObjectOutputStream.java.Student;
public class Test {
	public static void main(String[] args) throws Exception {
		//ObjectInputStream(InputStream out) creates an ObjectInputStream read from the specified InputStream. 
		String path = "E:"+File.separator+"lianxi"+File.separator+"student.txt";
		File le = new File(path);
		FileInputStream in = new FileInputStream(le);
		ObjectInputStream inn = new ObjectInputStream(in);
		//Object 	 readObject() reads an object from ObjectInputStream. 
		Object o = inn.readObject();
		inn.close();
		in.close();
		Student stu = (Student)o;
		stu.shiLi();
	}
}

Execution result:

io structure:

Tags: Java stream

Posted by ddc on Fri, 20 May 2022 18:13:35 +0300