Java code style: как правильно оформлять код java

5 ответов

Да, полезно упомянуть, что вы работаете с немецким

Детектор предложений на основе регулярных выражений со списком сокращений можно найти в GATE. Он использует три файла, расположенных здесь. Регулярные выражения довольно просты:

Код, использующий эти 3 файла, можно найти здесь.

Я думаю, что код слишком длинный, чтобы вставлять его сюда. Вы должны увидеть метод execute (). Как правило, он находит все совпадения для внутренних, внешних и блокирующих регулярных выражений, затем выполняет итерацию и использует только те внутренние и внешние выражения, которые не перекрываются ни с одним из блокирующих.

Вот некоторые фрагменты, которые вы должны просмотреть / использовать повторно:

Как файлы разбираются

В методе execute как заполняются блокирующие разрывы:

Надеюсь это поможет.

Есть еще одно решение. Не знаю, как с производительностью по сравнению с вашим решением, но, безусловно, наиболее полно. Вы можете использовать библиотеку ICU4J и файлы srx. Библиотеку можно скачать здесь http://site.icu-project.org/ download / 52 # TOC-ICU4J-Download. Многоязычный.

В целом, я думаю, что OpenNLP будет лучше (с точки зрения производительности), чем сегментаторы на основе правил, такие как Stanford segmenter или реализация регулярного выражения для решения задачи. Сегментеры на основе правил неизбежно пропускают некоторые исключения. Как, например, немецкое предложение «Ich wurde am 17. Dezember geboren» (я родился 17 декабря) будет ошибочно разбито на 2 предложения после 17. многие сегментеры, основанные на правилах, особенно если они построены. по английским правилам, а не по немецким. Подобные предложения будут встречаться, даже если качество вашего текста действительно хорошее, поскольку они составляют грамматически правильный немецкий язык

Поэтому очень важно проверить, на какой языковой модели моделируется сегментатор, который вы хотите использовать

PS: Среди OpenNLP, BreakIterator segmenter и Stanford segmenter OpenNLP работал у меня лучше всего.

Разделите строку специальными символами регулярного выражения.

3.1 split() принимает регулярное выражение в качестве аргумента, и в регулярном выражении 12 специальных символов имеют особое значение:

P.S Обе закрывающие квадратные скобки ] и закрывающая фигурная скобка > это обычный персонаж, не нужно убегать.

3.2 Если мы хотим использовать любой из вышеперечисленных специальных символов в качестве разделителя, мы должны избежать его. Например, если мы хотим разделить строку вертикальной чертой или символом трубы | (специальный символ регулярного выражения), что означает или в регулярном выражении, мы должны избежать символа |, используя один из следующих способов:

3.3 Полный пример разделения строки символом /.

Принцип (почему класс String неизменен)

1. Что такое неизменный объект

Если объект не может изменить свое состояние после создания, то объект является неизменяемым (Immutable). Невозможность изменить состояние означает, что переменные-члены в объекте не могут быть изменены, включая значение переменной базового типа данных. Переменная ссылочного типа не может указывать на другие объекты, и состояние объекта, на который указывает ссылочный тип, не может быть изменено.

2. Роль последних ключевых слов

Если вы хотите создать неизменяемый объект, ключевым шагом является объявление всех переменных-членов как окончательных типов. Итак, вот краткий обзор роли последнего ключевого слова:

• Последний класс модификации означает, что класс не может быть унаследован, широко известный как вымерший класс, все методы этого класса автоматически становятся конечными методами.
• Метод окончательной модификации, что означает, что подклассы не могут переопределить этот метод.
• Final изменяет переменную базового типа данных, что означает, что переменная постоянна и значение не может быть изменено
• Final изменяет переменные ссылочного типа, указывая, что ссылка не может указывать на другие объекты после создания объекта, но состояние объекта, на который указывает ссылка, может быть изменено

3. Анализ неизменности класса String.

Сначала посмотрите на следующий код:

