1. regex (регулярное выражение): RegularExpressions (замена StringTokenizer); мощный инструмент для обработки строк, популярный в Unix; Perl еще лучше использует регулярные выражения.
В основном используется для сопоставления строк, поиска и замены. Например: сопоставление IP-адресов (диапазон менее 256) легко использовать с регулярными выражениями; извлечение большого количества адресов электронной почты с веб-страниц для рассылки спама; извлечение ссылок с веб-страниц. Содержит Matcher (результат сопоставления строки с шаблоном) и шаблон.
Скопируйте код кода следующим образом:
/*
* Сообщает, соответствует ли эта строка заданному регулярному выражению (также строке).
*/
System.out.println("abc".matches("..."));//Каждый "." представляет символ
Скопируйте код кода следующим образом:
/*
* Замените все числа в строке на «-». Обычный метод требует, чтобы charAt оценивался один за другим;
* "//d" представляет любое число или заменяет его на "[0-9]";
* «//D» представляет любую нецифру или заменяется на «[^0-9]»
*/
System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//Каждый "."
два,
Скопируйте код кода следующим образом:
/*
* compile компилирует заданное регулярное выражение в шаблон (каждая компиляция занимает время, {3} означает ровно три раза);
* X{n} X, ровно n раз
* X{n,} X, не менее n раз
* X{n,m} X, не менее n раз, но не более m раз
*/
Шаблон p = Pattern.compile("[az]{3}");
Matcher m = p.matcher("ggs");//Создаем сопоставитель, который соответствует заданному вводу с этим шаблоном. Внутренне фактически создается автомат приоритетного состояния (принцип компиляции)
//Строка, которая должна быть сопоставлена в средстве сопоставления и сопоставления, на самом деле является CharSequence (интерфейсом), но String реализует этот интерфейс и имеет полиморфизм
System.out.println(m.matches());//Если это «ggss», оно не будет соответствовать
//Вы всегда можете напрямую использовать "ggs".matches("[az]{3}"), но у приведенного выше варианта есть преимущества, по крайней мере, он более эффективен, а Pattern и Matcher предоставляют множество функций
3. Вызов метасимвола в регулярном выражении ". * +"; ctrl + Shift + "/" означает комментарий, замените его на "/", чтобы удалить комментарий.
Скопируйте код кода следующим образом:
"a".matches(".");//true, "." представляет любой символ, включая китайские иероглифы
"aa".matches("aa");//правда, то есть обычные строки также можно использовать в качестве регулярных выражений
/*
* true, «*» означает 0 или более символов, но следующие символы должны совпадать с первыми.
* В противном случае оно считается ложным, то есть оценивается, является ли строка строкой, состоящей из отдельных символов.
*/
"аааа".matches("a*");
"".matches("a*");//true
"aaa".matches("a?");//истина, один раз или 0 раз
"".matches("a?");//true
"a".matches("a?");//истина
"544848154564113".matches("//d{3,100}");//true
//Это простейшее решение IP, но если оно превышает 255, его нельзя оценивать.
"192.168.0.aaa".matches("//d{1,3}//.//d{1,3}//.//d{1,3}//d{1,3}" );
"192".matches("[0-2][0-9][0-9]");
4. [abc] означает соответствие любому символу; [^abc] означает символ, отличный от abc (все равно должна быть буква, и будет возвращено значение false, если это пустая строка), эквивалентная [a-zA-Z]; «[az ]|[AZ]» — определенная прописная или строчная буква. [AZ&&[ABS]] означает любую из прописных букв и ABS.
Скопируйте код кода следующим образом:
//Я обнаружил, что нет разницы между | и ||, но есть разница между & и &&, я не знаю, правильно ли это понимать.
System.out.println("C".matches("[AZ&&[ABS]]"));//false
System.out.println("C".matches("[AZ&[ABS]]"));//true
System.out.println("A".matches("[AZ&&[ABS]]"));//true
System.out.println("A".matches("[AZ&[ABS]]"));//true
System.out.println("C".matches("[AZ|[ABS]]"));//true
System.out.println("C".matches("[AZ||[ABS]]"));//true
5. /w символы слова: [a-zA-Z_0-9] при совпадении имен пользователей; /s пустые символы: [ /t/n/x0B/f/r] /S непустые символы: [^/s]; ] ;/W символы, не являющиеся словами: [^/w].
Скопируйте код кода следующим образом:
" /n/t/r".matches("//s{4}");//true
" ".matches("//S");//false
"a_8".matches("//w{3}");//true
//"+" означает один или несколько раз
"abc888&^%".matches("[az]{1,3}//d+[&^#%]+");//true
/*
* Сопоставляемый символ — это просто обратная косая черта, но его нельзя записать как «/», а затем объединить со следующим «,
* Предыдущее «невозможно совпадение» приведет к CE.
* не может следовать "//", иначе произойдет ошибка во время выполнения (нет проблем при компиляции), его необходимо записать как "////"
*/
System.out.println("//".matches("////"));//true
6. Класс символов POSIX (только US-ASCII)
Скопируйте код кода следующим образом:
/p{Lower} Алфавитные символы нижнего регистра: [az] ;/p{Upper} Алфавитные символы верхнего регистра: [AZ] ;/p{ASCII} Все ASCII: [/x00-/x7F] ;/p{Alpha} Алфавитные символы: [/p{Lower}/p{Upper}] ;/p{Digit} Десятичное число: [0–9].
7. Сопоставление границ
^ Начало строки $ Конец строки/b Граница слова/B Граница без слова/A Начало ввода/G Конец предыдущего совпадения/Z Конец ввода, используется только для последнего ограничителя (если есть)
/z конец ввода
Скопируйте код кода следующим образом:
"hello world".matches("^h.*");//Начало строки ^
"hello world".matches(".*ld$");//Конец $строки
"hello world".matches("^h[az]{1,3}o//b.*");///bword border
"helloworld".matches("^h[az]{1,3}o//b.*");
" /n".matches("^[//s&&[^//n]]*//n$");//Оцениваем пустые строки, которые начинаются с пустого символа
8. Вы также можете использовать m.start() и m.end() в методе find, чтобы вернуть следующий между начальной и конечной позицией, если его невозможно найти, произойдет ошибка;
Скопируйте код кода следующим образом:
Шаблон p = Pattern.compile("//d{3,5}");
Строка s = "133-34444-333-00";
Сопоставитель m = p.сопоставитель(и);
m.matches();//соответствует всем строкам
м.сброс();
/*
* Если метод сброса вызывается первым ниже, будет выведено true, true, true, false.
* В противном случае предпоследняя находка также выдаст false.
*Причины следующие:
* соответствует первому "-" и обнаруживает, что оно не соответствует, но эти четыре символа были съедены. Сопоставление снова начнется с.
* Начинается 34444, а второй поиск начинается с 333, поскольку поиск соответствует следующей подпоследовательности.
* Метод сброса позволяет совпадениям выбрасывать строку, съеденную совпадениями.
* Вкратце: между совпадениями и поиском необходимо использовать сброс, поскольку они влияют друг на друга.
*
*/
м.найти();
м.найти();
m.find();//Попробуем найти следующую подпоследовательность входной последовательности, соответствующую этому шаблону
м.найти();
/*
* Пытается сопоставить входную последовательность, начинающуюся с начала региона, с этим шаблоном.
* Автор книги Thinking in Java резко раскритиковал этот метод, поскольку из слов непонятно, с чего начать сопоставление.
* Все нижеследующее верно, потому что они каждый раз начинают с нуля.
*/
м.смотрю();
м.смотрю();
м.смотрю();
м.смотрю();
9. Замена струны
Скопируйте код кода следующим образом:
импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;
общественный класс TestRegexReplacement {
public static void main(String[] args) {
Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//Следующий параметр является целым числом, что означает "регистронезависимость"
Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
в то время как (m.find()) {
System.out.println(m.group());//m.group выведет всю Java (игнорируя регистр)
}
String s = m.replaceAll("Java");//String также имеет этот метод
System.out.println(s);
m.reset();//необходимо добавить, поскольку поиск и сопоставление влияют друг на друга
StringBuffer sb = новый StringBuffer();
интервал я = 0;
/*
* Следующий метод заключается в замене нечетного числа найденных Java на «Java», а четного числа на «Java».
*/
в то время как (m.find()) {
я++;
// Его нельзя записать напрямую как i&1, его необходимо преобразовать в логическое значение
если((я&1)==1) {
m.appendReplacement(sb, "Java");
}еще {
m.appendReplacement(sb, "java");
}
}
m.appendTail(sb);//Добавляем оставшуюся строку после последней найденной Java
System.out.println(sb);//Без сброса выводится только Acmer
}
}
10. Группировка
Скопируйте код кода следующим образом:
/*
* Добавьте круглые скобки соответственно, не считая крайней скобки, первая левая скобка — это первая группа.
*/
Шаблон p = Pattern.compile("(//d{3,5})([az]{2})");
Строка s = "123aaa-77878bb-646dd-00";
Сопоставитель m = p.сопоставитель(и);
в то время как (m.find()) {
System.out.println(m.group());
System.out.println(m.group(1));//Выводим каждую пару совпадающих чисел
System.out.println(m.group(2));//Выводим каждую пару совпадающих букв
}
11. Захватывайте электронные письма с веб-страниц
Скопируйте код кода следующим образом:
импортировать java.io.BufferedReader;
импортировать java.io.FileNotFoundException;
импортировать java.io.FileReader;
импортировать java.io.IOException;
импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;
/*
* Если вам нужен какой-либо метод повышения, сначала укажите имя метода.
* Затем ctrl+1 выводит список рекомендаций и система создает этот метод
*/
общественный класс EmailSpider {
public static void main(String[] args) {
// TODO Автоматически сгенерированная заглушка метода
пытаться {
BufferedReader br = новый BufferedReader(новый FileReader("F://regex.html"));
Строковая линия = "";
пытаться {
while((line=br.readLine())!=null) {
решить (линия);
}
} catch (IOException e) {
// TODO Автоматически сгенерированный блок catch
е.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Автоматически сгенерированный блок catch
е.printStackTrace();
}
}
Private static voidsolve (строковая строка) {
// TODO Автоматически сгенерированная заглушка метода
//Если регулярное выражение не соответствует соответствующей функции, оно не выдаст ошибку, поскольку оно является строкой.
Pattern p = Pattern.compile("[//w[.-]]+@[//w[.-]]+//.[//w]+");
Matcher m = p.matcher(line);
в то время как (m.find()) {
System.out.println(m.group());
}
}
}
12. Статистика кода
Скопируйте код кода следующим образом:
Посмотреть код
/*
* Подсчитайте количество пустых строк, строк комментариев и строк программы в коде.
* На самом деле, вы также можете использовать в строке значения BeginsWith и EndsWith.
* При использовании менеджером проекта также необходимо посчитать, заканчивается ли количество символов в каждой строке на {, чтобы не было лени;
*/
импортировать java.io.BufferedReader;
импортировать java.io.File;
импортировать java.io.FileNotFoundException;
импортировать java.io.FileReader;
импортировать java.io.IOException;
общественный класс CoderCount {
статические длинные нормальные линии = 0;
статические длинные commentLines = 0;
статические длинные белые линии = 0;
public static void main(String[] args) {
Файл f = новый файл("D://share//src");
File[] codeFiles = f.listFiles();
for(Дочерний файл: codeFiles){
if(child.getName().matches(".*//.java$")) {
решить (ребенок);
}
}
System.out.println("normalLines:" +normalLines);
System.out.println("commentLines:" + commentLines);
System.out.println("whiteLines:" + whiteLines);
}
Private static voidsolve (Файл f) {
BufferedReader br = ноль;
логический комментарий = ложь;
пытаться {
br = новый BufferedReader (новый FileReader (f));
Строковая линия = "";
while((line = br.readLine()) != null) {
/*
* //Перед некоторыми строками комментариев есть табуляция
* нельзя записать после readLine
* Последняя строка будет нулевым указателем
*/
линия = линия.обрезка();
//readLine удаляет новую строку после чтения строки.
if(line.matches("^[//s&&[^//n]]*$")) {
белые линии++;
} else if (line.startsWith("/*") && !line.endsWith("*/")) {
Комментарий++;
комментарий = правда;
} else if (line.startsWith("/*") && line.endsWith("*/")) {
Комментарий++;
} else if (true == комментарий) {
Комментарий++;
if(line.endsWith("*/")) {
комментарий = ложь;
}
} else if (line.startsWith("//")) {
Комментарий++;
} еще {
нормальные линии++;
}
}
} catch (FileNotFoundException e) {
е.printStackTrace();
} catch (IOException e) {
е.printStackTrace();
} окончательно {
если (бр != ноль) {
пытаться {
бр.закрыть();
бр = ноль;
} catch (IOException e) {
е.printStackTrace();
}
}
}
}
}
13. Кванторы
включать? *+; По умолчанию — Жадный, а также Неохотный и Притяжательный (эксклюзивный).
Скопируйте код кода следующим образом:
//Группировка добавлена, чтобы ее было более наглядно видно.
Шаблон p = Pattern.compile("(.{3,10})+[0-9]");
String s = "aaaa5bbbb6";//Длина равна 10
Сопоставитель m = p.сопоставитель(и);
/*
* Теперь выведите 0-10, по умолчанию — жадный, сначала проглотите 10 символов, обнаружите, что они не совпадают, выплюнете один и обнаружите, что они совпадают;
* Если Pattern.compile("(.{3,10}?)+[0-9]") становится Reluctant, то сначала он проглотит три символа, найдет несоответствие, продолжит поглощать, пока не совпадет, и выведет 0 до 5;
* Если Pattern.compile("(.{3,10}++)+[0-9]") имеет Possessive (исключительный), он также сначала проглатывает 10 символов, но не выплевывает их, тогда он не будет сопоставлен ,
* Этот метод в основном используется там, где требуется высокая эффективность (будут ошибки).
*/
если (m.find()) {
System.out.println(m.start() + "----" + m.end());
}еще {
System.put.println("Не совпадает!");
}
14. Дополнение (незахватывающая группа)
Скопируйте код кода следующим образом:
//Значение группы без захвата противоположно буквальному значению, что означает захват, если оно соответствует
Шаблон p = Pattern.compile("(?=a).{3}");
/*
* Вывод a66, что эквивалентно требованию начинать с a. Вы также можете написать Pattern.compile("[a].{2}");
* Если Pattern.compile(".{3}(?!=a)") не заканчивается на {2}[^a], но следующий символ не a (просмотр вперед), будут выведены 44a, 66b, так что это использование обычно не используется;
* Если это Pattern.compile(".{3}(?=a)"), он выведет 444 (поскольку ?=a — это просмотр вперед). Если он помещен впереди, он будет включен в группу. , а если его разместить сзади, то он не будет включен в группу;
*
*
*/
Строка s = "444a66b";
Сопоставитель m = p.сопоставитель(и);
в то время как (m.find()) {
System.out.println(m.group());
}
15. Обратная ссылка
Скопируйте код кода следующим образом:
Шаблон p = Pattern.compile("(//d//d)//1");
/*
* Вывод true, //1 означает то же, что и первая группа, будет неправильно, если ее изменить на 1213;
* Если это Pattern.compile("(//d(//d))//2"), его необходимо изменить на 122.
*
*/
Строка с = "1212";
Сопоставитель m = p.сопоставитель(и);
System.out.println(m.matches());
16. Аббревиатура флагов
"." не соответствует символу новой строки, просто помните CASE_INSENSITIVE, сокращение "сопоставление без учета регистра также может быть включено с помощью встроенного выражения флага (?i)".
