Почему разработчики Java не создали статические версии методов манипуляции со строками в java.lang.String
классе? Следующие методы - это то, к чему я обращаюсь, но вопрос можно распространить и на другие нестатические методы в классе.
concat(String) substring(int, int)
replace(char, char) toLowerCase()
replace(CharSequence, CharSequence) toLowerCase(Locale)
replaceAll(String, String) toString()
replaceFirst(String, String) toUpperCase()
split(String) toUpperCase(Locale)
split(String, int) trim()
substring(int)
Наличие только нестатических версий этих методов вызывает явную проверку нуля везде, где должен вызываться такой метод. Например, простой вызов example = example.trim()
приведет к NullPointerException, если String example = null
. Таким образом, программист должен выполнить следующую проверку нуля:
if (example != null)
example = example.trim();
// OR:
example = (example==null) ? null : example.trim();
example = (example==null) ? null : example.substring(5);
Я полагаю, что было бы намного удобнее, если бы String
имелись статические версии этих методов (возможно, даже исключительно ), которые бы принимали входную строку в качестве первого аргумента:
example = String.trim(example);
example = String.replace(example, 'a', 'b');
example = String.substring(example, 5);
Это привело бы к более чистому коду, написанному программистами, который автоматически позаботился бы о нулевых случаях, просто возвращая ноль, вместо того, чтобы заставлять программистов явно обрабатывать нулевые случаи. Возвращение нуля имеет смысл для меня , так как манипулирования нулевой строки должна привести к нулевой строке, а не об ошибке.
Почему разработчики Java не думали об этом, когда разрабатывали String
класс в Java 1 или Java 2, или даже не добавляли такую функциональность в более позднюю версию Java?
источник
null
является исключительным состоянием и должно обрабатываться явно.Maybe<T>
Думаю , это плохая переопределение типа?string name = employee?.personalData?.name
, Просто как ярлык для всех этих повторяющихсяif (employee != null)
с. Соответствующий вопрос SO: stackoverflow.com/questions/1196031/…Ответы:
Ну, это ваше мнение. Другие могут утверждать, что операции String над нулевым объектом, который не содержит String, не имеют смысла и, следовательно, должны выдавать исключение
Почему «дизайнеры Java» сделали или не сделали что-то, трудно ответить.
Уже есть библиотеки, которые могут выполнять операции String с нулевой безопасностью, например StringUtils из Apache Commons. Вы можете использовать эту или аналогичные библиотеки, если они вам нужны.
Дополнение на основе ваших комментариев
Читая комментарии, кажется, что реальная проблема, с которой вы сталкиваетесь, заключается в том, что вы должны проверять
null
весь код. Это может быть индикатором плохого дизайна программы без четко определенных контрактов между интерфейсами. Возможно, вы захотите прочитать Избегание «! = Null» операторов в Java?источник
Optional
- code.google.com/p/guava-libraries/wiki/…ИМО весь подход "если аргумент равен нулю, возвращает ноль" к написанию методов без необходимости увеличивает цикломатическую сложность вашей программы.
Ранние Java-библиотеки использовали метод return null, но ребята из JDK всегда защищали от null с исключениями.
Со временем я думаю, что последний подход стал явным победителем.
Почему? Так как нулевые поля нарушают многие принципы. Вы просто не можете относиться к ним как к членам полиморфного класса. Это означает, что вы всегда должны кодировать особые случаи для нуля, и, следовательно, ваша цикломатическая сложность возрастает, когда вы должны предположить, что вещи могут быть нулевыми.
Чтобы решить ваши проблемы, рассмотрите возможность использования шаблона нулевого объекта вместо использования пустых полей.
источник
String
разве не полиморфно, нет? И как вы используете шаблон нулевого объекта для уже существующего типа, такого как String?int
умолчанию равно нулю, а неnull
. Концептуально должно быть возможно иметьstring
тип, значением по умолчанию которого будет пустая строка, а неnull
[такой тип может быть семантически относящимся кString
тому, чтоint
нужноInteger
]. Тот факт, что непустоеstring
будет внутренне содержать ссылку на объект кучи, будет деталью реализации; нет причины, по которой он не мог бы вести себя семантически как примитив.Не говоря уж об этом, но за исключением toString, все эти методы легко инкапсулируются в статический вспомогательный класс, тогда как обратное неверно.
Т.е. если вы хотите Stings.toUpper (строковый ввод), то код для этого легко написать, но если вы хотите instance.toUpper и все, что у вас есть, это String.toUpper, ну, это невозможно ... если они не вводят методы расширения, который, скорее всего, даже не рассматривался в то время.
источник
String.format
(статический), но вы не можете сделать"something %s".format(id)
.В Java эта строка является объектом. Это выбор дизайна.
Ссылки на объекты могут быть нулевыми и равными нулю, если для него не назначен объект. Если вы вызываете такой объект, генерируется исключение NullPointerException. Это стандартное поведение.
Java-дизайнеры сделали выбор иметь строки в качестве объекта, а те методы, которые генерируют исключения с нулевым указателем, - это то, что вы получите, если хотите, чтобы строки были объектами.
Они, наверное, думали об этом и решили включить в себя oo-поведение.
источник
String.format
, (То же самое в C #, кстати). Так что, если это выбор дизайна, он не может исходить исключительно из того факта, что строки являются объектами, и он не применяется последовательно.Strings
служебном классе, как, например, у нас естьArrays
служебный класс ( хотя я понимаю, что он был создан из-за чистой необходимости из-за того, что массивы представляют собой некое странное сочетание между примитивами и объектами: ) ) .. пока он был частью стандартной Java и не требовал зависимостей.