Увидев это, вы можете усомниться в том, что String является неизменяемым объектом, потому что из распечатанного результата видно, что значение s действительно изменилось. На самом деле это не так, потому что s — это просто ссылка на объект String, а не на сам объект String. Когда выполняется строка кода в (1), в пуле констант времени выполнения области метода будет создан объект String «abc», а затем ссылка на объект String будет создана в стеке Java. s, и пусть s указывает на «abc», как показано ниже:

Когда строка кода в (2) выполняется, новый объект String «123» будет создан в пуле констант времени выполнения области метода, а затем ссылка s будет перенаправлена ​​на этот новый объект, а исходный объект «abc» В памяти нет изменений, как показано на следующем рисунке:

4. Принцип неизменности класса String.

Чтобы понять неизменность класса String, сначала посмотрите, какие переменные-члены находятся в классе String. В JDK1.8 переменные-члены String в основном имеют следующее:

Прежде всего, вы можете видеть, что класс String использует модификатор final, указывая на то, что класс String не наследуется. Затем мы в основном сосредотачиваемся на значении переменной-члене класса String. Это значение имеет тип char [], поэтому объект String фактически инкапсулируется с этим массивом символов. Если посмотреть на модификатор значения, используется private, а метод setter не предоставляется. Следовательно, значение не может быть изменено за пределами класса String, а значение также изменяется с помощью final. Тогда значение не может быть изменено внутри класса String, но приведенное выше является окончательным. В содержании измененных переменных ссылочного типа упоминалось, что это может только гарантировать, что значение не может указывать на другие объекты, но состояние объекта, на который указывает значение, может быть изменено.Посмотрев на исходный код класса String, мы можем обнаружить, что класс String является неизменным.Ключ состоит в том, что инженеры компании SUN очень осторожны, чтобы не перемещать элементы в массиве символов во всех стоящих за ним методах String. Таким образом, ключ к неизменности класса String заключается в базовой реализации, а не только в финале.

5. Действительно ли объект String неизменен?

Как упоминалось выше, хотя value украшен final, это может гарантировать только то, что vaue не может указывать на другие объекты, но состояние объекта, на который указывает value, может быть изменено, то есть элементы в массиве символов, на который указывает value, могут быть изменены. Поскольку value имеет частный тип, вы можете использовать отражение только для получения атрибута value объекта String, а затем изменить элементы в массиве символов, на которые указывает значение. Подтвердите с помощью следующего кода:

В приведенном выше коде s всегда указывает на один и тот же объект String, но после операции отражения содержимое этого объекта String изменяется. Другими словами, неизменяемые объекты, такие как String, могут быть изменены посредством отражения.

JSON

Сериализация и Десериализация

JSON — невероятно удобный и полезный синтаксис для хранения и обмена данными. Java полностью поддерживает это.

Прим. перев. Для использования JSON из примера необходимо подключить библиотеку JSON Simple.

Вы можете сериализовать данные следующим образом:

Получается следующая строка JSON:

Десериализация в Java выглядит так:

Используемый в примере файл JSON (jsonDemoFile.json):

Прим. перев. В Java проектах очень часто для работы с JSON используют библиотеки Gson от Google или Jackson. Обе библиотеки очень популярны и хорошо поддерживаются. Попробуйте и их.

Поиск в строке в Java

Чтобы найти индекс первого вхождения подстроки в строку, используют метод indexOf(), последнего — метод lastIndexOf(). Если подстрока не найдена, оба метода вернут -1:

String str = "Hello world";
int index1 = str.indexOf('l'); // 2
int index2 = str.indexOf("wo"); //6
int index3 = str.lastIndexOf('l'); //9

Чтобы определить, начинается строка с определённой подстроки, применяют метод startsWith(). Что касается метода endsWith(), то он даёт возможность определить оканчивается ли строка на определенную подстроку:

String str = "myfile.exe";
boolean start = str.startsWith("my"); //true
boolean end = str.endsWith("exe"); //true

Строки

Оптимизация строки

Для конкатенации (сложения) строк в Java используется оператор «+», для примера, в цикле новый объект может создаваться для каждой новой строки, что приводит к потере памяти и увеличению времени работы программы.

Необходимо избегать создания Java строк через конструктор, пример:

Одинарные и двойные кавычки

