How does a BufferedReader's read(char[]) work?

I was searching on the internet and came across this code to read files from a file and convert it into a string. But I don't understand how in.read(arr) is reading all the contents of a file at once.

   import java.util.Scanner;
   import java.io.*;
   class Main{
       public static void main(String[] args)
       {
         Scanner sc = new Scanner(System.in);
         String s = sc.next();
         try
         {
           File file = new File(s);
           BufferedReader in = new BufferedReader(new FileReader(file));
           int c;
           char arr[] = new char[(int)file.length()];
           in.read(arr);
           String res = new String(arr);
           System.out.println(res);
         }
         catch(Exception e){}
       }
   }

In contemporary Java code you would use Files.readString for this purpose. It was introduced with Java 11, and it specifically reads an entire text file into a String.

What happens in the code you ask about is a common thing with read(someArray) methods: they read up to a number of conditions, something like

• The specified number of characters have been read,
• The read method of the underlying stream returns -1, indicating end-of-file, or
• The ready method of the underlying stream returns false, indicating that further input requests would block.

here you use the first and second conditions, and hope that the third one will not kick in, so reading from a local file won't cause "blocking" at an arbitrary file position.
File.length tells you the size of the file in bytes. There can't be more characters in a file than its size in bytes, that's why file.length is a good upper estimate for the number of characters you would need. However as there are encodings which can result a single character stored as multiple bytes (such as UTF-8), you should actually use the return value of that read() call which tells you the number of characters read, and then pass it to the String constructor:

char arr[] = new char[(int)file.length()];
int count = in.read(arr);
String res = new String(arr, 0, count);

<hr>

Actual variants of your code:

• with File.toPath() if you like

  import java.util.Scanner;
  import java.io.File;
  import java.nio.file.Files; // "Files" is needed of course
  
  class Main
  {
      public static void main(String[] args)
      {
          Scanner sc = new Scanner(System.in);
          String s = sc.next();
          try
          {
              File file = new File(s);
              String res = Files.readString(file.toPath()); // many lines disappeared
              System.out.println(res);
          }
          catch (Exception e) {}
      }
  }
  

• with java.nio classes and interfaces:

  import java.util.Scanner;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  
  class Main
  {
      public static void main(String[] args)
      {
          Scanner sc = new Scanner(System.in);
          String s = sc.next();
          try
          {
              Path path = Paths.get(s); // "File file" became "Path path"
              String res = Files.readString(path); // many lines disappeared again
              System.out.println(res);
          }
          catch (Exception e) {}
      }
  }
  

It's up to a bit of taste and what you have already. If you have a File object anyway (like you need its size for some another purpose, or you get it from GUI code for example - in many cases that's going to be a File), use its toPath(). If you have a String, a single Paths.get() is less typing.

1. The object 'in' has the information related to file.
2. 'arr' is the array whose length is equal to the length of file contents.
3. Then 'in' is read upto that length of file