Code Review

public class TextMonitoring {
    public static Map<String, Integer> researchText(String str) {
        Map<String, Integer> map = new HashMap<>();
        for(String string : str.replaceAll("[,.!?]", "").split("[^A-Za-z]+")) {
            map.put(string, map.getOrDefault(string, 0) + 1);
        }
        return map;
    }

    public static int getCountUniqueWords(String str) {
        return researchText(str).size();
    }

    public static Collection<String> getUniqueWords(String str) {
        Collection keyset = researchText(str).keySet();
        return keyset;

    }
    public static int getFrequencyWord(String str, String word) {
        return researchText(str).get(word);
    }

    public static List<Map.Entry<String,Integer>> getFrequencyWords(String str, boolean isAscendingFrequency) {
        List<Map.Entry<String, Integer>> list = new LinkedList(researchText(str).entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>()
        {
            public int compare(Map.Entry<String, Integer> o1,
                               Map.Entry<String, Integer> o2) {
                if (isAscendingFrequency) {
                    var result =  Double.compare(o1.getValue(),o2.getValue());
                    if(result == 0) {
                        return o1.getKey().compareTo(o1.getKey());
                    } else return result;
                } else {
                    return o2.getValue().compareTo(o1.getValue());
                }
            }
        });
        return list;
    }
}

public boolean addToBase(Person personToAdd) {
    if (persons.contains(personToAdd)) {
        System.out.println("Such person is already exists!");
        return false;
    }
    for (Person person : persons) {
        if (person.getPersonID().equals(personToAdd.getPersonID())) {
            System.out.println("You are trying to add person with the same ID!");
            return false;
        }
    }
    persons.add(personToAdd);
    System.out.println("Successfully added");
    return true;
}

public boolean showInfoUsingID(int ID) {
    for (Person person : persons) {
        if (person.getPersonID().equals(String.valueOf(ID))) {
            System.out.println(person);
            return true;
        }
    }
    System.out.println("There is no person with such ID, please correct and try again!");
    return false;
}

public void showInfoUsingPenalties(Penalty penalty) {
    for (Person person : persons) {
        if (person.personPenalties.contains(penalty)) {
            System.out.println(person);
        }
    }
}

public void showInfoUsingCity(String city) {
    for (Person person : persons) {
        if (person.getLivingCity().equals(city)) {
            System.out.println(person);
        }
    }
}

public void showAllInfo() {
    Iterator<Person> iterator = persons.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

public enum Cities {
    MINSK,
    BREST,
    GRODNO,
    MOGILEV,
    GOMEL;
}

public enum Fines {
    FINE01("Drunk driving", 600),
    FINE02("Speeding", 250),
    FINE03("Wrong parking", 50),
    FINE04("Hijacking",1000),
    FINE05("Crash", 450),
    FINE06("Emergency", 300);

    private final Integer sum;
    private final String decoding;

    Fines(String decoding, Integer sum) {
        this.sum = sum;
        this.decoding = decoding;
    }

    public Integer getSum() {
        return sum;
    }

    public String getDecoding() {
        return decoding;
    }
}

public class Taxpayer {
    private String id;
    private String firstName;
    private String lastName;
    private Cities city;
    private Integer fineCounter = 0;
    private HashSet<Fine> fine = new HashSet<>();

@Test
public void addFineForTaxpayerTest1() {
    wantedMen.addFineForTaxpayer(Fines.FINE02, "$$60,000,000,000");

    int actual = vashTheStampede.getFine().size();
    Assertions.assertEquals(1, actual);
}

@Test
public void addFineForTaxpayerTest2() {
    wantedMen.addFineForTaxpayer(Fines.FINE02, "$$60,000,000,000");
    wantedMen.addFineForTaxpayer(Fines.FINE05, "$$60,000,000,000");
    wantedMen.addFineForTaxpayer(Fines.FINE01, "$$60,000,000,000");

    int actual = vashTheStampede.getFine().size();
    Assertions.assertEquals(3, actual);
}

@Test
public void removeFineForTaxpayerTest1() {
    wantedMen.addFineForTaxpayer(Fines.FINE04, "$$40,040,040,040");
    wantedMen.addFineForTaxpayer(Fines.FINE01, "$$40,040,040,040");

    wantedMen.removeFineForTaxpayer("$$40,040,040,040", "$$40,040,040,040#FINE01#2");

    int actual = tetsuoShima.getFine().size();
    Assertions.assertEquals(1, actual);
}

public class Fine {
    private String id;
    private Fines type;
    private Integer sum;
    private String fineDetails;

    public Fine(Fines type, Integer sum, String fineDetails) {
        this.type = type;
        this.sum = sum;
        this.fineDetails = fineDetails;
    }

    public Fine() {
    }

    @Override
    public String toString() {
        return this.type + " FINE: id " + this.id + " " + this.fineDetails + " " + this.sum + " BYN\n";
    }

public void personInfoRenew(Person person, String name, String lastName, Cities city) {
    for (Person personToRenew : this.personData) {
        if(personToRenew == person) {
            person.setName(name);
            person.setLastName(lastName);
            person.setCity(city);
        }
    }
}

public void fineInfoRenew(String id, Fines type, Integer sum, String fineDetails) {
    for (Person person : this.personData) {
        for (Fine fine : person.getFines()) {
            if (Objects.equals(fine.getId(), id)) {
                fine.setType(type);
                fine.setSum(sum);
                fine.setFineDetails(fineDetails);
            }
        }
    }
}

@DisplayName("Test addPerson(), adds Person to TaxService")
@Test
void addPersonTest() {
    belarusTexService.addPerson(elenaBlinovskaya);

    Assertions.assertTrue(belarusTexService.getPersonData().contains(dzmitryRakovets));
}