oop-labs-collection/labs/3/Finder.java

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Pattern;
import lab3lib.Fetcher;

public class Finder {
    public static void main(String[] args) {
        boolean demoContent = false;
        
        StringBuilder inputStringBuilder = new StringBuilder();
        if (demoContent) {
            inputStringBuilder = new StringBuilder("Testing, text to make up words. Testing, text without specific, up words. Therefore, we don't care about arteriscs and other useless symbols, as the only reason to use it is when the code runs horrible.");
        } else {
            inputStringBuilder = receiveText();
        }

        System.out.println("Processing string: " + inputStringBuilder);

        final StringBuilder[] sentences = splitStringBuilder(inputStringBuilder, "[.?!] ?");
        Set<StringBuilder> firstSentenceWords = new HashSet<StringBuilder>();

        for (StringBuilder word : splitStringBuilder(sentences[0], ",? ")) {
            firstSentenceWords.add(word);
        }

        final long startTime = System.nanoTime();

        for (StringBuilder sentence : subarrayStringBuilder(sentences, 1, sentences.length)) {
            StringBuilder[] words = splitStringBuilder(sentence, ",? ");

            for (StringBuilder word1 : words) {
                System.out.print("Searching for '" + toLowerCaseStringBuilder(word1) + "' in " + firstSentenceWords.toString() + "...");

                Set<StringBuilder> tempWords = new HashSet<>(firstSentenceWords);
                
                boolean wordFound = false;
                for (StringBuilder word2 : firstSentenceWords) {
                    if (compareStringBuilders(toLowerCaseStringBuilder(word1), toLowerCaseStringBuilder(word2))) {
                        wordFound = true;
                        tempWords.remove(word2);
                        break;
                    }
                }
                
                if (wordFound) {
                    System.out.println(" found!");
                    firstSentenceWords = tempWords;
                } else {
                    System.out.println(" absent.");
                }
            }
        }

        final long endTime = System.nanoTime();

        System.out.println(getFinalMessage(firstSentenceWords));
        System.out.println("Stats: search execution took " + (endTime - startTime) + "ns");
    }

    private static StringBuilder receiveText() {
        try {
            return Fetcher.fetchTextFromPython();
        } catch (Exception e) {
            return new StringBuilder("Testing, text to make up words. Testing, text without specific, up words. Therefore, we don't care about arteriscs and other useless symbols, as the only reason to use it is when the code runs horrible.");
        }
    }

    private static StringBuilder toLowerCaseStringBuilder(StringBuilder inputStringBuilder) {
        return new StringBuilder(new String(inputStringBuilder).toLowerCase());
    }

    private static StringBuilder getFinalMessage(Set<StringBuilder> s) {
        if (s.size() == 1) {
            return new StringBuilder("Found the word '" + s.iterator().next() + "'");
        } else if (s.size() > 1) {
            return new StringBuilder("Found more than one word (" + s.toString() + "), can't pick one.");
        } else {
            return new StringBuilder("No such word has been found!");
        }
    }

    private static boolean compareStringBuilders(StringBuilder a, StringBuilder b)
    {
        if (a.length() == b.length())
        {
            for (int i = 0; i < a.length(); i++)
            {
                if (a.charAt(i) != b.charAt(i))
                {
                    return false;
                }
            }
            return true;
        } 
        else
        {
            return false;
        }
    }

    // apparently, this is incredibly complicated in Java
    private static String[] subarray(String[] array, int start, int end) {
        String[] result = new String[end - start];

        for (int i = start, j = 0; i < end; i++, j++) {
            result[j] = array[i];
        }

        return result;
    }
    
    // little wrapper to simplify StringBuilder usage task
    private static StringBuilder[] subarrayStringBuilder(StringBuilder[] array, int start, int end) {
        String[] tempArray = subarray(stringBuilderArrayToStringArray(array), start, end);
        return stringArrayToStringBuilderArray(tempArray);
    }
    
    // name describes it well enough
    private static StringBuilder[] stringArrayToStringBuilderArray(String[] inputArray) {
        StringBuilder[] outputArray = new StringBuilder[inputArray.length];

        for (int i = 0; i < inputArray.length; i++) {
            outputArray[i] = new StringBuilder(inputArray[i]);
        }

        return outputArray;
    }

    // reverse of the above
    private static String[] stringBuilderArrayToStringArray(StringBuilder[] inputArray) {
        String[] outputArray = new String[inputArray.length];

        for (int i = 0; i < inputArray.length; i++) {
            outputArray[i] = new String(inputArray[i]);
        }

        return outputArray;
    }
    
    // same as String split method but using StringBuilder
    private static StringBuilder[] splitStringBuilder(StringBuilder input, String regexp) {
        String[] tempStrings = Pattern.compile(regexp).split(input);
        return stringArrayToStringBuilderArray(tempStrings);
    }

}