Подскажите как оптимизировать

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.*;
 
import static java.lang.Integer.parseInt;
import static jdk.nashorn.internal.objects.NativeString.trim;
 
public class fileSorting {
 
    private final static String INTTYPE = "-i";
    private final static String STRINGTYPE = "-s";
    private final static String SORTBYASC = "-a";
    private final static String SORTBYDESC = "-d";
 
    private static void mainSort(String inFile, String outFile, String dataType, String sortBy) throws FileNotFoundException {
 
        List<String> linesList = new ArrayList<>();
        try (Scanner scanner = new Scanner(new FileInputStream(inFile))) {
            while (scanner.hasNextLine()) {
                linesList.add(trim(scanner.nextLine()));
            }
        }
 
        if (dataType.equals(INTTYPE)) {
 
            if (sortBy.equals(SORTBYASC)) {
                int[] arrayInts = ascendingSortInt(linesList);
                try (PrintWriter writer = new PrintWriter(outFile)) {
                    for (int currentInt : arrayInts) {
                        writer.println(currentInt);
                    }
                }
 
            } else if (sortBy.equals(SORTBYDESC)) {
 
                int[] arrayInts = descendingSortInt(linesList);
                try (PrintWriter writer = new PrintWriter(outFile)) {
                    for (int currentInt : arrayInts) {
                        writer.println(currentInt);
                    }
                }
 
            } else {
                throw new IllegalArgumentException("Incorrect command format");
            }
 
        } else if (dataType.equals(STRINGTYPE) && sortBy.equals(SORTBYASC)) {
 
            String[] arrayWords = ascendingSortWords(linesList);
            try (PrintWriter writer = new PrintWriter(outFile)) {
                for (String currentWord : arrayWords) {
                    writer.println(currentWord);
                }
            }
 
        } else {
            throw new IllegalArgumentException("Incorrect command format");
        }
    }
 
    private static String[] ascendingSortWords(List<String> linesList) {
        String[] arrayWords = linesList.toArray(new String[linesList.size()]);
        for (int i = 1; i < arrayWords.length; i++) {
            String insertionElement = arrayWords[i];
            for (int j = 0; j < i; j++) {
                if (insertionElement.compareTo(arrayWords[j]) <= 0) {
                    System.arraycopy(arrayWords, j, arrayWords, j + 1, i - j);
                    arrayWords[j] = insertionElement;
                    break;
                }
            }
        }
        return arrayWords;
    }
 
    private static int[] ascendingSortInt(List<String> linesList) {
        int[] arrayInts = new int[linesList.size()];
        for (int i = 0; i < linesList.size(); i++) {
            try {
                arrayInts[i] = parseInt(linesList.get(i));
            } catch (Exception e) {
                throw new NumberFormatException("for this command need file with numbers");
            }
        }
 
        for (int i = 1; i < arrayInts.length; i++) {
            int insertionElement = arrayInts[i];
            for (int j = 0; j < i; j++) {
                if (insertionElement < arrayInts[j]) {
                    System.arraycopy(arrayInts, j, arrayInts, j + 1, i - j);
                    arrayInts[j] = insertionElement;
                    break;
                }
            }
        }
        return arrayInts;
    }
 
    private static int[] descendingSortInt(List<String> linesList) {
        int[] arrayInts = new int[linesList.size()];
        for (int i = 0; i < linesList.size(); i++) {
            try {
                arrayInts[i] = parseInt(linesList.get(i));
            } catch (Exception e) {
                throw new NumberFormatException("for this command need file with numbers");
            }
        }
 
        for (int i = 1; i < arrayInts.length; i++) {
            int insertionElement = arrayInts[i];
            for (int j = 0; j < i; j++) {
                if (insertionElement > arrayInts[j]) {
                    System.arraycopy(arrayInts, j, arrayInts, j + 1, i - j);
                    arrayInts[j] = insertionElement;
                    break;
                }
            }
        }
        return arrayInts;
    }
 
    public static void main(String[] args) throws FileNotFoundException {
 
        if (args.length == 4) {
            System.out.println("COMPLETED SORTING!!!");
            mainSort(args[0], args[1], args[2], args[3]);
        } else {
            throw new IllegalArgumentException("Incorrect command format");
        }
 
    }
}

public static final Path SOURCE = Paths.get("D:/test.txt");
    public static final Path STRINGS = Paths.get("D:/strings.txt");
    public static final Path NUMBERS = Paths.get("D:/numbers.txt");
    public static final boolean IS_STRING = false;
    public static final boolean IS_NUMBER = true;
    public static final boolean IS_STRING_REVERSE = true;
    public static final boolean IS_NUMBER_REVERSE = true;
 
    public static void main(String[] args) throws InterruptedException {
        try (Stream<String> lines = Files.lines(SOURCE)) {
            Map<Boolean, List<String>> map = lines.collect(Collectors.groupingBy(StringUtils::isNumeric));
            map.put(IS_STRING, map.get(IS_STRING).stream().sorted(getStringComparator()).collect(Collectors.toList()));
            map.put(IS_NUMBER, map.get(IS_NUMBER).stream().map(line -> Long.parseLong(line)).sorted(getComparator()).map(l -> l.toString()).collect(Collectors.toList()));
            Files.write(STRINGS, map.get(IS_STRING));
            Files.write(NUMBERS, map.get(IS_NUMBER));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    private static Comparator<Long> getComparator() {
        return IS_NUMBER_REVERSE ? Comparator.reverseOrder() : Comparator.naturalOrder();
    }
 
    private static Comparator<String> getStringComparator() {
        return IS_STRING_REVERSE ? Comparator.reverseOrder() : Comparator.naturalOrder();
    }