[НП] - Text Processor 2

import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.stream.Collectors;

class Text{
    private String line; //linija bez znaci, lower char
    private String original; //originalnata linija potrebna za da se presmeta slicnost
    Map<String, Integer> wordFrequencies; //zbor so negovite pojavuvanja
    List<Integer> freq; //frekvencija na site zborovi pojaveni vo site tekstovi

    public Text(String line) {
        this.original = line;
        this.line = line.toLowerCase().replaceAll("[^A-Za-z\\s+]", "");
        this.wordFrequencies = new HashMap<>();
        this.freq = new ArrayList<>();
        fillTheMap();
    }

    public void fillTheMap(){
        String [] parts = line.split("\\s+");
        for (int i=0; i<parts.length; i++){
            int finalI = i;
            wordFrequencies.computeIfAbsent(parts[finalI], (k) -> wordFrequencies.put(parts[finalI],0));
            wordFrequencies.put(parts[finalI], wordFrequencies.get(parts[finalI])+1);
        }
    }

    public String getFreq(Set<String> words){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        words.forEach(word -> {
            if (wordFrequencies.containsKey(word)) {
                sb.append(wordFrequencies.get(word) + ", ");
                freq.add(wordFrequencies.get(word));
            }
            else {
                sb.append(0 + ", ");
                freq.add(0);
            }
        });
        sb.deleteCharAt(sb.lastIndexOf(","));
        sb.deleteCharAt(sb.lastIndexOf(" "));
        sb.append("]");
        return sb.toString();
    }

    public int getOccurencies(String word){
        return wordFrequencies.getOrDefault(word, 0);
    }

    public List<Integer> frequencies(){
        return freq;
    }

    @Override
    public String toString() {
        return original;
    }
}

class TextProcessor{
    List<Text> textLines;
    Set<String> words;
    Map<String, Integer> map;

    public TextProcessor() {
        this.textLines = new ArrayList<>();
        this.words = new TreeSet<>(String::compareTo);
        this.map = new TreeMap<>();
    }

    public void readText(InputStream is){
        Scanner in = new Scanner(System.in);

        while (in.hasNextLine()){
            String line = in.nextLine();
            textLines.add(new Text(line));
            line = line.replaceAll("[^A-Za-z\\s+]", "");
            line = line.toLowerCase();

            String [] parts = line.split("\\s+");
            words.addAll(Arrays.asList(parts));
        }
        fillTheMap();
    }

    public void fillTheMap(){
        words.forEach(word -> {
            textLines.forEach(text -> {
                map.computeIfAbsent(word, (k) -> map.put(word, 0));
                map.put(word, map.get(word)+text.getOccurencies(word));
            });

        });
    }

    public void printTextsVectors(OutputStream os){
        textLines.forEach(text -> {
            System.out.println(text.getFreq(words));
        });
    }

    public void printCorpus(OutputStream os, int n, boolean ascending){
        Comparator<Integer> comparatorAscending = Comparator.comparingInt(Integer::intValue);
        Comparator<Integer> comparatorDescending = Comparator.comparingInt(Integer::intValue).reversed();

        Comparator<Integer> comparator = ascending ? comparatorAscending : comparatorDescending;

        map.entrySet().stream().sorted(Map.Entry.comparingByValue(comparator))
                .limit(n)
                .forEach(entry -> System.out.println(entry.getKey()+" : "+entry.getValue()));
    }

    public void mostSimilarTexts(OutputStream os){
        double maxSimilarity = 0;
        int maxI = 0;
        int maxJ = 0;
        for(int i=0; i<textLines.size()-1; i++){
            for (int j=0; j<textLines.size(); j++){
                if (i!=j){
                    double similarity = CosineSimilarityCalculator.cosineSimilarity(textLines.get(i).frequencies(), textLines.get(j).frequencies());
                    if (similarity > maxSimilarity){
                        maxSimilarity = similarity;
                        maxI = i;
                        maxJ = j;
                    }
                }
            }
        }
        System.out.println(textLines.get(maxI));
        System.out.println(textLines.get(maxJ));
        System.out.println(String.format("%.10f", maxSimilarity));
    }
}


class CosineSimilarityCalculator {
    public static double cosineSimilarity (Collection<Integer> c1, Collection<Integer> c2) {
        int [] array1;
        int [] array2;
        array1 = c1.stream().mapToInt(i -> i).toArray();
        array2 = c2.stream().mapToInt(i -> i).toArray();
        double up = 0.0;
        double down1=0, down2=0;

        for (int i=0;i<c1.size();i++) {
            up+=(array1[i] * array2[i]);
        }

        for (int i=0;i<c1.size();i++) {
            down1+=(array1[i]*array1[i]);
        }

        for (int i=0;i<c1.size();i++) {
            down2+=(array2[i]*array2[i]);
        }

        return up/(Math.sqrt(down1)*Math.sqrt(down2));
    }
}

public class TextProcessorTest {

    public static void main(String[] args) {
        TextProcessor textProcessor = new TextProcessor();

        textProcessor.readText(System.in);

        System.out.println("===PRINT VECTORS===");
        textProcessor.printTextsVectors(System.out);

        System.out.println("PRINT FIRST 20 WORDS SORTED ASCENDING BY FREQUENCY ");
       textProcessor.printCorpus(System.out,  20, true);

        System.out.println("PRINT FIRST 20 WORDS SORTED DESCENDING BY FREQUENCY");
        textProcessor.printCorpus(System.out, 20, false);

        System.out.println("===MOST SIMILAR TEXTS===");
        textProcessor.mostSimilarTexts(System.out);
    }
}