lambeta-underscore.string.java: String manipulation operations in java

Библиотека для работы со строками в Java

Последняя версия

0.2.0

Подробнее в Release Notes

Введение в блоге здесь

Синхронизация с репозиторием Gitee

Необходимые условия

Java >= 1.6
Guava 18.0

Установка

Gradle

repositories {
    mavenCentral()
}

dependencies {
    compile 'com.lambeta:underscore.string.java:0.2.0'
}

Maven

<dependency>
    <groupId>com.lambeta</groupId>
    <artifactId>underscore.string.java</artifactId>
    <version>0.2.0</version>
</dependency>

API

capitalize

Преобразует первую букву строки в верхний регистр.

import static com.lambeta.UnderscoreString.capitalize;

capitalize(" hello ");
// -> "Hello"

decapitalize

Преобразует первую букву строки в нижний регистр.

import static com.lambeta.UnderscoreString.decapitalize;

decapitalize(" Hello ");
// -> "hello"
decapitalize("HELLO");
// -> "hELLO"

slugify

Преобразование текста в ASCII-слаг, который можно безопасно использовать в URL-адресах. Заменяет пробелы, акцентированные и специальные символы на дефис. Ограниченный набор не-ASCII символов преобразуется в аналогичные версии в наборе символов ASCII, например ä в a.

import static com.lambeta.UnderscoreString.slugify;

slugify(" hello World!");
// -> "hello-world"
slugify("Un éléphant àß l\'orée du bois");
// -> "un-elephant-ass-l-oree-du-bois"

count

Возвращает количество вхождений подстроки в строку.

import static com.lambeta.UnderscoreString.count;

count("Hello world", "l");
// -> 3

trim

Обрезает определённые символы с начала и конца строки. По умолчанию это пробельные символы.

import static com.lambeta.UnderscoreString.trim;

trim(" foo ");
// -> "foo"
trim("foo", "f");
// -> "oo"

ltrim

Левый обрез. Аналогично trim, но только для левой стороны.

import static com.lambeta.UnderscoreString.ltrim;

ltrim(" foo");
// -> "foo"
ltrim("foof", "f");
// -> "oof"

rtrim

Правый обрез. Аналогично trim, но только для правой стороны.

import static com.lambeta.UnderscoreString.rtrim;

rtrim("foo ");
// -> "foo"
rtrim("foof", "f");
// -> "foo"

repeat

Повторяет строку count раз.

import static com.lambeta.UnderscoreString.repeat;

repeat("foo");
// -> ""
repeat("foo", 3);
// -> "foofoofoo"
repeat("foo", 3, 3);
// -> "foo3foo3foo"
repeat("foo", 3, new Person("ryan", "male"));
// -> "fooPerson{name=ryan, gender=male}fooPerson{name=ryan, gender=male}foo"

join

Объединяет строки вместе с заданным разделителем.

import static com.lambeta.UnderscoreString.join;

join("", "foo", "bar");
// -> "foobar"
join("", null, "bar")
// -> "bar"

reverse

Возвращает обратную строку.

import static com.lambeta.UnderscoreString.reverse;

reverse("foo");
// -> "oof"

clean

Обрезка и замена нескольких пробелов одним пробелом.

import static com.lambeta.UnderscoreString.clean;

clean(" foo    bar   ");
// -> "foo bar"

chop

Разбивает данную строку на части.

import static com.lambeta.UnderscoreString.chop;

chop("whitespace", 2);
// -> ["wh", "it", "es", "pa", "ce"]

splice

Как сращивание массива. splice(start, deleteCount, item).

import static com.lambeta.UnderscoreString.splice;

splice("whitespace", 5, 5, "shift");
// -> "whiteshift"

pred

Возвращает предшественника строки.

import static com.lambeta.UnderscoreString.pred;

pred('2');
// -> '1'

succ

Возвращает преемника строки.

import static com.lambeta.UnderscoreString.succ;

succ('a');
// -> 'b'

titleize

Делает заглавной каждую букву данной строки, как в заголовке.

import static
``` **camelize**

Преобразует строку с символами подчёркивания или тире в строку, записанную по правилам «верблюжьего регистра». Начинается со строчной буквы, если перед ней не стоит символ подчёркивания, дефиса или прописной буквы.

```java
import static com.lambeta.UnderscoreString.camelize;

