Unix4j (unix4j 0.4 API)

java.lang.Object
- org.unix4j.Unix4j

```
public final class Unix4j
extends Object
```
Utility class with static methods serving as starting point to create a command or build a command chain joining several commands.
Every method returns a new builder instance. For more information and a detailed description of command building and chaining, see Unix4jCommandBuilder.

Method Summary

Methods
Modifier and Type	Method and Description
`static Unix4jCommandBuilder`	`builder()` Returns a builder to create a command or command chain.
`static Unix4jCommandBuilder`	`cat(CatOptions options, File... files)` Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format.
`static Unix4jCommandBuilder`	`cat(CatOptions options, String... paths)` Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format.
`static Unix4jCommandBuilder`	`cat(File... files)` Reads the lines from the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`cat(String... args)` Reads the lines from files specified as arguments and writes them to the standard output.
`static Unix4jCommandBuilder`	`cd()` Changes the current directory to the user home directory as defined by the execution context (usually the directory specified by the `"user.home"` system property).
`static Unix4jCommandBuilder`	`cd(File file)` The current working directory is changed to the given file.
`static Unix4jCommandBuilder`	`cd(String path)` The current working directory is changed to the given file.
`static Unix4jCommandBuilder`	`echo(EchoOptions options, String... strings)` Writes any of the specified strings, separated by single blank (`' '`) characters to the standard output suppressing the trailing line ending if the `-n` option is specified.
`static Unix4jCommandBuilder`	`echo(EchoOptions options, String string)` Writes the specified string followed by a newline character to the standard output suppressing the trailing line ending if the `-n` option is specified.
`static Unix4jCommandBuilder`	`echo(String... args)` Writes any of the specified strings, separated by single blank (`' '`) characters to the standard output suppressing the trailing line ending if the `"-n"` option is specified.
`static Unix4jCommandBuilder`	`find(FindOptions options, Date time)` Finds all files that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`static Unix4jCommandBuilder`	`find(FindOptions options, Date time, String name)` Finds all files matching the given `name` that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`static Unix4jCommandBuilder`	`find(FindOptions options, long size)` Finds all files matching the specified file `size` in or below the user's current working directory and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(FindOptions options, long size, Date time, String name)` Finds all files matching the given `name` and `size` and have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`static Unix4jCommandBuilder`	`find(FindOptions options, long size, String name)` Finds all files matching the specified file `name` and `size` in or below the user's current working directory and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(FindOptions options, String name)` Finds all files matching the specified `name` in or below the user's current working directory and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(FindOptions options, String path, Date time)` Finds all files that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`static Unix4jCommandBuilder`	`find(FindOptions options, String path, Date time, String name)` Finds all files matching the given `name` that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`static Unix4jCommandBuilder`	`find(FindOptions options, String path, long size)` Finds all files matching the specified file `size` in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(FindOptions options, String path, long size, Date time, String name)` Finds all files matching the given `name` and `size` and have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`static Unix4jCommandBuilder`	`find(FindOptions options, String path, long size, String name)` Finds all files matching the specified file `name` and `size` in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(FindOptions options, String path, String name)` Finds all files matching the specified `name` in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(long size)` Finds all files matching the specified file `size` in or below the user's current working directory and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(long size, String name)` Finds all files matching the specified file `name` and `size` in or below the user's current working directory and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(String... args)` Finds all files matching the search criteria specified by the given arguments and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(String path)` Finds all files in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(String path, long size)` Finds all files matching the specified file `size` in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(String path, long size, String name)` Finds all files matching the specified file `name` and `size` in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`find(String path, String name)` Finds all files matching the specified `name` in or below the directory specified by `path` and writes the file names to the standard output.
`static Unix4jCommandBuilder`	`from(Collection<? extends String> lines)` Uses the strings in the specified `input` collection as input lines for the next command.
`static Unix4jCommandBuilder`	`from(Input input)` Reads from the given input object and redirects the contents into the next command.
`static Unix4jCommandBuilder`	`from(InputStream stream)` Reads from the given input stream and redirects the contents into the next command.
`static Unix4jCommandBuilder`	`from(Reader reader)` Uses the given reader and redirects the read input into the next command.
`static Unix4jCommandBuilder`	`from(URL url)` Reads from the given URL and redirects the contents into the next command.
`static Unix4jCommandBuilder`	`fromFile(File file)` Redirects the contents of the given file into the next command.
`static Unix4jCommandBuilder`	`fromFile(String path)` Redirects the contents of the given file into the next command.
`static Unix4jCommandBuilder`	`fromResource(String resource)` Reads from the given resource relative to the classpath and redirects the contents into the next command.
`static Unix4jCommandBuilder`	`fromString(String string)` Uses the given string as input for the next command.
`static Unix4jCommandBuilder`	`fromStrings(String... strings)` Uses the given strings as input for the next command.
`static Unix4jCommandBuilder`	`grep(GrepOptions options, Pattern pattern, File... files)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`grep(GrepOptions options, Pattern pattern, String... paths)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`grep(GrepOptions options, String regexp, File... files)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`grep(GrepOptions options, String regexp, String... paths)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`grep(Pattern pattern, File... files)` Filters the lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`grep(Pattern pattern, String... paths)` Filters the lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`grep(String regexp, File... files)` Filters the lines from the specified input files and writes the matching lines to the standard output.
`static Unix4jCommandBuilder`	`head(File... files)` Reads the first 10 lines from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`head(HeadOptions options, long count, File... files)` Reads the first `count` lines or characters from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`head(HeadOptions options, long count, String... paths)` Reads the first `count` lines or characters from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`head(long count, File... files)` Reads the first `count` lines from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`head(long count, String... paths)` Reads the first `count` lines from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`ls()` Lists all files and directories in the user's current working directory and writes them to the output.
`static Unix4jCommandBuilder`	`ls(File... files)` Prints the name of the given files and lists all files contained in directories for every directory in `files`.
`static Unix4jCommandBuilder`	`ls(LsOptions options)` Lists all files and directories in the user's current working directory and writes them to the output using the given options specifying the details of the output format.
`static Unix4jCommandBuilder`	`ls(LsOptions options, File... files)` Prints the name of the given files and lists all files contained in directories for every directory in `files`.
`static Unix4jCommandBuilder`	`ls(LsOptions options, String... paths)` Prints the name of the given files and lists all files contained in directories for every directory in `files`.
`static Unix4jCommandBuilder`	`ls(String... args)` Prints the name of the specified files and lists all files contained in directories for every directory in those files.
`static Unix4jCommandBuilder`	`sed(SedOptions options, String regexp)` Executes the sed command specified by the given options or executes the print command p if no command option has been declared.
`static Unix4jCommandBuilder`	`sed(SedOptions options, String string1, String string2)` Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
`static Unix4jCommandBuilder`	`sed(SedOptions options, String string1, String string2, int... occurrence)` Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
`static Unix4jCommandBuilder`	`sed(String... args)` Executes the sed script specified by the given arguments and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sed(String script)` Executes the given sed script, such as "s/original/replacement/g".
`static Unix4jCommandBuilder`	`sed(String regexp, String replacement)` Substitutes the replacement string for instances of the regexp in the matched line.
`static Unix4jCommandBuilder`	`sed(String regexp, String replacement, int... occurrence)` Substitutes the replacement string for instances of the regexp in the matched line.
`static Unix4jCommandBuilder`	`sort(Comparator<? super Line> comparator, File... files)` Sort the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(Comparator<? super Line> comparator, String... paths)` Sort the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(File... files)` Sort the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(SortOptions options, Comparator<? super Line> comparator, File... files)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(SortOptions options, Comparator<? super Line> comparator, String... paths)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(SortOptions options, File... files)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(SortOptions options, String... paths)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`sort(String... args)` Sort the lines of all the specified files together and writes the result to the standard output.
`static Unix4jCommandBuilder`	`tail(File... files)` Reads the last 10 lines from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`tail(long count, File... files)` Reads the last `count` lines from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`tail(long count, String... paths)` Reads the last `count` lines from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`tail(String... args)` Reads the last n lines from each of the files specified and writes them to the standard output.
`static Unix4jCommandBuilder`	`tail(TailOptions options, long count, File... files)` Reads the last `count` lines or characters from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`tail(TailOptions options, long count, String... paths)` Reads the last `count` lines or characters from each of the specified files and writes them to the standard output.
`static Unix4jCommandBuilder`	`uniq(File file)` Reads from the specified input `file` and compares adjacent lines, writing one copy of each input line to the standard output.
`static Unix4jCommandBuilder`	`uniq(String path)` Reads the file specified by its `path` and compares adjacent lines, writing one copy of each input line to the standard output.
`static Unix4jCommandBuilder`	`uniq(UniqOptions options, File file)` Reads from the specified input `file` and compares adjacent lines, writing one copy of each input line to the standard output.
`static Unix4jCommandBuilder`	`uniq(UniqOptions options, String path)` Reads the file specified by its `path` and compares adjacent lines, writing one copy of each input line to the standard output.
`static Unix4jCommandBuilder`	`use(ExecutionContextFactory contextFactory)` Returns a builder that uses the specified factory to create contexts for command execution.
`static Unix4jCommandBuilder`	`wc(File... files)` Executes a count of lines, words and chars contained in each input file and writes them to the standard output.
`static Unix4jCommandBuilder`	`wc(WcOptions options, File... files)` Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output.
`static Unix4jCommandBuilder`	`wc(WcOptions options, String[] paths)` Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - builder
```
public static Unix4jCommandBuilder builder()
```
    Returns a builder to create a command or command chain. The builder is initialized with a NoOp command which will be replaced by the first command joined to this builder's command chain.
    
    Returns:
    the builder to create the command or command chain
  - use
```
public static Unix4jCommandBuilder use(ExecutionContextFactory contextFactory)
```
    Returns a builder that uses the specified factory to create contexts for command execution. The builder is initialized with a NoOp command which will be replaced by the first command joined to this builder's command chain.
    
    Parameters:
    contextFactory - the factory used to create execution contexts that are passed to the execute method when a command is executed
    
    Returns:
    the builder to create the command or command chain
  - cat
```
public static Unix4jCommandBuilder cat(String... args)
```
    Reads the lines from files specified as arguments and writes them to the standard output. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). File arguments are expanded if wildcards are used. All file arguments are processed in command-argument order.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options and file operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). File arguments are expanded if wildcards are used.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - cat
```
public static Unix4jCommandBuilder cat(File... files)
```
    Reads the lines from the specified files and writes them to the standard output. The files are processed in command-argument order.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    files - The input files to be printed; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - cat
```
public static Unix4jCommandBuilder cat(CatOptions options,
                       File... files)
