Найти наибольшее количество предложений текста, в которых есть одинаковые слова

private int findMax(String str) {
        byte[] bytes = str.getBytes();
        byte tocka = '.';
        byte vopr = '?';
        byte voscl = '!';
   
        Map<String, Integer> sentences = new HashMap<String, Integer>(); 
        
        int max = bytes.length;
        if (max>0) {
            int i = 0;
            byte a;
            
            while(i<max){
                String sentence = "";
                
                while(i<max){
                    a = bytes[i];
                    i = i + 1;
 
                    if(i<max){
                        if(a == tocka || a == vopr || a == voscl){ //ПРЕДЛОЖЕНИЕ.
                            //проверяем следующий символ
                            a = bytes[i];
                            i = i + 1;
                            if(i<max){
                                if(a == tocka || a == vopr || a == voscl){ //возможно это троеточие, почемубы и нет? или ???
                                    while(i<max){
                                        a = bytes[i];
                                        if(a!=tocka && a!=vopr && a!=voscl){
                                            break;
                                        }
                                        i = i + 1;
                                    }
                                }
                            }
                            break;
                        }
                    }
                    
                    byte[] dwawdawkda = { a }; 
                    
                    sentence += new String(dwawdawkda);
 
                }                
                sentences.put(sentence, 0);
                
                String[] wordsInSentence = sentence.split(" ");
                
                
                for(int j = 0; j < wordsInSentence.length; j++) {
                    wordsInSentence[j] = wordsInSentence[j].replaceAll("[^a-zA-Z]", "");
                    System.out.println(wordsInSentence[j]);
                }
                
                HashMap<String, Integer> originallyWords = new HashMap<String, Integer>(); 
                for(int j = 0; j < wordsInSentence.length; j++) {
                    if (originallyWords.containsKey(wordsInSentence[j])) {
                        Integer figure = originallyWords.get(wordsInSentence[j]);
                        originallyWords.put(wordsInSentence[j], ++figure);
                    } else {
                        originallyWords.put(wordsInSentence[j], 1);
                    }
                }
                sentences.put(
                    sentence, 
                    originallyWords.entrySet().stream()
                        .sorted(Map.Entry.<String, Integer>comparingByValue()
                        .reversed()).iterator().next().getValue()
                );
                sentence = "";
            }
        }
        
        HashMap.Entry<String, Integer> entry = sentences.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).iterator().next();
        
        String key = entry.getKey();
        Integer value = entry.getValue();
        
        System.out.println(sentences);
        
        System.out.println(key);
        System.out.println(String.valueOf(value));
    
        return value;
    }

public List<String> foo(String source) {
        return Arrays.stream(source.split("[.!?]"))
                .map(line -> line.replaceAll("\\W+", " "))
                .sorted(Collections.reverseOrder(Comparator.comparingLong(x -> Arrays.stream(x.split(" "))
                        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                        .values()
                        .stream()
                        .max(Comparator.comparingLong(Long::longValue))
                        .get())))
                .collect(Collectors.toList());
    }