Что ты ожидаешь в результате выполнения этого кода?

Казалось бы, строка должна возвращать «HaHa», но на самом деле это будет «Ha169».

Java Senior Backend разработчик (Команда NPM)

МТС, Москва, По итогам собеседования

tproger.ru

Вакансии на tproger.ru

Двойные кавычки обрабатывают символы как строки, но одинарные кавычки ведут себя иначе. Они преобразуют символьные операнды ( и ) в целые значения посредством расширения примитивных типов — получается 169.

Разделите строку специальными символами регулярного выражения.

3.1 принимает регулярное выражение в качестве аргумента, и в регулярном выражении имеют особое значение:

1. Точка или точка
2. Знак плюс
3. Звездочка или звезда
4. Знак вопроса
5. Каретка
6. Знак доллара
7. Открывающая и закрывающая скобки и
8. Открывающая квадратная скобка
9. Открывающая фигурная скобка
10. Символ трубы
11. Обратная косая черта

P.S Обе закрывающие квадратные скобки ] и закрывающая фигурная скобка } это обычный персонаж, не нужно убегать.

3.2 Если мы хотим использовать любой из вышеперечисленных специальных символов в качестве разделителя, мы должны избежать его. Например, если мы хотим разделить строку вертикальной чертой или символом трубы | (специальный символ регулярного выражения), что означает в регулярном выражении, мы должны избежать символа |, используя один из следующих способов:

  str.split("\\|")              // backslash \ to escape regex special character

  str.split("")              // character class [] to escape regex  special character

  str.split(Pattern.quote("|")) // Pattern#quote() to escape regex special character

3.3 Полный пример разделения строки символом /.

package com.mkyong;

import java.util.regex.Pattern;

public class SplitString31 {

    public static void main(String[] args) {

        String csv = "a|b|c|d";
        //String[] output = csv.split("\\|");
        //String[] output = csv.split("");
        String[] output = csv.split(Pattern.quote("|"));

        System.out.println(output.length);

        for (String s : output) {
            System.out.println(s);
        }

    }
}

Выход

4
a
b
c
d

3.4 Полный пример разделения строки символом обратной косой черты .

package com.mkyong;

import java.util.regex.Pattern;

public class SplitString32 {

    public static void main(String[] args) {

        String dir = "C:\\Users\\mkyong\\projects\\mkyong-tutorials";
        //String[] output = dir.split("\\\\");
        //String[] output = dir.split("");
        String[] output = dir.split(Pattern.quote("\\"));

        System.out.println(output.length);

        for (String s : output) {
            System.out.println(s);
        }

    }
}

Выход

5
C:
Users
mkyong
projects
mkyong-tutorials

Примеры использования регулярных выражений в Java

Извлечение даты

Теперь давайте извлечём дату из строки:

Проверка:

А вот использование различных режимов квантификаторов, принцип работы которых мы рассмотрели чуть ранее.

Жадный режим

В заданном шаблоне первый символ – . Matcher сопоставляет его с каждым символом текста, начиная с нулевой позиции и захватывая всю строку до конца, в чём и проявляется его «жадность». Вот и получается, что заданная стартовая позиция – это 0, а последняя – 2.

Сверхжадный режим

Принцип, как и в жадном режиме, только поиск заданного символа в обратном направлении не происходит. В приведённой строке всё аналогично: заданная стартовая позиция – это 0, а последняя – 2.

Ленивый режим

Здесь всё просто: самое короткое совпадение находится на первой, второй и третьей позиции заданной строки.

Абстрактные методы в Джаве

Абстрактным называют метод, который объявлен без реализации — он не имеет ни тела, ни даже фигурных скобок. Перед именем такого метода ставят модификатор abstract:

Зачем он такой нужен? В качестве шаблона для других методов из других классов. Вот есть у нас абстрактный класс «Строение», а в нём — абстрактный метод «возвести». Реализовывать эти абстракции нужно через несколько неабстрактных классов-наследников и их методы. Пример: класс «Хижина» — метод «стройХижину», класс «Мост» — метод «стройМост» и др.