```
    Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format. The files are processed in command-argument order.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the cat command.
    files - The input files to be printed; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - cat
```
public static Unix4jCommandBuilder cat(CatOptions options,
                       String... paths)
```
    Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format. The path arguments are expanded if wildcards are used and processed in command-argument order.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the cat command.
    paths - Pathnames of the input files to be printed; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - cd
```
public static Unix4jCommandBuilder cd()
```
    Changes the current directory to the user home directory as defined by the execution context (usually the directory specified by the "user.home" system property).
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - cd
```
public static Unix4jCommandBuilder cd(File file)
```
    The current working directory is changed to the given file. If the specified file argument does not represent a valid directory, an exception is thrown. Note that relative paths are not resolved with the (old) current working directory. Use the String path to enable relative path resolving and wildcards.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    file - the file to use as input; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - cd
```
public static Unix4jCommandBuilder cd(String path)
```
    The current working directory is changed to the given file. Relative paths are resolved on the basis of the (old) current working directory. Wildcards are possible if the first matching file represents a directory. If the first file specified by the given path argument is not a valid directory, an exception is thrown.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - the directory to become the new current working directory; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - echo
```
public static Unix4jCommandBuilder echo(String... args)
```
    Writes any of the specified strings, separated by single blank (' ') characters to the standard output suppressing the trailing line ending if the "-n" option is specified.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options for the command and the strings to be written to the output. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--").
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - echo
```
public static Unix4jCommandBuilder echo(EchoOptions options,
                        String string)
