Location>code7788 >text

io stream

Popularity：332 ℃/2025-03-26 23:02:12

io stream

Java is to operate the File class provided by the file. File represents text and io stream reads and writes data.

File

Create an object

public File(String pathname)
     //Create file object according to file path
     //In the path, D:/resource is enough. The backslash needs to be written with two escapes. D:\\resource
     //Separator---Constant
     //Generally use relative paths
public File(String parent,String child)
 //Create file object based on parent path and child path name
 public File(File parent,String child)
 //Create file objects based on the corresponding file objects and child path names of the parent path corresponding to the file objects and the child path names

Determine file type and obtain file information

  • Many methods are recommended to check it yourself
//1. Create a file object, referring to a file
 File f1 = new File(pathname:"D:/resource/");
 //2. public boolean exists(): determines whether the corresponding file path exists in the current file object, and returns true if it exists.

 //3. pubLic boolean isFile(): determines whether the current file object refers to a file, and returns true if it is a file, otherwise.

 //4. pubLic boolean isDirectory(): determines whether the current file object refers to a folder. It returns true if it is a folder, otherwise.

 // String getName(): Get the name of the file (including the suffix)

 // long length (: Get the file size, return the number of bytes

 // String qetPath(): Get the path used when creating a file object

 // String getAbsolutePath(): Get the absolute path

Create and delete files

1. public boolean createNewFile(): Create a new file (the file content is empty), and return true after successful creation.
    
 2. public boolean mkdir(): used to create folders, note: create first-level folders
    
 3. public boolean mkdirs(): used to create folders. Note: Multi-level folders can be created.
    
 3. public boolean delete(): Do not remove files or empty files. Note: You cannot unless you have an empty folder.
     //Removing non-empty requires recursive deletion

Traverse folders

//1. public String[] List(): Get all "first-level file names" in the current directory and return it into a string array.
 File f1 new File(pathname:"")
 //2. public File[] listFiles(): (key point) Get all "level file objects" in the current directory and return it into the file object array (key point)

When using listFiles methodThings to note：

  • Return null when the main call is a file or the path does not exist
  • When the main call is an empty folder, return an array of length 0
  • When the main call is a folder with content, put the paths of all first-level files and folders in it in the File array and return
  • When the main call is a folder and there are hidden files inside, put the paths of all files and folders in it in the Flie array and return it, including hidden files
  • When the main call is a folder but does not have permission to access the folder, return null

Method recursion

Understand recursion

Adjust yourself

Application, execution process, algorithm ideas

Fibonacci sequences, binary trees, etc.

File Search

Recursion is a classic and recommended to read more

