Building Command-Line Tools in Java

public class Greet {
    // args[] holds the words you typed after the program name.
    // Run as:  java Greet Alice 3
    //   -> args[0] = "Alice", args[1] = "3"
    public static void main(String[] args) {
        // Defaults so the tool still works with no arguments.
        String name = "World";
        int times = 1;

        // args.length tells you how many were passed — ALWAYS check it.
        if (args.length >= 1) {
            name = args[0];               // first word after the program name
        }
        if (args.length >= 2) {
            times = Integer.parseInt(args[1]);  // text "3" -> int 3
        }

        for (int i = 0; i < times; i++) {
            System.out.println("Hello, " + name + "!");
        }
    }
}

$ java Greet Alice 3
Hello, Alice!
Hello, Alice!
Hello, Alice!

$ java Greet
Hello, World!

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

public class Echo {
    public static void main(String[] args) throws Exception {
        // --- Scanner: easy, great for prompting interactively ---
        Scanner sc = new Scanner(System.in);
        System.out.print("Your name: ");   // print (no newline) so the prompt sits inline
        String name = sc.nextLine();        // reads one line the user types
        System.out.println("Hi, " + name + "!");

        // --- BufferedReader: faster, ideal for piping lots of lines in ---
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        int count = 0;
        // readLine() returns null at end-of-input (Ctrl-D / end of a pipe).
        while ((line = in.readLine()) != null) {
            count++;
            System.out.println(count + ": " + line);  // number each line, like 'cat -n'
        }
        System.out.println("Total lines: " + count);
    }
}

$ printf "apple\nbanana\ncherry\n" | java Echo
Your name: apple
Hi, apple!
1: banana
2: cherry
Total lines: 2

public class Validate {
    public static void main(String[] args) {
        // --- Environment variables: set OUTSIDE the program (the shell) ---
        // System.getenv returns null if the variable is not set.
        String home = System.getenv("HOME");
        System.out.println("HOME = " + home);

        // --- System properties: passed with -D or built into the JVM ---
        // java -Denv=prod Validate   ->  System.getProperty("env") = "prod"
        String env = System.getProperty("env", "dev");  // "dev" is the fallback
        System.out.println("env = " + env);

        // --- Exit codes: 0 = success, non-zero = failure ---
        if (args.length == 0) {
            System.err.println("Error: expected a filename");  // errors go to stderr
            System.exit(2);   // stops now; the shell sees code 2 (a usage error)
        }

        System.out.println("Processing " + args[0] + "...");
        System.exit(0);       // explicit success (0 is also the default)
    }
}

$ java Validate
HOME = /home/alice
env = dev
Error: expected a filename
$ echo $?
2

$ java -Denv=prod Validate report.csv
HOME = /home/alice
env = prod
Processing report.csv...
$ echo $?
0

public class WordCount {
    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        // 1) If no argument was given, print an error to stderr and exit with code 2.
        if (args.length == 0) {
            System.err.println("Usage: WordCount <sentence>");
            System.exit(___);          // 👉 use the conventional usage-error code

        }

        // 2) split() turns "a b c" into an array of words.
        String sentence = args[0];
        String[] words = sentence.split(" ");

        // 3) Print how many words there are.
        System.out.println("Words: " + ___);   // 👉 the length of the words array

        // ✅ Expected output:
        //   $ java WordCount "the quick brown fox"
        //   Words: 4
    }
}

$ java WordCount "the quick brown fox"
Words: 4

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class SumLines {
    public static void main(String[] args) throws Exception {
        // 🎯 YOUR TURN — read numbers from stdin and add them up

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int total = 0;
        String line;

        // 1) Loop until readLine() returns null (end of input).
        while ((line = in.readLine()) != ___) {   // 👉 what does readLine() return at the end?

            // 2) Turn the line of text into an int and add it to total.
            total += Integer.parseInt(___);        // 👉 the current line you just read
        }

        System.out.println("Sum: " + total);

        // ✅ Expected output:
        //   $ printf "10\n20\n30\n" | java SumLines
        //   Sum: 60
    }
}

$ printf "10\n20\n30\n" | java SumLines
Sum: 60

import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;
import picocli.CommandLine.Parameters;
import java.util.concurrent.Callable;

@Command(name = "greet", version = "greet 1.0",
         description = "Greet someone N times.",
         mixinStandardHelpOptions = true)  // adds --help and --version for free
public class Greet implements Callable<Integer> {

    @Parameters(index = "0", description = "Who to greet")
    String name;                       // a positional argument: greet Alice

    @Option(names = {"-c", "--count"}, defaultValue = "1",
            description = "How many times (default: 1)")
    int count;                         // picocli converts "3" -> int for you

    @Option(names = {"-u", "--upper"}, description = "Shout it")
    boolean upper;                     // a flag: present = true, absent = false

    @Override
    public Integer call() {            // runs after parsing succeeds
        String msg = "Hello, " + name + "!";
        if (upper) msg = msg.toUpperCase();
        for (int i = 0; i < count; i++) System.out.println(msg);
        return 0;                      // becomes the process exit code
    }

    public static void main(String[] args) {
        // execute() parses args, runs call(), and returns the exit code.
        int code = new CommandLine(new Greet()).execute(args);
        System.exit(code);
    }
}

public class Calc {
    public static void main(String[] args) {
        // 🎯 MINI-CHALLENGE: a tiny calculator CLI
        // Run it like:  java Calc 6 + 4   ->  10
        //
        // 1. If args.length is not exactly 3, print a usage message to
        //    System.err and System.exit(2).
        // 2. Read args[0] and args[2] as ints (Integer.parseInt).
        // 3. Look at args[1] ("+", "-", "*", or "/") and compute the result.
        //    Use a switch; for an unknown operator, error out with exit code 2.
        // 4. Print the result, then System.exit(0).
        //
        // ✅ Expected:
        //   $ java Calc 6 + 4   ->  10
        //   $ java Calc 9 / 3   ->  3
        //   $ java Calc 6 ^ 4   ->  (error to stderr, exit code 2)

        // your code here
    }
}