```
    Writes the specified string followed by a newline character to the standard output suppressing the trailing line ending if the -n option is specified.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the echo command.
    string - A string to be written to standard output.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - echo
```
public static Unix4jCommandBuilder echo(EchoOptions options,
                        String... strings)
```
    Writes any of the specified strings, separated by single blank (' ') characters to the standard output suppressing the trailing line ending if the -n option is specified.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the echo command.
    strings - Strings to be written to standard output, separated by single blank characters.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(String... args)
```
    Finds all files matching the search criteria specified by the given arguments and writes the file names to the standard output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--name" operand have to be prefixed with the operand name.
    The files names written to the output are relative paths referring to the working directory (or -- if provided -- relative to the path given after the "--path" operand name).
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--path" operand have to be prefixed with the operand name (e.g. "--name" for subsequent path operand values).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(String path)
```
    Finds all files in or below the directory specified by path and writes the file names to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(String path,
                        String name)
```
    Finds all files matching the specified name in or below the directory specified by path and writes the file names to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(long size)
```
    Finds all files matching the specified file size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(String path,
                        long size)
```
    Finds all files matching the specified file size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(String path,
                        long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String name)
```
    Finds all files matching the specified name in or below the user's current working directory and writes the file names to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        String name)
```
    Finds all files matching the specified name in or below the directory specified by path and writes the file names to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        long size)
