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

Я столкнулся с аналогичной проблемой и немного изменил решения, представленные здесь, и пришел к этому решению, которое также работает, но (imo) немного проще понять и расширить:

/^([a-zäöüß\s\d.,-]+?)\s*([\d\s]+(?:\s?[-|+/]\s?\d+)?\s*[a-z]?)?\s*(\d{5})\s*(.+)?$/i

Вот несколько примеров совпадений.

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

[a-zäöüß\s\d,.-]+?                         # Street name (lazy)
[\d\s]+(?:\s?[-|+/]\s?\d+)?\s*[a-z]?)?     # Street number (optional)

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

Я бы начал с обратной стороны, поскольку, насколько мне известно, название города не может содержать чисел (но может содержать пробелы (первый пример, который я нашел: «Weil der Stadt"). Затем пятизначное число перед ним должно быть почтовым индексом.

Номер (возможно, за которым следует одна буква) перед ним - это номер улицы. Обратите внимание, что это также может быть диапазон. Все, что перед этим, - это название улицы.

В любом случае, поехали:

^((?:\p{L}| |\d|\.|-)+?) (\d+(?: ?- ?\d+)? *[a-zA-Z]?) (\d{5}) ((?:\p{L}| |-)+)(?: *\(([^\)]+)\))?$

Это правильно анализирует даже загадочные адреса, такие как «Straße des 17. Juni 23-25 ​​a 12345 Berlin-Mitte».

Обратите внимание, что это не работает с расширениями адресов (такими как «Gartenhaus» или «c / o…»). Я понятия не имею, как с этим справиться. Я очень сомневаюсь, что существует жизнеспособное регулярное выражение, чтобы выразить все это.

Как видите, это довольно сложное регулярное выражение с множеством групп захвата. Если я бы использовал такое выражение в коде, я бы использовал именованные захваты (Java 7 поддерживает их) и разбил бы выражение на более мелкие кусочки, используя флаг x. К сожалению, Java не поддерживает это. Это дерьмо, потому что это делает сложные регулярные выражения непригодными для использования.

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

^
(?<street>(?:\p{L}|\ |\d|\.|-)+?)\ 
(?<number>\d+(?:\ ?-\ ?\d+)?\ *[a-zA-Z]?)\ 
(?<zip>\d{5})\ 
(?<city>(?:\p{L}|\ |-)+)
(?:\ *\((?<suffix>[^\)]+)\))?
$

В Java 7 самое близкое, что мы можем достичь, это (не проверено; может содержать опечатки):

String pattern =
    "^" +
    "(?<street>(?:\\p{L}| |\\d|\\.|-)+?) " +
    "(?<number>\\d+(?: ?- ?\\d+)? *[a-zA-Z]?) " +
    "(?<zip>\\d{5}) " +
    "(?<city>(?:\\p{L}| |-)+)" +
    "(?: *\\((?<suffix>[^\\)]+)\\))?" +
    "$";

Вот мое предложение, которое можно дополнительно доработать, например. чтобы допустить недостающие части.

Шаблон регулярного выражения:

^([^0-9]+) ([0-9]+.*?) ([0-9]{5}) (.*)$

• Группа 1: Улица
• Группа 2: Дом №
• Группа 3: ZIP
• Группа 4: Город

public static void main(String[] args) {
    String data = "Name der Strase 25a 88489 Teststadt";
    String regexp = "([ a-zA-z]+) ([\\w]+) (\\d+) ([a-zA-Z]+)";

    Pattern pattern = Pattern.compile(regexp);
    Matcher matcher = pattern.matcher(data);
    boolean matchFound = matcher.find();

    if (matchFound) {
        // Get all groups for this match
        for (int i=0; i<=matcher.groupCount(); i++) {
            String groupStr = matcher.group(i);
            System.out.println(groupStr);
        }
    }System.out.println("nothing found");
                }

Я думаю, это не работает с немецкими умляутами, но вы можете исправить это самостоятельно. В любом случае это хороший стартап.

Я рекомендую посетить это отличный сайт о регулярных выражениях. Удачи!

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

Я бы сделал что-то вроде этого (псевдокод):

address[4] = empty
split[?] = address_string.split(" ")
address[3] = split[last]
address[2] = split[last - 1]
address[1] = split[last - 2]
address[0] = join split[first] through split[last - 3] with whitespace, trim trailing whitespace with trim()

Однако это будет обрабатывать только одну форму адреса. Если адреса записываются несколькими способами, это может быть намного сложнее.

попробуй это:

^[^\d]+[\d\w]+(\s)\d+(\s).*$

Он захватывает группы для каждого из пробелов, которые ограничивают 1 из 4 разделов адреса.

OR

это дает вам группы для каждой из частей адреса:

^([^\d]+)([\d\w]+)\s(\d+)\s(.*)$

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