Coffee break #135. 5 Ways to Convert a File to a String in Java. How to change command line arguments in Java

5 Ways to Convert a File to a String in Java

Source: Medium Today we will discuss 5 simple and proven ways to read or convert a file to a string in Java. The choice of the most suitable method for you depends on the configuration of a particular project. To begin with, let's assume that inputStream is a variable of type InputStream.

InputStream inputStream;

Now let's check out the different conversion methods.

1. Using the built-in Java 1.11+ file package:

import java.nio.file.Files;
import java.nio.file.Path;
String result = Files.readString(Path.of("filePath"));

//Bonus: To Write string to a file you can use
String content = "Demo Content";
Files.writeString(filePath, content);

This method works with Java 1.11+.

2. Using the built-in Streams Java 1.8+ package:

String result =  new  String( Files.readAllBytes ( Paths.get ( filePath )),          StandardCharsets.UTF_8 ) ;

This method works with Java 1.8+.

3. Own Java scanner:

try (Scanner scanner = new Scanner(Paths.get(fileName), StandardCharsets.UTF_8.name())) {
    String result = scanner.useDelimiter("\\A").next();
}

Note that \A represents the regular expression pattern for the scanner's useDelimiter method . \A means: :start of a string! (beginning of line!). So when this pattern is applied, the entire stream is ready to be used in the scanner object.

4. Apache commons-io IOUtils method:

File file = new File("data.txt");
String result = FileUtils.readFileToString(file, StandardCharsets.UTF_8);

This method requires the Apache commons-io library to be installed in your project. You can find it at the link from maven .

5. Using Google Guava library:

String result = Files.toString(new File(path), Charsets.UTF_8);

Using this method assumes that your project already has the Guava library. You can find it using the link from maven . If you want to experiment with real InputStreams without any utility methods, then use this method.

How to change command line arguments in Java

Source: DZone In this article, you will learn how to change command line arguments in Java, how they are passed and how they work. How do you check that your code is error-free and handles all requests? The easiest way is to test it on all possible ranges of test cases. However, taking all these tests can be quite long and labor intensive. We need some other way that can do this easily, without much hassle, and preferably automated. Java command line arguments are one solution to our problem. They significantly simplify the testing and debugging process.

// here args will hold the command line arguments
    public static void main(String[] args) {
        System.out.println("Hello World!");
        // remaining code will go here
    }

What are command line arguments?

Java Command-Line Arguments are a way of entering data into a program through the command line. Programmers can pass these arguments directly from the console, which will be accessed by the main() method . If necessary, command line arguments can be ignored by passing the values ​​directly to the main() method .

How do command line arguments work?

Command line arguments are wrapped and passed into args[] . This is an array of strings that contains all the command line arguments passed to it. Each argument will be stored by index, starting from args[0] to args[n] .

How are command line arguments passed?

Command line arguments are passed through the command line or terminal. All arguments passed through them will be converted and enclosed in the args[] array inside the JVM. Now let's see how to pass command line arguments with an example. Let's say we have a file with some Java code. The following steps will demonstrate how to pass command line arguments in Java:

1. Save the Java program with a .java extension (for example, Arguments.java ).

2. Open a terminal/command prompt in the directory where the program is stored locally.

3. Compile a Java program to convert a .java file to a .class file .

   • Command: javac filename.java (In our example: javac Arguments.java )

4. Run the program and pass the arguments after the file name is separated by spaces.

   • Command: java filename argument1 argument2 .... argumentN (In our example, Java arguments: Welcome to this blog and Happy Learning )

How to access command line arguments?

Now let's try to access all the passed command line arguments in Java. How to do it? Since the arguments are stored in the args[] array , this means that we can easily access them using args[i] , which specifies an index that can range from 0 to n (the total number of arguments passed).

class Arguments {
    public static void main( String[] args ) {
        System.out.println(" Hello World! ");
        // args.length is used to get length of args array

        System.out.println(" Total number of args: " + args.length);
        // iterating over the args array to print the args if available

        for (int i = 0; i < args.length; i++) {
            System.out.println(" Arg " + i + ": " + args[i]);
        }
    }
}

Conclusion:

How to change command line arguments?

Here we can use args[i] to get the value at the i-th index and then use the assignment operator (=). So we can change the command line argument at the i-th index. The code snippet below will change some of the arguments passed through the command line in Java.

args[1] = " Modified Command Line Argument 1 ";
args[3] = " Modified Command Line Argument 2 ";
args[5] = " Modified Command Line Argument 3 ";

Output after change:

Conclusion

• Java command line arguments are a way of entering data into a program through the command line.

• Command line arguments are passed when executing the run command, the arguments are passed immediately after the file name, separated by spaces.

• Command line arguments are written to the string array args[] .

• We can access or change command line arguments using the args[i] operators and assignment operators.