```
    Finds all files matching the specified file size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        long size)
```
    Finds all files matching the specified file size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        Date time)
```
    Finds all files that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the user's current working directory are written to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        Date time)
```
    Finds all files that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the directory specified by path are written to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        Date time,
                        String name)
```
    Finds all files matching the given name that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the user's current working directory are written to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        Date time,
                        String name)
```
    Finds all files matching the given name that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the directory specified by path are written to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        long size,
                        Date time,
                        String name)
```
    Finds all files matching the given name and size and have been created, modified or accessed before or after the specified time (depending on the given -time... options).
    Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative. The names of the matching files found in or below the user's current working directory are written to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - find
```
public static Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        long size,
                        Date time,
                        String name)
```
    Finds all files matching the given name and size and have been created, modified or accessed before or after the specified time (depending on the given -time... options).
    Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative. The names of the matching files found in or below the directory specified by path are written to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - fromString
```
public static Unix4jCommandBuilder fromString(String string)
```
    Uses the given string as input for the next command. If the string contains line ending codes (UNIX or DOS independent from the host operating system), the string is split into multiple lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    string - the string to use as input
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - fromStrings
```
public static Unix4jCommandBuilder fromStrings(String... strings)
```
    Uses the given strings as input for the next command. Each string usually represents a single line of the input; however, if any of the strings contains line ending codes (UNIX or DOS independent from the host operating system), it is split into multiple lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    strings - the input lines
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - from
```
public static Unix4jCommandBuilder from(Collection<? extends String> lines)
```
    Uses the strings in the specified input collection as input lines for the next command. Each string usually represents a single line of the input; however, if any of the strings contains line ending codes (UNIX or DOS independent from the host operating system), it is split into multiple lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    lines - collection with input lines
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - fromFile
```
public static Unix4jCommandBuilder fromFile(String path)
```
    Redirects the contents of the given file into the next command. This is essentially equivalent to the following syntax in a unix command shell: path > ...
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - the file to use as input; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - fromFile
```
public static Unix4jCommandBuilder fromFile(File file)
```
    Redirects the contents of the given file into the next command. This is essentially equivalent to the following syntax in a unix command shell: file > ...
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    file - the file to use as input; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - fromResource
```
public static Unix4jCommandBuilder fromResource(String resource)
```
    Reads from the given resource relative to the classpath and redirects the contents into the next command. The resource is usually a file or URL on the classpath. The resource is read using Class.getResourceAsStream(String).
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    resource - a path to the file to redirect to the next command. The will need to be on the classpath. If the file is in the root directory, the filename should be prefixed with a forward slash. e.g.: "/test-file.txt"
    If the file is in a package, then the package should be specified prefixed with a forward slash, and with each dot "." replaced with a forward slash. e.g.: "/org/company/mypackage/test-file.txt"
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - from
```
public static Unix4jCommandBuilder from(InputStream stream)
```
    Reads from the given input stream and redirects the contents into the next command.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    stream - the input stream to read from
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - from
```
public static Unix4jCommandBuilder from(Reader reader)
```
    Uses the given reader and redirects the read input into the next command.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    reader - the reader used to read the input
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - from
```
public static Unix4jCommandBuilder from(URL url)
```
    Reads from the given URL and redirects the contents into the next command.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    url - the URL to read from
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - from
```
public static Unix4jCommandBuilder from(Input input)
```
    Reads from the given input object and redirects the contents into the next command.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    input - the input object to read from
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(String regexp,
                        File... files)
```
    Filters the lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regexp string using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(Pattern pattern,
                        File... files)