camelize("the_camelize_string_method");
// -> "TheCamelizeStringMethod"
camelize("_webkit   _  transform ");
// -> "WebkitTransform"

dasherize

Преобразует строку с символами подчёркивания или записанную по правилам «верблюжьего регистра» в строку с дефисами.

import static com.lambeta.UnderscoreString.dasherize;

dasherize("the_dasherize_string_method");
// -> "the-dasherize-string-method"

underscored

Преобразует строку, записанную по правилам «верблюжьего регистра», или строку с дефисами в строку с символами подчёркивания.

import static com.lambeta.UnderscoreString.underscored;

underscored("the-underscored-string-method");
// -> "the_underscored_string_method"

classify

Преобразует строку в название класса, записанное по правилам «верблюжьего регистра». Первая буква всегда прописная.

import static com.lambeta.UnderscoreString.classify;

classify("some_class_name");
// -> "SomeClassName"

humanize

Преобразует строку с символами подчёркивания, записанную по правилам «верблюжьего регистра», или с дефисом в удобочитаемую строку.

import static com.lambeta.UnderscoreString.humanize;

humanize("the humanize string method");
// -> "The humanize string method"
humanize("the humanize_id string method");
// -> "The humanize id string method"

surround

Заключает строку в другую строку.

import static com.lambeta.UnderscoreString.surround;

surround("foo", "|");
// -> "|foo|"

quote

Кавычит строку. По умолчанию символ кавычки — ".

import static com.lambeta.UnderscoreString.quote;

quote("foo");
// -> "\"foo\""

unquote

Раскрывает строку. По умолчанию символ кавычки — ".

import static com.lambeta.UnderscoreString.unquote;

unquote("\"foo\"");
// -> "foo"
unquote('\''foo\'', '\'');
// -> "foo"

numberFormat

Форматирует числа.

import static com.lambeta.UnderscoreString.numberFormat;

numberFormat(9000);
// -> "9,000"

strRight

Ищет строку слева направо по заданному шаблону и возвращает подстроку, состоящую из символов строки справа от шаблона, или всю строку, если совпадение не найдено.

import static com.lambeta.UnderscoreString.strRight;

strRight("This_is_a_test_string", "_");
// -> "is_a_test_string"

strRightBack

Ищет строку справа налево по заданному шаблону и возвращает подстроку, состоящую из символов строки справа от шаблона, или всю строку, если совпадение не найдено.

import static com.lambeta.UnderscoreString.strRightBack;

strRightBack("This_is_a_test_string", "_");
// -> "string"

strLeft

Ищет строку слева направо по заданному шаблону и возвращает подстроку, состоящую из символов строки слева от шаблона, или всю строку, если совпадение не найдено.

import static com.lambeta.UnderscoreString.strLeft;

strLeft("This_is_a_test_string", "_");
// -> "This"

strLeftBack

Ищет строку справа налево по заданному шаблону и возвращает подстроку, состоящую из символов строки слева от шаблона, или всю строку, если совпадение не найдено.

import static com.lambeta.UnderscoreString.strLeftBack;

strLeftBack("This_is_a_test_string", "_");
// -> "This_is_a_test"

toSentence

Объединяет массив в удобочитаемое предложение.

import static com.lambeta.UnderscoreString.toSentence;

String[] words = new String[] {"Hello", "Welcome"};
toSentence(words);
// -> "Hello and Welcome"

truncate

Усекает заданную строку до заданной длины.

import static com.lambeta.UnderscoreString.truncate;

truncate("Hello World", 5, "...");
// -> "Hello..."

lpad

Лево дополняет строку.

import static com.lambeta.UnderscoreString.lpad;

lpad("Hello", 8);
// -> "   Hello"

rpad

Право дополняет строку.

import static com.lambeta.UnderscoreString.rpad;

rpad("Hello", 8);
// -> ("Hello   ")

lrpad

Лево/право дополняет строку. ### words Разделяет строку по разделителю.

import static com.lambeta.Underscorestring.words;

words("I_love_you!");
// -> ["I", "love", "you!"]

prune