Поскольку конкретной реализации у абстрактного класса нет, экземпляры его создавать нельзя. Он — шаблон, который задаёт структуру для других классов и содержит объявления методов.

Кроме этого, рекомендуем помотреть вебинар по введению в ООП на Java, где также будет рассматриваться работа с методами и конструкторами.

Определение и сигнатура

Метод

split

в Java разделяет строку на подстроки, используя разделитель, который определяется с помощью регулярного выражения. Приведем сигнатуру метода и начнем наше погружение:

String[] split(String regex)

Из сигнатуры ясны две вещи:

1. Метод возвращает массив строк.
2. Метод принимает строку regex в качестве параметра.

Разберем каждую вещь по отдельности в разрезе определения, приведенного выше.

1. Метод возвращает массив строк.

   В определении есть такие слова: “Метод split в Java разделяет строку на подстроки”. Данные подстроки собираются методом в массив и представляют собой его возвращаемое значение.

2. Метод принимает строку regex в качестве параметра.

   Опять же, вспомним определение: “разделяет строку на подстроки, используя разделитель, который определяется с помощью регулярного выражения”. Принимаемый параметр regex — это шаблон регулярного выражения, который применяется к исходной строке и по совпадениям определяет в ней символ (или комбинацию символов) разделителя.

Сравниваем строки в Java

Мы уже писали о том, как сравнивать строки в Java, используя для этого метод equals() (регистр учитывается) и equalsIgnoreCase() (регистр не учитывается). Хотелось бы сказать пару слов про ещё одну пару методов: int compareTo(String str) и int compareToIgnoreCase(String str) — они позволяют не только сравнить 2 строки, но и узнать, больше ли одна другой. Если значение, которое возвращается, больше 0, первая строка больше, если меньше нуля, всё наоборот. Когда обе строки равны, вернётся ноль.

Для определения используется лексикографический порядок. Допустим, строка «A» меньше строки «B», ведь символ ‘A’ в алфавите находится перед символом ‘B’. Когда первые символы строк равны, в расчёт берутся следующие символы. К примеру:

String str1 = "hello";
String str2 = "world";
String str3 = "hell";

System.out.println(str1.compareTo(str2)); // -15 - str1 меньше, чем strt2
System.out.println(str1.compareTo(str3)); // 1 - str1 больше, чем str3

Разделение строки при помощи последовательно идущих разделителей

Если вы для разделения строки используете метод и не указываете разделитель, то разделителем считается пробел. При этом последовательно идущие пробелы трактуются как один разделитель.

Но если вы указываете определенный разделитель, ситуация меняется. При работе метода будет считаться, что последовательно идущие разделители разделяют пустые строки. Например, .

Если вам нужно, чтобы последовательно
идущие разделители все-таки трактовались
как один разделитель, нужно воспользоваться
регулярными выражениями. Разницу можно
видеть в примере:

import re

print('Hello1111World'.split('1'))
print(re.split('1+', 'Hello1111World' ))

Результат:

Английский для программистов

Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

Подробнее

×

Регулярные выражения в Java

Поскольку мы говорим о регекспах в Java, то следует учитывать спецификации данного языка программирования.

Экранирование символов в регулярных выражениях Java

В коде Java нередко можно встретить обратную косую черту : этот символ означает, что следующий за ним символ является специальным, и что его нужно особым образом интерпретировать. Так, означает перенос строки. Посмотрим на примере:

Результат:

Поэтому в регулярных выражениях для, например, метасимволов, используется двойная косая черта, чтобы указать компилятору Java, что это элемент регулярки. Пример записи поиска символов пробела:

Ключевые классы

Java RegExp обеспечиваются пакетом java.util.regex. Здесь ключевыми являются три класса:

1. Matcher — выполняет операцию сопоставления в результате интерпретации шаблона.
2. Pattern — предоставляет скомпилированное представление регулярного выражения.
3. PatternSyntaxException — предоставляет непроверенное исключение, что указывает на синтаксическую ошибку, допущенную в шаблоне RegEx.

Также есть интерфейс MatchResult, который представляет результат операции сопоставления.

Требования по оформлению исходного текста программы¶