public static void searchFile(File dir,String fileName){
	 //1. Intercept all illegal situations
	 if(dir == null ll !() || ()){
		 return;// means that search cannot be done
	 //2. dir is not nuLl, it exists, it must be a directory object.
	 //Get all first-level file objects in the current directory.
	 File[] files=();
	 //3. Determine whether there is a first-level file object in the current directory and whether it can obtain the first-level file object.
	 if(files != null && > θ){
	 //4. Traverse all first-level file objects.
	 for (File f : files){
	 //5. Determine whether a file is a file or a folder
		 if(()){
		 //It's a file, determine whether the file name is what we are looking for
			 if(().contains(fileName)){
				 ("Finished:"+());
             }
         }else {
             //It's a folder, repeat
             searchFile(f,fileName);
		 }
     }

Character Set

Common character sets

To process information, characters need to be stored in the computer. The computer can only store 01, so it is encoded so the character set is generated:

  • ASCII character set---1 byte storage, the first bit must be zero, because 7 bits are enough but not 8 bits, so add zero
  • GBK, national standard, one Chinese two byte storage, compatible with ASCIII, the first digit of Chinese characters must be 1, when decoding, it will decode two bytes of Chinese, and when decoding, it will decode zero, it will be English and numbers, etc.
  • Unicode character set, Unicode code, accommodates all text and matching character sets in the world, 4 bytes, and directly 4 4 decodes
    • Disadvantages occupy storage space and reduce communication efficiency

UTF-8, a Unicode character set born to solve its shortcomings, variable length solution

  • English characters, numbers, etc. only account for 1 byte (compatible with standard ASCII encoding), Chinese characters occupy 3 bytes
  • image-20250326193141074

Encoding and decoding

  • byte[] getBytes()---------------------------------------------------------------------------------------------------------------------
  • byte[] getBytes(String charsetName)-----Encoding the String into a series of bytes using the specified character set, storing the result into a new byte array
  • String(byte[] bytes)----Construct a new String by decoding a specified byte array using the platform's default character set
  • String(byte[] bytes,String charsetName)----Construct a new String by decoding the specified byte array by the specified character set.

Io flow classification

  1. I refers to lnput, called input stream: responsible for reading data into memory
  2. O refers to Output, called output stream: responsible for writing data out

image-20250326193631719

Summary of four major categories of flow:

  • Byte input stream (InputStream): A stream that reads data from disk files/network into memory in the form of bytes based on memory.
  • Byte output stream (OutStream): A stream that writes data in memory in bytes to disk files or network based on memory.
  • Character input stream (Reader): A stream that reads data from disk files/network into memory in the form of characters based on memory.
  • Character output stream (Writer): A stream that writes the data in memory into a disk file or network medium based on memory as a reference.

io byte stream

FileInputStream

public FileInputStream(File file) //Create the byte input stream pipeline and connect to the source file
 public FileInputStream(String pathname) //Create the byte input stream pipeline and connect to the source file
public int read()
 //Return one byte each time, and if you find that there is no data to read, it will return -1.
 //Each time, use a byte array to read data, and return how many bytes have been read by the byte array.

Only one can be read at a time using Read. At the same time, if Chinese characters are multiple bytes, the code will appear.

public int read(byte[] buffer)
 //If you find that there is no data to read, it will return -1.
  //2. Start reading byte data in the file: read multiple bytes at a time.
 byte[] buffer new byte[3];
 int len ​​= (buffer);
 String rs new String(buffer);
 (rs);
 ("Number of bytes read this time: "+len):
 //buffer [abci
 //buffer [66c]
 //The buffer will overwrite Remember to control
 int len2 = (buffer);
 String rs2 = new String(buffer);
 (rs2);
 ("Number of bytes read this time:"+Len2):

You can read it directly, but it may also destroy the encoding of Chinese characters.

File byte input stream: Read all bytes at once

  1. Define buffer large enough to read at one time

    • Obviously not very reasonable

  2. readAllBytes

    byte[]buffer=();
 (new String(buffer));
 //The file is too large and there will be problems.

  3. Use character streams to read and write text, and the above two byte streams are not suitable

FileOutStream

File byte output stream: write bytes out

public FileOutputStream(File file)//Create a byte output stream pipeline and connect to the source file object
 public FileOutputStream(String filepath)//Create the byte output stream pipeline and connect to the source file path
 public FileOutputStream(File file,boolean append)
 //Create a byte output stream pipeline and connect it to the source file object, and add data
 public File0utputStream(String filepath,boolean append)
 //Create the byte output stream pipeline and connect it to the source file path, and add data

 public void write(int a)
 //Write a byte out
 public void write(byte[] buffer)
 //Write a byte array out
 public void write(byte[] buffer, int pos, int len)
 //Write a part of a byte array out.
 public void close() throws I0Exception
 //Close the stream.

io stream-resource release method

To ensure closing, exception handling is required

try-catch-finally

  • Features of the finally code area: Whether the program in the try is executed normally or an exception occurs, the finally area will be executed in the end unless the VM terminates.
  • Function: It is generally used to release resources after the program execution is completed (professional practice).

try-with-resource

jdk7 new

try(Define resource 1;Define resource 2;...){
		 Code that may appear exceptions;
 }catch(Exception class name variable name){
		 Exception handling code;
 }

io character stream

  • Byte stream: suitable for copying files, etc., not suitable for reading and writing text files
  • Character stream: suitable for reading and writing text file content

FileReader

public FileReader(File file)
 //Create the character input stream pipeline and connect to the source file
 public FileReader(String pathname)
 //Create the character input stream pipeline and connect to the source file

 public int read()
 //Return one character each time, if you find that there is no data to read, it will return -1·
 //Each time, use a character array to read data, and return how many characters are read by the character array.
 public int read(char[]buffer)
 //If you find that there is no data to read, it will return -1.

FileWrite

public FileWriter(File file)
 //Create the byte output stream pipeline and connect to the source file object
 public FileWriter(String filepath)
 //Create the byte output stream pipeline and connect to the source file path
 public FileWriter(File file,boolean append)
 //Create a byte output stream pipeline and connect it to the source file object, and add data
 public FileWriter(String filepath,boolean append)
 //Create the byte output stream pipeline and connect it to the source file path, and add data

 void write(int )
 //Write a character
 void write(String str)
 //Write a string
 void write(String str,int off,int len)
 //Write a part of a string
 void write(char[] cbuf)
 //Write a character array
 void write(char] cbuf, int off, int len)
 //Write part of the character array
  • Things to note

After the character output stream writes out the data, the stream must be refreshed or closed, so that the written data can take effect.

();//Refresh the stream
 ();//Close refresh, but close it cannot be used

io buffered stream

BufferedInputStream //Byte buffered input stream
 BufferedOutputStream //Byte buffered output stream
 BufferedReader // Character buffer input stream
 BufferedWriter // Character buffered output stream

Buffer streams improve read and write performance, and buffers are born to improve performance.

image-20250326200830340

Inputstream is = new FileInputStream(name:"io-app2/src/");
 //1. Define a byte buffered input stream to wrap the original byte input stream
 InputStream bis = new BufferedInputstream(is, 8192*2);//size
 //Encapsulation can directly new BufferedInputstream(new FileInputStream(name:"io-app2/src/"),8192*2)

 Outputstream os = new Fileoutputstream(name:"io-app2/src/itheima01_bak.txt");
 //2. Define a byte buffered output stream to wrap the original byte output stream
 Outputstream bos = new BufferedOutputstream(os);
public BufferedReader(Reader r)
 //Package low-level character input streams into character buffer input stream pipelines, thereby improving the performance of character input stream reading character data
 //A new function of character buffering input stream: read characters according to lines

 public String readLine()
 //Read a row of data and return. If there is no data to read, it will return u11
    
 public BufferedWriter(Writer r)
    
 public void newLine() //Winline

io conversion stream

  • If the code encoding and the code of the read text file are consistent, there will be no garbled code when reading the text file using character stream!
  • If the code encoding and the encoding of the read text file are inconsistent, garbled code will appear when reading the text file using character streams!

Character input conversion stream----InputStreamReader

​ First get the original byte stream of the file, and then encode it into a character input stream according to the real character set, so that the characters in the character input stream will not be garbled.

public InputStreamReader (InputStream is, String charset)
 //Input the original byte input stream and convert it into a character input stream according to the specified character set encoding (key point)

Character output conversion stream

public OutputStreamWriter(OutputStream os,String charst)
 //The original byte output stream can be converted into a character output stream according to the specified encoding (key point)

io print stream

PrintStream/PrintWriter(Print Stream)
Function: Printing streams can achieve more convenient and efficient printing of data, and can achieve whatever is printed.

public PrintStream(OutputStream/File/String)
 //The print stream directly leads to the byte output stream/file/file path
 public PrintStren(String fileName, Charset charset)
 //You can specify the written character encoding
 public PrintStream(OutputStream out, boolean autoFlush)
 //You can specify automatic refresh
 public PrintStream (OutputStreamout, booleanautoFlush, Stringencoding)
 //You can specify automatic refresh and character encoding can be specified
    
 public PrintWriter(OutputStream/Writer/File/String)
 //The print stream directly leads to the byte output stream/file/file path
 public Printwriter(String fileName,Charset charset)
 //You can specify the written character encoding
 public Printwriter(OutputStream out/Writer,boolean autoFlush)
 //You can specify automatic refresh
 public PrintWriter(Outputstream out,boolean autoFlush,String encoding)
 //You can specify automatic refresh and character encoding can be specified
public void println(Xxx xx)
 //Print any type of data out
 Public void write (int/byte[]/byte[] part)
 //It can support writing byte data out

io data flow

  • DataInputStream
public DataInputstream(Inputstream is)
 Create a new data input stream that wraps the basic byte input stream

 Public final byte readByte()throws IOException
 Read byte data and return
 public final int readInt()throws IOException
 Read data of type int to return
 public final double readDouble()throws IOException
 Read double type data to return

 public final String readUTF()throws IOException
 Read the number of strings (UTF-8) data return
 public int readInt()/read(byte[])
 Support reading byte data into
  • DataOutputStream
public DataOutputStream (outputStream out)
 Create a new data output stream that wraps the basic byte output stream

 public final void writeByte(int v) throws IoException
 Write data of type byte to the basic byte output stream
 public final void writeInt(int v) throws IoException
 Write data of type int to the basic byte output stream
 public final void writeDouble(Double v) throws I0Exception
 Write double type data to the basic byte output stream
 public final void writeUTF(String str) throws IoException
 Encode string data into bytes in UTF-8 and write to the basic byte output stream
 public void write(int/byte[]/byte[] part)
 Support writing byte data out

io serialization stream

Serialization: ---implements Serializable

Note: If an object wants to participate in serialization, it must implement the serialization interface()

Object serialization: Write java objects into a file

Object deserialization: read out the java object in the file

  • ObjectInputStream
public objectInputstream(Inputstream is)
 Create object byte input streams, wrap the basic byte input streams

 public final object readobject()
 Read out Java objects stored in files

When the parameter does not want to be serialized:

// This member variable transient will not participate in serialization:
 private transient String password;
  • ObjectOutputStream
public objectoutputstream(Outputstream out)
 Create object byte output streams and wrap basic byte output streams

 public final void writeobject(object o)throws IOException
 Write out the object

  • What if you want to serialize multiple objects at once?

    Use an ArrayList collection to store multiple objects, and then serialize the collection directly

    Note: The ArrayList collection has implemented the serialization interface!

Supplementary knowledge: io framework

What is a framework

  • To solve a certain type of problem, a set of classes, interfaces, etc. written can be understood as a semi-finished product, and most frameworks are developed by third parties.
  • Advantages: Developed based on the framework, you can obtain excellent software architecture and improve development efficiency
  • The form of the framework: Generally, classes, interfaces, etc. are compiled into classi forms, and then compressed into a jar-end file for issuance.

What is an IO framework?

It encapsulates the code that operates files and data provided by Java, and provides a simpler way to operate files, read and write data, etc.

Commons-io

Some methods provided by the FileUtils class are displayed:
 public static void copyFile(File srcFile, File destFile)
 Copy the file.
 public static void copyDirectory(File srcDir,File destDir)
 Copy folder
 public static void deleteDirectory(File directory)
 Delete folder
 public static String readFileToString(File file,String encoding)
 Read data
 public static void writeStringToFile (File file, String data, String charname, boolean append)
 Write data
Some methods provided by lOUtils class are displayed.
 public static int copy(Inputstreaminputstream,Outputstream)
 Copy the file.
 public static int copy(Reader reader,Writer writer)
 Copy the file.
 public static void write(String data,Outputstream output,String charsetName)
 Write data
<Previous Next>