```
    Filters the lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    pattern - Lines will be printed which match the given pattern.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(Pattern pattern,
                        String... paths)
```
    Filters the lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    pattern - Lines will be printed which match the given pattern.
    paths - Pathnames of the input files to be searched for the pattern; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(GrepOptions options,
                        String regexp,
                        File... files)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regexp string; the exact comparison rules are defined by the specified matching options.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(GrepOptions options,
                        String regexp,
                        String... paths)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regexp string; the exact comparison rules are defined by the specified matching options.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    paths - Pathnames of the input files to be searched for the pattern; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(GrepOptions options,
                        Pattern pattern,
                        File... files)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern; the exact comparison rules are defined by the specified matching options.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    pattern - Lines will be printed which match the given pattern.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - grep
```
public static Unix4jCommandBuilder grep(GrepOptions options,
                        Pattern pattern,
                        String... paths)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern; the exact comparison rules are defined by the specified matching options.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    pattern - Lines will be printed which match the given pattern.
    paths - Pathnames of the input files to be searched for the pattern; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - head
```
public static Unix4jCommandBuilder head(File... files)
```
    Reads the first 10 lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - head
```
public static Unix4jCommandBuilder head(long count,
                        File... files)
```
    Reads the first count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - head
```
public static Unix4jCommandBuilder head(long count,
                        String... paths)
```
    Reads the first count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - head
```
public static Unix4jCommandBuilder head(HeadOptions options,
                        long count,
                        File... files)
```
    Reads the first count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the head command.
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - head
```
public static Unix4jCommandBuilder head(HeadOptions options,
                        long count,
                        String... paths)
```
    Reads the first count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the head command.
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - ls
```
public static Unix4jCommandBuilder ls()
```
    Lists all files and directories in the user's current working directory and writes them to the output.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - ls
```
public static Unix4jCommandBuilder ls(String... args)
```
    Prints the name of the specified files and lists all files contained in directories for every directory in those files.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--count" for a subsequent count operand value).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - ls
```
public static Unix4jCommandBuilder ls(File... files)
```
    Prints the name of the given files and lists all files contained in directories for every directory in files.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    files - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - ls
```
public static Unix4jCommandBuilder ls(LsOptions options)
```
    Lists all files and directories in the user's current working directory and writes them to the output using the given options specifying the details of the output format.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the output format.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - ls
```
public static Unix4jCommandBuilder ls(LsOptions options,
                      File... files)
```
    Prints the name of the given files and lists all files contained in directories for every directory in files. The given options define the details of the output format.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the output format.
    files - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - ls
```
public static Unix4jCommandBuilder ls(LsOptions options,
                      String... paths)
```
    Prints the name of the given files and lists all files contained in directories for every directory in files. The given options define the details of the output format.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the output format.
    paths - The files or directories used as starting point for the listing; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(String... args)
```
    Executes the sed script specified by the given arguments and writes the result to the standard output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--script" operand have to be prefixed with the operand name.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--script" operand have to be prefixed with the operand name (e.g. "--occurrence" for subsequent occurrence indices).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(String script)