1. Исходный текст каждого класса программы должен быть размещён в отдельном файле (кроме вложенных классов).

2. Пустые строки внутри класса должны быть только между методами. Порядок следования элементов класса следующий: поля, конструкторы, методы. Пример:

public class Rectangle {
    /** First side length of the rectangle.*/
    private x;
    /** Second side length of the rectangle.*/
    private y;

    /**
     * Constructor.
     * @param x First side length of the rectangle.
     * @param y Second side length of the rectangle.
     */
    public Rectangle (x, y) {
        this.x = x;
        this.y = y;
    }

    /**
     * Constructs square.
     * @param x Side length of the square.
     */
    public Rectangle :x: {
        this.x = x;
    }

    /**
     * Returns whether this rectangle is a square.
     * @returns True if this rectangle is a square and false otherwise.
     */
    public boolean isSquare () {
        return x==y;
    }

   /**
     * Returns the area of the rectangle.
     * @returns The area of the rectangle.
     */
    public int getArea () {
        return x*y;
    }
}

1. Программы должны быть выровнены в соответствии со стилем Кёрнигана и Ричи.

2. Величина отступа всюду должна быть 4 пробела. Запрещается использовать символ табуляции.

3. Все операторы линейной части программы должны иметь один и тот же отступ. Отступ увеличивается для объявлений вложенных классов, полей и методов классов, тел методов, субоператоров (в т. ч. для всех операторов блока, образующего субоператор).

4. При использовании множественного ветвления обязательно следует размещать конструкции строго друг под другом без дополнительных отступов.

5. Точка с запятой, завершающая пустой оператор, должна размещаться на отдельной строке.

6. Не допускается использование строк, длина которых больше 95 символов. Не вмещающиеся части строки переносятся на следующие строки с отступом относительно предыдущей строки. Рекомендуется использовать отступ вдвое больше определённого для программы. Перенос строк, содержащих объявление метода, допускается осуществлять без отступа.

7. Запрещается перенос аргументов метода в стиле WIN32, т. е. когда каждый аргумент располагается на новой строке. Пример:

public void insertElements(begin,
                           end,
                           elements)

1. Запрещается размещение нескольких операторов в одной строке, кроме случаев, когда это не ухудшает удобочитаемости программы.

2. Разрешается написание одной строкой условного оператора, в теле которого содержится всего один вызов . Пример:

if (x > 0) return x;

1. Рекомендуется использование пробелов для отбивок отдельных лексем в программе. Способ расстановки пробелов в этом случае должен соответствовать полиграфическим правилам.

2. Многострочный документационный комментарий выравнивается следующим образом: первая и последняя строки содержать только символы /** и */ (или **/) соответственно. Все промежуточные строки начинаются со звёздочки, за которой следует текст комментария.

Русские Блоги

String — это неизменный класс в Java. Неизменяемый класс просто означает, что все экземпляры этого класса не могут быть изменены. Вся информация об экземпляре инициализируется при его создании и не может быть изменена. Неизменяемые классы имеют много преимуществ. В этой статье объясняется, почему String разработан так, чтобы его нельзя было изменить. Хороший ответ требует глубокого понимания памяти, синхронизации и структур данных. 1. Необходимость в пуле строк Пул строк (внутренний пул строк) — это особая область в области метода. При создании строки, если строка уже существует в памяти, возвращается ссылка на эту существующую строку вместо создания нового объекта и возврата его ссылки. Следующий код создаст строковый объект в куче.

Если строку можно изменить, изменение строки ссылкой приведет к тому, что другая ссылка укажет на неправильное значение. 2, значение хеш-функции кеша В Java часто используется хеш-значение строки. Например, в HashMap. Оставаясь неизменным, вы можете гарантировать, что всегда будет возвращаться одно и то же значение хеш-функции. Так что его можно кэшировать, не беспокоясь об изменении. Это означает, что нет необходимости вычислять хеш-значение каждый раз, когда оно используется. Это будет более эффективным. В классе String он имеет следующий код:

3. Упростите использование других классов. Чтобы быть более конкретным, рассмотрим следующую программу:

