От автора
«Куда только не заведёт любопытство» — именно с этих слов и началась эта история.
Дело обстояло так.
Вернулся я из командировки из США, где провел целый месяц своей жизни. Готовился я Вам скажу я к ней основательно и прилично так налегал на английский, но вот не задача, приехав к заморским друзьям я понял что совершенно их не понимаю. Моему огорчению не было придела. Первым делом по приезду я встретился с другом, который свободно говорит по английски, излил ему душу и услышал в ответ: «… ты просто не те слова учил, нужно учить самые популярные… запас слов, который используется в повседневных разговорах не более 1000 слов...»
Хм, так ли это?, возник вопрос в моей голове… И пришла мне в голову идея проанализировать разговорный текст, так сказать, определить те самые употребляемые слова.
Исходные данные
В качестве разговорного текста я решил взять сценарий одной из серий сериала друзья, заодно и проверим гипотезу — «… если смотреть сериалы на английском, то хорошо подтянешь язык ...» (сценарий без особого труда можно найти в интернете)
Используемые технологии
- Java SE 8
- Eclipse Mars 2
Ожидаемый результат
Результатом нашего творчества станет jar библиотека, которая будет составлять лексический минимум для текста с заданным процентом понимания. То есть мы например хотим понять 80% всего текста и библиотека, проанализировав текст выдаёт нам набор слов, которые необходимо для этого выучить.
И так, поехали.
Объекты DTO (боевые единицы)
ReceivedText.java
package ru.lexmin.lexm_core.dto;
/**
* Класс для получения от пользователя введённой информации а виде текста (text)
* и процента понимания (percent)
*
*/
public class ReceivedText {
/**
* Версия
*/
private static final long serialVersionUID = 5716001583591230233L;
// текст, который ввёл пользователь
private String text;
// желаемый процент понимания текста пользователем
private int percent;
/**
* Пустой конструктор
*/
public ReceivedText() {
super();
}
/**
* Конструктор с параметрами
*
* @param text
* {@link String}
* @param percent
* int
*/
public ReceivedText(String text, int percent) {
super();
this.text = text;
this.percent = percent;
}
/**
* @return text {@link String}
*/
public String getText() {
return text;
}
/**
* Устанавливает параметр
*
* @param text
* text {@link String}
*/
public void setText(String text) {
this.text = text;
}
/**
* @return percent {@link int}
*/
public int getPercent() {
return percent;
}
/**
* Устанавливает параметр
*
* @param percent
* percent {@link int}
*/
public void setPercent(int percent) {
this.percent = percent;
}
}
WordStat.java
package ru.lexmin.lexm_core.dto;
import java.util.HashMap;
import java.util.Map;
/**
* Класс для передачи рзультов обработки текста в виде: - количество слов в
* тексте - честота употребления каждого слова.
*
* Количество слов хранится в поле countOfWords (int) Частота употребления
* хранится в поле frequencyWords (Map<String, Integer>): - ключом является
* слово - значением частора употребления в тексте
*
* Поле receivedText - содержет ссылку на dto с текстом и процентом понимания.
*
*/
public class WordStat {
/**
* Версия
*/
private static final long serialVersionUID = -1211530860332682161L;
// ссылка на dto с исходным текстом и параметрами
private ReceivedText receivedText;
// кол-во слов в тексте, на который ссылка receivedText
private int countOfWords;
// статистика по часторе слов текста, на который ссылка receivedText,
// отфильтрованная с учётом процента понимания
private Map<String, Integer> frequencyWords;
/**
* Констркутор по умолчанию
*/
public WordStat() {
super();
}
/**
* Конструктор с параметрами
*
* @param receivedText
* @param countOfWords
* @param frequencyWords
*/
public WordStat(ReceivedText receivedText, int countOfWords, Map<String, Integer> frequencyWords) {
this.receivedText = receivedText;
this.countOfWords = countOfWords;
this.frequencyWords = frequencyWords;
}
/**
* Конструктор задаёт значение поля receivedText из передоваемого объекта.
* остальнве поля интциализируются значениями по умолчанию
*
* @param receivedText
*/
public WordStat(ReceivedText receivedText) {
this.receivedText = receivedText;
// инициализация остальных полей значениями по умолчинию
this.countOfWords = 0;
this.frequencyWords = new HashMap<String, Integer>();
}
/**
* @return receivedText {@link ReceivedText}
*/
public ReceivedText getReceivedText() {
return receivedText;
}
/**
* Устанавливает параметр
*
* @param receivedText
* receivedText {@link ReceivedText}
*/
public void setReceivedText(ReceivedText receivedText) {
this.receivedText = receivedText;
}
/**
* @return countOfWords {@link int}
*/
public int getCountOfWords() {
return countOfWords;
}
/**
* Устанавливает параметр
*
* @param countOfWords
* countOfWords {@link int}
*/
public void setCountOfWords(int countOfWords) {
this.countOfWords = countOfWords;
}
/**
* @return frequencyWords {@link Map<String,Integer>}
*/
public Map<String, Integer> getFrequencyWords() {
return frequencyWords;
}
/**
* Устанавливает параметр
*
* @param frequencyWords
* frequencyWords {@link Map<String,Integer>}
*/
public void setFrequencyWords(Map<String, Integer> frequencyWords) {
this.frequencyWords = frequencyWords;
}
}
Ну тут всё просто и понятно, думаю комментариев в коде достаточно
Интерфейс анализатора текстов (определяем функциональность)
TextAnalyzer.java
package ru.lexmin.lexm_core;
import ru.lexmin.lexm_core.dto.ReceivedText;
import ru.lexmin.lexm_core.dto.WordStat;
/**
* Данный интерфейс описывает основной функционал анализа получаемого от
* пользователя текста
*
*/
public interface TextAnalyzer {
/**
* Мемод получает объект класса {@link WordStat}, заполненный данными,
* актуальными для передаваемого объекта {@link ReceivedText}
*
* @param receivedText
* {@link ReceivedText}
* @return возврашает заполненный {@link WordStat}
*/
public abstract WordStat getWordStat(ReceivedText receivedText);
}
Нам будет достаточно всего одного внешнего метода, который нам вернёт WordStat (DTO), из которого мы потом и вытащим слова.
Реализация анализатора текстов
TextAnalyzerImp.java
package ru.lexmin.lexm_core;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import ru.lexmin.lexm_core.dto.ReceivedText;
import ru.lexmin.lexm_core.dto.WordStat;
/**
* Этот класс является реализацией интерфейса TextAnalyzer
*
*/
public class TextAnalyzerImp implements TextAnalyzer {
/* Константы */
private final int PERCENT_100 = 100;
private final int ONE_WORD = 1;
private final String SPACE = " ";
// регулярное выражение: все испольуемые апострофы
private final String ANY_APOSTROPHE = "[’]";
// применяемый, стандартный апостроф
private final String AVAILABLE_APOSTROPHE = "'";
// регулярное выражение: не маленькие латинские буквы, не пробел и не
// апостроф(')
private final String ONLY_LATIN_CHARACTERS = "[^a-z\s']";
// регулярное выражение: пробелы, более двух подрят
private final String SPACES_MORE_ONE = "\s{2,}";
/**
* Метод преобразует передаваемый текст в нижнеме регистру, производит
* фильтрацию текста. В тексте отсаются только латинские буквы, пробельные
* символы и верхний апостроф. Пробелы два и более подрят заменяются одним.
*
* @param text
* {@link String}
* @return отфильтрованный текст
*/
private String filterText(String text) {
String resultText = text.toLowerCase().replaceAll(ANY_APOSTROPHE, AVAILABLE_APOSTROPHE)
.replaceAll(ONLY_LATIN_CHARACTERS, SPACE).replaceAll(SPACES_MORE_ONE, SPACE);
return resultText;
}
/**
* Метод преобразует получаемый текст в Map<{слво}, {количество}>
*
* @param text
* {@link String}
* @return заполненный Map
*/
private Map<String, Integer> getWordsMap(String text) {
Map<String, Integer> wordsMap = new HashMap<String, Integer>();
String newWord = "";
Pattern patternWord = Pattern.compile("(?<word>[a-z']+)");
Matcher matcherWord = patternWord.matcher(text);
// поиск слов в тексте по паттерну
while (matcherWord.find()) {
newWord = matcherWord.group("word");
if (wordsMap.containsKey(newWord)) {
// если слово уже есть в Map то увеличиваеи его количество на 1
wordsMap.replace(newWord, wordsMap.get(newWord) + ONE_WORD);
} else {
// если слова в Map нет то добавляем его со значением 1
wordsMap.put(newWord, ONE_WORD);
}
}
return wordsMap;
}
/**
* Метод возвращает общее количество слов, суммируя частоту употребления
* слов в получаемом Map
*
* @param wordsMap
* {@link Map}
* @return общее количество слов в тексте, по которому составлен Map
*/
private int getCountOfWords(Map<String, Integer> wordsMap) {
int countOfWords = 0;
// считаем в цикле сумму значений для всех слов в Map
for (Integer value : wordsMap.values())
countOfWords += value;
return countOfWords;
}
/**
* Метод производит вычисление процентрого соотнашения аргумента
* numberXPercents от аргумента number100Percents
*
* @param number100Percents
* int
* @param numberXPercents
* int
* @return прочентное соотношение
*/
private int getPercent(int number100Percents, int numberXPercents) {
return (numberXPercents * PERCENT_100) / number100Percents;
}
/**
* Метод выполняет фильтрацию слов в массива, чтобы их количество покрывало
* заданный процент понимания текста
*
* @param wordsMap
* {@link Map}
* @param countOfWords
* int
* @param percent
* int
* @return возвращает отфильтрованный массив, элементы когорого
* отсорвированы по убывающей
*/
private Map<String, Integer> filterWordsMap(Map<String, Integer> wordsMap, int countOfWords, int percent) {
// LinkedHashMap - ассоциативный массив, который запоминает порядок
// добавления элементов
Map<String, Integer> resultMap = new LinkedHashMap<String, Integer>();
int sumPercentOfWords = 0;
// создаёт поток из Map с записями Entry<String, Integer>,
// отсортированными по убыванию
Stream<Entry<String, Integer>> streamWords = wordsMap.entrySet()
.stream().sorted(Map.Entry.comparingByValue(
(Integer value1, Integer value2) -> (
value1.equals(value2)) ? 0 : ((value1 < value2) ? 1 : -1)
)
);
// создаём итератор для обхода всех записей потока
Iterator<Entry<String, Integer>> iterator = streamWords.iterator();
// добавляем в resultMap каждую последующую запись из итератора, пока не
// будет тостигнут заданный процент понимания
while (iterator.hasNext() && (sumPercentOfWords < percent)) {
Entry<String, Integer> wordEntry = iterator.next();
resultMap.put(wordEntry.getKey(), wordEntry.getValue());
sumPercentOfWords += getPercent(countOfWords, wordEntry.getValue());
}
return resultMap;
}
/*
* (non-Javadoc)
*
* @see
* ru.lexmin.lexm_core.TextAnalyzer#getWordStat(ru.lexmin.lexm_core.dto.
* ReceivedText)
*/
@Override
public WordStat getWordStat(ReceivedText receivedText) {
WordStat wordStat = new WordStat(receivedText);
Map<String, Integer> wordsMap = getWordsMap(filterText(receivedText.getText()));
wordStat.setCountOfWords(getCountOfWords(wordsMap));
wordStat.setFrequencyWords(
filterWordsMap(wordsMap, wordStat.getCountOfWords(), receivedText.getPercent())
);
return wordStat;
}
}
Я постарался максимально подробно закомментировать все методы.
Если кратко, то происходит следующее:
Сначала из текста вырезается всё что является латинскими буквами, апострофами или пробелами. Количество пробелов более 2х подряд заменяется одним. Делается это в методе метод filterText(String text).
Далее из подготовленного текста формируется массив слов — Map<слово, количество в тексте>. За это отвечает метод getWordsMap(String text).
Подсчитываем общее количество слов методом getCountOfWords(Map<String, Integer> wordsMap)
И наконец фильтруем нужные нам слова, для того чтобы покрыть N% текста методом filterWordsMap(Map<String, Integer> wordsMap, int countOfWords, int percent)
Ставим эксперимент (выведем в консоль список слов)
package testText;
import ru.lexmin.lexm_core.TextAnalyzer;
import ru.lexmin.lexm_core.TextAnalyzerImp;
import ru.lexmin.lexm_core.dto.ReceivedText;
import ru.lexmin.lexm_core.dto.WordStat;
public class Main {
public static void main(String[] args) {
final int PERCENT = 80;
TextAnalyzer ta = new TextAnalyzerImp();
String friends = "There's nothing to tell! He's .... тут текст двух серий первого сезона";
ReceivedText receivedText = new ReceivedText(friends, PERCENT);
WordStat wordStat = ta.getWordStat(receivedText);
System.out.println("Количество слов в тексте: " + wordStat.getCountOfWords());
System.out.println("Количество слов, покрывающие 80% текста: " + wordStat.getFrequencyWords().size());
System.out.println("Список слов, покрывающих 80% текста");
wordStat.getFrequencyWords().forEach((word, count) -> System.out.println(word));
}
}
Результат
Количество слов в тексте: 1481
Количество слов, покрывающие 80% текста: 501
Список слов, покрывающих 80% текста: i, a, and, you, the, to, just, this, it, be, is, my, no, of, that, me, don't, with, it's, out, paul, you'r, have, her, okay, … и так далее
Заключение
В данном эксперименте мы проанализировали только две серии первого сезона и делать какие-либо выводы рано, но две серии идут около 80-90 мин и для их понимания (остальные 20% оставляем на додумывание, логику и зрительное восприятие) достаточно всего 501 слово.
P.S.: От себя хочу сказать что мои друзья заинтересовались этим экспериментом, и мы будем развивать эту тему. Было принято решение начать создание портала, на котором любой желающий сможет проанализировать интересующий его текст. По результатам таких анализов будет собираться статистика и формироваться ТОРы английских слов.
О всех наших проблемах и достижениях на этом тернистом пути я буду писать в следующих постах. Спасибо за внимание и, надеюсь, до новых встреч.
Автор: entony