```
    Executes the given sed script, such as "s/original/replacement/g".
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    script - Sed script as one string, such as "s/original/replacement/g".
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(String regexp,
                       String replacement)
```
    Substitutes the replacement string for instances of the regexp in the matched line.
    An ampersand ('&') appearing in the replacement is be replaced by the line matching the regexp. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    A line can be split by substituting a newline ('\n') into it.
    A substitution is considered to have been performed even if the replacement string is identical to the string that it replaces.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    regexp - Regular expression matched against a line.
    replacement - Replacement string for substitute command. An ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(String regexp,
                       String replacement,
                       int... occurrence)
```
    Substitutes the replacement string for instances of the regexp in the matched line. Only the given occurrences of the regexp found within the matched string are substituted.
    An ampersand ('&') appearing in the replacement is be replaced by the line matching the regexp. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    A line can be split by substituting a newline ('\n') into it.
    A substitution is considered to have been performed even if the replacement string is identical to the string that it replaces.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    regexp - Regular expression matched against a line.
    replacement - Replacement string for substitute command. An ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    occurrence - Substitute for the given occurrences only of the regexp found within the matched string; the occurrence indices are one-based. If empty or omitted, all occurrences are substituted.
    (This operand only applies to the substitute command and is ignored by all other commands).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(SedOptions options,
                       String regexp)
```
    Executes the sed command specified by the given options or executes the print command p if no command option has been declared.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Sed options and commands
    regexp - Regular expression matched against a line.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(SedOptions options,
                       String string1,
                       String string2)
```
    Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Sed options and commands
    string1 - Regular expression matched against a line for all commands except for command y where string1 contains the source characters for the translation.
    string2 - Replacement string for substitute command s; appended, inserted or changed text for a, i and c command; destination characters for translate command y; ignored by all other commands.
    If string2 is a replacement string for the substitute command: an ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression; the characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    (This operand only applies to the commands s, a, i, c and y and is ignored by all other commands).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sed
```
public static Unix4jCommandBuilder sed(SedOptions options,
                       String string1,
                       String string2,
                       int... occurrence)
```
    Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
    The string1 operand usually contains the regular expression matched against a line for all commands except for command y where string1 contains the source characters for the translation.
    The string2 operand contains the replacement string for the substitute command s. It contains the appended, inserted or changed text for the commands a, i and c, respectively, and the destination characters for the translate command y. All other commands ignore the string2 operand.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Sed options and commands
    string1 - Regular expression matched against a line for all commands except for command y where string1 contains the source characters for the translation.
    string2 - Replacement string for substitute command s; appended, inserted or changed text for a, i and c command; destination characters for translate command y; ignored by all other commands.
    If string2 is a replacement string for the substitute command: an ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression; the characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    (This operand only applies to the commands s, a, i, c and y and is ignored by all other commands).
    occurrence - Substitute for the given occurrences only of the regexp found within the matched string; the occurrence indices are one-based. If empty or omitted, all occurrences are substituted.
    (This operand only applies to the substitute command and is ignored by all other commands).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(String... args)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--comparator" for a subsequent comparator operand value).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(File... files)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(Comparator<? super Line> comparator,
                        File... files)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    comparator - The comparator to use for the line comparisons.
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(Comparator<? super Line> comparator,
                        String... paths)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    comparator - The comparator to use for the line comparisons.
    paths - Pathnames of the files to be sorted, merged, or checked; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(SortOptions options,
                        File... files)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options for the sort command.
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(SortOptions options,
                        String... paths)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options for the sort command.
    paths - Pathnames of the files to be sorted, merged, or checked; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(SortOptions options,
                        Comparator<? super Line> comparator,
                        File... files)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator. All comparison related options except for --reverse are ignored.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options for the sort command.
    comparator - The comparator to use for the line comparisons.
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - sort
```
public static Unix4jCommandBuilder sort(SortOptions options,
                        Comparator<? super Line> comparator,
                        String... paths)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator. All comparison related options except for --reverse are ignored.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options for the sort command.
    comparator - The comparator to use for the line comparisons.
    paths - Pathnames of the files to be sorted, merged, or checked; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - tail