В этом примере, если String может быть изменен, если его значение изменится, это нарушит дизайн Set (Set не может содержать повторяющиеся элементы). Этот пример предназначен для упрощения дизайна, в фактическом классе String нет атрибута value.

4. Безопасность String Во многих java-классах сетевые соединения, открытые файлы часто используются в качестве параметров. Если String можно изменить, соединение или файл могут быть изменены, что вызовет серьезные угрозы безопасности. Этот метод предполагает, что он подключается к машине, но это не так. Строки переменных будут отражены или использованы в качестве параметров, что вызовет проблемы с безопасностью. Ниже приведен пример кода:

5. Неизменяемые объекты естественно потокобезопасны. Поскольку неизменяемые объекты нельзя изменить, они могут свободно совместно использоваться несколькими потоками. Это исключает синхронизацию. Таким образом, String спроектирован так, чтобы его нельзя было изменить для повышения эффективности и безопасности. Вот почему существует множество классов, которые нельзя изменить.

Соединение строк в Java

Чтобы соединить строки в Java, подойдёт операция сложения “+”:

String str1 = “Java”;String str2 = “Hi”;String str3 = str1 + ” “ + str2;System.out.println(str3); // Hi Java

Если же в предстоящей операции сложения строк будет применяться нестроковый объект, допустим, число, данный объект преобразуется к строке:

String str3 = “Год “ + 2020;

По факту, когда мы складываем строки с нестроковыми объектами, вызывается метод valueOf() класса String. Этот метод преобразует к строке почти все типы данных. Чтобы преобразовать объекты разных классов, valueOf вызывает метод toString() данных классов.

Объединять строки можно и с помощью concat():

String str1 = “Java”;String str2 = “Hi”;str2 = str2.concat(str1); // HiJava

Метод принимает строку, с которой нужно объединить вызывающую строку, возвращая нам уже соединённую строку.

Также мы можем использовать метод join(), позволяющий объединять строки с учетом разделителя. Допустим, две строки выше слились в слово “HiJava”, однако мы бы хотели разделить подстроки пробелом. Тут и пригодится join():

String str1 = “Java”;String str2 = “Hi”;String str3 = String.join(” “, str2, str1); // Hi Java

Метод join — статический. Первый параметр — это разделитель, который будет использоваться для разделения подстрок в общей строке. Последующие параметры осуществляют передачу через запятую произвольного набора объединяемых подстрок — в нашем случае их две, но можно и больше.

Цели проектирования (почему String должен быть неизменным)

В Java дизайн String как неизменяемый является результатом всестороннего рассмотрения различных факторов, таких как память, синхронизация, структура данных и безопасность. Ниже приводится сводка различных факторов.

1. Потребность в пуле постоянных времени выполнения

При выполнении приведенного выше кода JVM сначала проверяет, есть ли объект String «abc» в пуле констант времени выполнения. Если объект уже существует, ему не нужно создавать новый объект String «abc», но он указывает ссылку s непосредственно на пул констант времени выполнения. Существующий объект String «abc» в; если он не существует, сначала создайте новый объект String «abc» в пуле констант времени выполнения, а затем укажите ссылку s на новый объект String, созданный в пуле констант времени выполнения.

Когда приведенный выше код выполняется, только один объект String «abc» создается в пуле констант времени выполнения, что экономит место в памяти.Принципиальная схема выглядит следующим образом:

2. Синхронизация

Поскольку объекты String неизменяемы, они многопоточны, а один и тот же экземпляр String может использоваться несколькими потоками. Это устраняет необходимость в использовании синхронизации из-за проблем безопасности потоков.

3. Разрешить объектам String кэшировать хэш-код.

Глядя на исходный код класса String в JDK1.8 выше, вы можете обнаружить, что существует хэш поля. Неизменяемость класса String гарантирует уникальность хэш-кода, поэтому хеш-код объекта String можно кэшировать с помощью хэш-поля. Рассчитайте хэш-код. Поэтому объекты String в Java часто используются в качестве ключей контейнеров, таких как HashMap.

4. Безопасность