Элегантная версия усечения. Гарантирует, что обрезанная строка не превышает исходную длину. Избегает наполовину обрезанных слов при усечении.

import static com.lambeta.Underscorestring.prune;

prune("Hello, cruel world", 15);
// -> "Hello, cruel..."

isBlank

Определяет, является ли данная строка пустой или нет.

import static com.lambeta.Underscorestring.isBlank;

isBlank("");
// -> true
isBlank(null);
// -> true
isBlank("\n");
// -> true

replaceAll

Заменяет все find str в данной строке на replacement, если данная строка равна нулю или пуста, то возвращает пустую строку. Последний аргумент true означает игнорирование регистра.

import static com.lambeta.Underscorestring.replaceAll;

replaceAll("aca", "a", "b");
// -> "bcb"
replaceAll("Aa", "a", "b", true);
// -> "bb"
replaceAll("", "a", "b);
// -> ""

swapCase

Возвращает копию строки, в которой все символы на основе регистра поменяли свой регистр.

import static com.lambeta.Underscorestring.swapCase;

swapCase("Hello World");
// -> "hELLO wORLD"
swapCase("ß");
// -> "SS"

naturalCmp

Естественная сортировка строк, как это сделали бы люди. Числа сравниваются по их ASCII-значениям. Обратите внимание: это означает, что «a» > «A». Используйте .toLowerCase, если это нежелательно.

import static com.lambeta.Underscorestring.naturalCmp;

naturalCmp("abc", "123");
// -> 1
naturalCmp("15a123", "15a122");
// -> 1
naturalCmp("r9", "r69");
// -> -1

dedent

Убирает ненужный отступ.

import static com.lambeta.Underscorestring.dedent;

dedent("    Hello\n  World");
// -> "  Hello\nWorld"
dedent("\t\tHello\tWorld");
// -> "Hello\tWorld"
dedent("\t\tHello\n\t\tWorld");
// -> "Hello\nWorld"

commonPrefix

Возвращает самый длинный общий префикс s и s1. Если ignoreCase равно true, вернёт общий суффикс s1.

import static com.lambeta.Underscorestring.commonPrefix;

commonPrefix("123456", "123o8yuidfg");
// -> "123"
commonPrefix("Hello", "helloo", true);
// -> "hello"

commonSuffix

Возвращает самый длинный общий суффикс s и s1. Если ignoreCase равно true, вернёт общий суффикс s1.

import static comcom.lambeta.Underscorestring.commonSuffix;

commonSuffix("456123", "1414123");
// -> "123"
commonSuffix("hello", "hellO", true);
// -> "hellO"

chopPrefix

Удаляет префикс с начала s. В противном случае возвращает s.

import static com.lambeta.Underscorestring.chopPrefix;

chopPrefix("foo", "FOO")
// -> "foo"
chopPrefix("foo", "FOO", true);
// -> ""

chopSuffix

Удаляет суффикс с конца s. В противном случае возвращает s.

import static com.lambeta.Underscorestring.chopSuffix;

chopSuffix("foo", "FOO");
// -> "foo"
chopSuffix("foo", "FOO", true);
// -> ""

screamingUnderscored

Преобразует s в верхний регистр и использует подчеркивания для разделения слов.

import static com.lambeta.Underscorestring.screamingUnderscored;

screamingUnderscored("The-Underscored_String_-Method");
// -> "THE_UNDERSCORED_STRING_METHOD"
screamingUnderscored("HTTPRequest");
// -> "HTTP_REQUEST"
screamingUnderscored("setID");
// -> "SET_ID"

stripAccents

Удаляет все акценты (диакритические знаки) из s.

import static com.lambeta.Underscorestring.stripAccents;

stripAccents("Et ça sera sa moitié");
// -> "Et ca sera sa moitie"

pascalize

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

import static com.lambeta.Underscorestring.pascalize;

pascalize("PascalCase");
// -> "PascalCase"

translate

Переводит все символы в s согласно сопоставлениям, найденным в tmap (второй аргумент).

Любые символы, найденные в наборе delete-chars (третий аргумент), будут удалены перед обращением к tmap.

Также будут удалены любые символы, сопоставленные с null в tmap.

import static com.lambeta.Underscorestring.translate;

translate("ababa", new ### HashMap
HashMap<Character, Character>(){{put('a', 'b');}});  
// -> "bbbbb"  

translate("ababa", new HashMap<Character, Character>(){{put('a', 'b');}}, new HashSet<Character>(){{add('b');}});  
// -> "bbb"

### mixedCase
Return `Optional<String> s` если s содержит как заглавные, так и строчные буквы.  
```java  
import static com.lambeta.Underscorestring.mixedCase;  

mixedCase("1AB");  
// -> Optional.<String>absent();  
mixedCase("FooBar");  
// -> Optional.<String>of("FooBar")

collapseWhitespaces

Преобразует все соседние пробелы в строке s в один пробел.

import static com.lambeta.Underscorestring.collapseWhitespaces;  

collapseWhitespaces("foo    bar    baz");  
// -> "foo bar baz"

ascii

Возвращает Optional<String> s, если s содержит только символы ASCII.

import static com.lambeta.Underscorestring.ascii;  

ascii("ascii");  
// -> Optional<String>.of("ascii")  
ascii("Et ça sera sa moitié");  
// -> Optional<String>.absent()

chomp

Возвращает новую строку с удаленными символами \r\n, \n или \r в конце.

import static com.lambeta.Underscorestring.chomp;  

chomp("foo\n");  
// -> "foo"  
chomp("foo\n\r");  
// -> "foo\n"

startsWith

Возвращает true, если строка s начинается с префикса. Если третий аргумент указан как true, сравнение строк нечувствительно к регистру.

import static com.lambeta.Underscorestring.startsWith;  

startsWith("foo", "foo");  
// -> true  
startsWith("foo", "foobar");  
// -> false  
startsWith("Foo", "foo", true);  
// -> true

endsWith

Возвращает true, если строка s заканчивается суффиксом. Если третий аргумент указан как true, сравнение строк нечувствительно к регистру.

import static com.lambeta.Underscorestring.endsWith;  

endsWith("foobar", "bar");  
// -> true  
endsWith("fooBar", "bar");  
// -> false  
endsWith("fooBar", "bar", true);  
// -> true

levenshtein

Получает расстояние редактирования между s1 и s2.

import static com.lambeta.Underscorestring.levenshtein;  

levenshtein("Godfather", "Godfather");  
// -> 0  
levenshtein("Godfather", "Gdfthr");  
// -> 3  
levenshtein("因為我是中國人所以我會說中文", "因為我是英國人所以我會說英文");  
// -> 2  
levenshtein("lol", null);  
// -> 3  
levenshtein(null, "lol");  
// -> 3

hamming

Получает расстояние Хэмминга между s1 и s2.
См. расстояние Хэмминга.

import static com.lambeta.Underscorestring.hamming;  

hamming("karolin", "kerstin");  
// -> 3

longestCommonSubstring

Возвращает набор самых длинных общих подстрок в s1 и s2. Эта реализация использует динамическое программирование, а не обобщенное дерево суффиксов, поэтому время выполнения составляет O(nm).

import static com.lambeta.Underscorestring.longestCommonSubstring;  

longestCommonSubstring("fooquxbar", "foobar");  
// -> {"foo", "bar"}

Новые функции в 0.2.1-SNAPSHOT

gradle

repositories {  
    maven {  
        url 'https://oss.sonatype.org/content/groups/public'  
    }  
}  

dependencies {  
    compile ("com.lambeta:underscore.string.java:0.2.1-SNAPSHOT")  
}

maven

<repositories>  
    <repository>  
      <id>my-repo</id>  
      <name>sonatype</name>  
      <url>https://oss.sonatype.org/content/groups/public</url>  
    </repository>  
</repositories>  

<dependency>  
    <groupId>com.lambeta</groupId>  
    <artifactId>underscore.string.java</artifactId>  
    <version>0.2.1-SNAPSHOT</version>  
</dependency>

replaceZeroWidthDelimiterWith

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

import static com.lambeta.Underscorestring.replaceZeroWidthDelimiterWith;  

replaceZeroWidthDelimiterWith("GL11Version", " ");  
// -> "GL 11 Version"  
replaceZeroWidthDelimiterWith("SimpleXMLParser", " ");  
// -> "Simple XML Parser"