```
public static Unix4jCommandBuilder tail(String... args)
```
    Reads the last n lines from each of the files specified and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--count" for a subsequent count operand value).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - tail
```
public static Unix4jCommandBuilder tail(File... files)
```
    Reads the last 10 lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - tail
```
public static Unix4jCommandBuilder tail(long count,
                        File... files)
```
    Reads the last count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - tail
```
public static Unix4jCommandBuilder tail(long count,
                        String... paths)
```
    Reads the last count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - tail
```
public static Unix4jCommandBuilder tail(TailOptions options,
                        long count,
                        File... files)
```
    Reads the last count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the tail command.
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - tail
```
public static Unix4jCommandBuilder tail(TailOptions options,
                        long count,
                        String... paths)
```
    Reads the last count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - Options for the tail command.
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - uniq
```
public static Unix4jCommandBuilder uniq(File file)
```
    Reads from the specified input file and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated lines in the input are not detected if they are not adjacent (see --global or -g option); sorted input lines always result in unique output lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    file - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - uniq
```
public static Unix4jCommandBuilder uniq(String path)
```
    Reads the file specified by its path and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated lines in the input are not detected if they are not adjacent (see --global or -g option); sorted input lines always result in unique output lines.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    path - The files or directories used as starting point for the listing; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - uniq
```
public static Unix4jCommandBuilder uniq(UniqOptions options,
                        File file)
```
    Reads from the specified input file and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated non-adjacent lines in the input are only detected with the --global or -g option. In other words, unique output lines are guaranteed only if either (a) the --global or -g option is specified, or (b) the input lines are sorted.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the uniqueness details for the output lines.
    file - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - uniq
```
public static Unix4jCommandBuilder uniq(UniqOptions options,
                        String path)
```
    Reads the file specified by its path and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated non-adjacent lines in the input are only detected with the --global or -g option. In other words, unique output lines are guaranteed only if either (a) the --global or -g option is specified, or (b) the input lines are sorted.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining the uniqueness details for the output lines.
    path - The files or directories used as starting point for the listing; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - wc
```
public static Unix4jCommandBuilder wc(File... files)
```
    Executes a count of lines, words and chars contained in each input file and writes them to the standard output. If more than one input file is specified, a line of cumulative counts for all the files is displayed on a separate line after the output for the last file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    files - The input files; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - wc
```
public static Unix4jCommandBuilder wc(WcOptions options,
                      File... files)
```
    Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output. If more than one input file is specified, a line of cumulative counts for all the files is displayed on a separate line after the output for the last file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining command behavior.
    files - The input files; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)
  - wc
```
public static Unix4jCommandBuilder wc(WcOptions options,
                      String[] paths)
```
    Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output. If more than one input file is specified, a line of cumulative counts for all the files is displayed on a separate line after the output for the last file.
    Note that the method returns the command builder to allow for command chaining. The command itself is returned by the build() method of the returned builder (see Unix4jCommandBuilder for more information).
    
    Parameters:
    options - The options defining command behavior.
    paths - Pathnames of the input files; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    the command builder to allow for method chaining. Method chaining is used here to create command chains. Adding a command to the chain usually means that the previous command pipes its output to the added command (the pipe symbol in unix)

Class Unix4j

Method Summary

Methods inherited from class java.lang.Object

Method Detail

builder

use

cat

cat

cat

cat

cd

cd

cd

echo

echo

echo

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

fromString

fromStrings

from

fromFile

fromFile

fromResource

from

from

from

from

grep

grep

grep

grep

grep

grep

grep

head

head

head

head

head

ls

ls

ls

ls

ls

ls

sed

sed

sed

sed

sed

sed

sed

sort

sort

sort

sort

sort

sort

sort

sort

tail

tail