Если объект String является изменяемым, это вызовет серьезные проблемы с безопасностью. Например, имя пользователя и пароль базы данных передаются в виде строк для получения соединения с базой данных или при программировании сокетов имя хоста и порт передаются в виде строк. Поскольку объект String неизменяем, его значение нельзя изменить.В противном случае хакеры могут воспользоваться лазейкой и изменить значение объекта, на который указывает ссылка на String, что вызовет бреши в безопасности.

Разделите строку и Java 8

5.1 Для потока Java 8 мы можем использовать чтобы разделить строку.

package com.mkyong;

import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class SplitString5a {

    public static void main(String[] args) {

        String phone = "299-399-4999";

        List output = Pattern.compile("-")
                .splitAsStream(phone)
                .filter(x -> !x.equals("399"))
                .collect(Collectors.toList());

        output.forEach(s -> System.out.println(s));

    }

}

Выход

299
4999

5.2 Мы также можем использовать для преобразования массива в поток.

package com.mkyong;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SplitString5b {

    public static void main(String[] args) {

        String phone = "299-399-4999";

        List output = Arrays.stream(phone.split("-"))
                .filter(x -> !x.equals(399))
                .collect(Collectors.toList());

        output.forEach(s -> System.out.println(s));

    }

}

Выход

299
4999

Извлекаем символы и подстроки в Java

Чтобы извлечь символы по индексу, в классе String есть метод char charAt(int index). Этот метод принимает индекс, по которому необходимо получить символы, возвращая извлеченный символ:

String str = "Java";
char c = str.charAt(2);
System.out.println(c); // v

Обратите внимание, что индексация начинается с нуля, впрочем, как и в массивах.
Если же нужно извлечь сразу группу символов либо подстроку, подойдёт getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin). Этот метод принимает ряд параметров:
• srcBegin: индекс в нашей строке, с которого осуществляется начало извлечения символов;
• srcEnd: индекс в нашей строке, до которого осуществляется извлечение символов;
• dst: массив символов (именно в него будут эти символы извлекаться);
• dstBegin: индекс в массиве dst (с него надо добавлять символы, извлечённые из строки)

String str = "Hi world!";
int start = 6;
int end = 11;
char[] dst=new charend - start];
str.getChars(start, end, dst, );
System.out.println(dst); // world

Соглашения об именах¶

1. Имена должны быть осмысленными словами (или словосочетаниями в значении соответствующей части речи) английского языка.

2. Имена пакетов и подпакетов — существительные в единственном числе в нижнем регистре, слова разделяются подчёркиваниями ().

3. Имена классов и интерфейсов — существительные или словосочетания в значении существительных: в нижнем регистре, первые буквы слов — в верхнем регистре, разделители слов не используются (); имена классов-исключений заканчиваются на ().

4. Рекомендуется для классов-наследников использовать имена, в которых содержится имя суперкласса (); исключение — имена классов-наследников, из которых следует, что данный класс наследует суперкласс ().

5. Имена полей̆ и локальных переменных — существительные в нижнем регистре, первые буквы слов начиная со второго — в верхнем регистре, разделители слов не используются ().

6. Имена полей и локальных переменных не должны вводить в заблуждение относительно их типов. Пример (!) НЕПРАВИЛЬНОГО (!) именования переменной: String currentPlayer = player.getName();

7. Имена методов — глаголы в нижнем регистре (либо словосочетания, отражающие действия), первые буквы слов начиная со второго — в верхнем регистре, разделители слов не используются ().

8. В названии методов нужно использовать глаголы, которые как можно более точно и полно описывают то, что выполняет метод.

9. Имена методов, выполняющих чтение/изменение значений полей класса, должны начинаться на и , соответственно (, ); исключение — методы, возвращающие значения полей типа , они начинаются на is ().

10. Имена методов, выполняющих преобразование к другому типу данных, должны начинаться на ().

11. Имена методов, которые создают и возвращают созданный объект, должны начинаться с ().

12. Имена методов, инициализирующие поля класса или элементы графического интерфейса, должны начинаться с () и использоваться только в конструкторе класса. Таких методов следует избегать.

13. Имена переменных — существительные или словосочетания в верхнем регистре, слова разделены подчёркиваниями ().