[Schmitzm-commits] r1778 - in trunk/schmitzm-adresses/src: main/java/de/schmitzm/adresses test/java/de/schmitzm/adresses
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Mon Nov 14 11:44:20 CET 2011
Author: alfonx
Date: 2011-11-14 11:44:19 +0100 (Mon, 14 Nov 2011)
New Revision: 1778
Modified:
trunk/schmitzm-adresses/src/main/java/de/schmitzm/adresses/AddrStringUtil.java
trunk/schmitzm-adresses/src/test/java/de/schmitzm/adresses/AddrStringUtilTest.java
Log:
Modified: trunk/schmitzm-adresses/src/main/java/de/schmitzm/adresses/AddrStringUtil.java
===================================================================
--- trunk/schmitzm-adresses/src/main/java/de/schmitzm/adresses/AddrStringUtil.java 2011-11-12 01:13:40 UTC (rev 1777)
+++ trunk/schmitzm-adresses/src/main/java/de/schmitzm/adresses/AddrStringUtil.java 2011-11-14 10:44:19 UTC (rev 1778)
@@ -9,23 +9,23 @@
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
+import com.sun.tools.internal.xjc.Language;
+
+import de.schmitzm.lang.LangUtil;
+import de.schmitzm.regex.RegexCache;
+
/**
- * Diese Klasse bietete nützliche Methoden zur Bearbeitung von
- * Addressschreibweisen. Zur Zeit werden nur Strings mit Strasse [Hn] [Zusatz]
- * behandelt.<br/>
- * Es werden Methoden zum Aufteilen (Splitten) von String angeboten, um Strasse
- * +Hn + Zusatz in drei Strings zu zerlegen. Weiterhin existieren Methoden um
- * die Schreibweisen von Straßen, Hausnummern un Zusätzen zu normalisieren.
- * Diese normalisierten Strings können dann zum abgeleichen von
- * Addressinformationen verwendet werden.<br/>
- * Ersetzungsregeln für die Normalisierung werden in drei Excel-Dateien
- * verwaltet.<br/>
+ * Diese Klasse bietete nützliche Methoden zur Bearbeitung von Addressschreibweisen. Zur Zeit werden nur Strings mit
+ * Strasse [Hn] [Zusatz] behandelt.<br/>
+ * Es werden Methoden zum Aufteilen (Splitten) von String angeboten, um Strasse +Hn + Zusatz in drei Strings zu
+ * zerlegen. Weiterhin existieren Methoden um die Schreibweisen von Straßen, Hausnummern un Zusätzen zu normalisieren.
+ * Diese normalisierten Strings können dann zum abgeleichen von Addressinformationen verwendet werden.<br/>
+ * Ersetzungsregeln für die Normalisierung werden in drei Excel-Dateien verwaltet.<br/>
*/
public class AddrStringUtil {
static final private Logger log = Logger.getLogger(AddrStringUtil.class);
- final static Pattern REGEX_splitHnZusatz = Pattern
- .compile("(\\d+)\\s*(.*?)\\s*$");
+ final static Pattern REGEX_splitHnZusatz = Pattern.compile("(\\d+)\\s*(.*?)\\s*$");
final static Pattern REGEX_splitFullString = Pattern
.compile("^(.*\\d+\\.+[^\\d]*|[^\\d,]+)"
+ "\\s*"
@@ -37,19 +37,20 @@
// final static Pattern REGEX_hnBereich = Pattern
// .compile("(\\d+)([^\\d]?)(\\s*)(-|bis)(\\s*)(\\w+).*");
- final static Pattern REGEX_hnListe = Pattern
- .compile("(\\d+)([^\\d]+)(\\d+).*");
+ final static Pattern REGEX_hnListe = Pattern.compile("(\\d+)([^\\d]+)(\\d+).*");
final static Pattern REGEX_hnEinzeln = Pattern.compile("(\\d+)(.*)");
/**
- * Normalisiert die Schreibweise eines Straßennamens, z.B.
- * "Dr.-Vogeler-Str." -> "drvogelerstrasse"
+ * Normalisiert die Schreibweise eines Straßennamens, z.B. "Dr.-Vogeler-Str." -> "drvogelerstrasse"
+ *
+ * @deprecated
*/
public static final NormResult normalizeStrasse(final String strasse) {
return normalize(RuleRegistry.getRulesStr(), strasse);
}
+
/**
* Normalisiert die Schreibweise einer Hausnummer, z.B. " 5 " -> "5"
*/
@@ -67,8 +68,7 @@
/**
* Applies the given "Rules"/ Transformations to the given String.
*/
- private static NormResult normalize(final List<NormRule> rules,
- final String string) {
+ private static NormResult normalize(final List<NormRule> rules, final String string) {
if (string == null)
return new NormResult(null);
@@ -87,16 +87,14 @@
}
/**
- * Diese Methode teilt einen String, der Hausnummer und einen optionalen
- * Zusatz enhält, in zwei Strings.
+ * Diese Methode teilt einen String, der Hausnummer und einen optionalen Zusatz enhält, in zwei Strings.
*
* @param origHn
- * darf <code>null</code> sein. Kann nur die HN oder HN+ZUSATZ
- * enthalten.
+ * darf <code>null</code> sein. Kann nur die HN oder HN+ZUSATZ enthalten.
* @param origZusatz
* darf <code>null</code> sein.
- * @return Zwei Strings, zuerst ein String mit der Hausnummer (oder null),
- * und als zweites ein String mit dem Zusatz (oder null).
+ * @return Zwei Strings, zuerst ein String mit der Hausnummer (oder null), und als zweites ein String mit dem Zusatz
+ * (oder null).
*/
public static String[] splitHn(final String origHn, final String origZusatz) {
if (origHn == null)
@@ -133,17 +131,14 @@
}
/**
- * Diese Methode teilt einen String, der Strasse, Hausnummer und einen optionalen
- * Zusatz enhält, in zwei Strings.
+ * Diese Methode teilt einen String, der Strasse, Hausnummer und einen optionalen Zusatz enhält, in zwei Strings.
*
* @param origStrasseFull
* darf null sein.
* @param origHn
* darf null sein.
* @param origZusatz2
- * @return Drei Objekte, String strasse, dann ein Integer mit der
- * Hausnummer, und als drittes ein String mit dem Zusatz. bei können
- * null sein.
+ * @return Drei Strings, strasse, dann Hausnummer, und als drittes ein String mit dem Zusatz. ALle können null sein.
*/
public static String[] split(final String... stringStrHnZusatz) {
@@ -163,8 +158,7 @@
if (stringStrHnZusatz.length == 3)
origZusatz = stringStrHnZusatz[2];
- if (origStrasse == null || origStrasse.isEmpty()
- || !origStrasse.matches(".*[A-Za-z][A-Za-z]+.*")) {
+ if (origStrasse == null || origStrasse.isEmpty() || !origStrasse.matches(".*[A-Za-z][A-Za-z]+.*")) {
final String[] splitHn = splitHn(origHn, origZusatz);
return new String[] { null, splitHn[0], splitHn[1] };
}
@@ -180,8 +174,7 @@
origZusatz = trimQuotes(origZusatz);
}
- String zusammen = origStrasse + " "
- + (origHn != null ? " " + origHn : "")
+ String zusammen = origStrasse + " " + (origHn != null ? " " + origHn : "")
+ (origZusatz != null ? " " + origZusatz : "");
zusammen = trimQuotes(zusammen);
zusammen = removeKommataAfterStreetname(zusammen);
@@ -200,8 +193,7 @@
// + origStrasse + " " + origHn + " " + origZusatz);
// return new String[] { null, splitHn[0], splitHn[1] };
- Pattern p = Pattern
- .compile("([^\\d]*)\\s([\\d]+[^\\s]*|[\\d]+\\s+\\d+)$");
+ Pattern p = Pattern.compile("([^\\d]*)\\s([\\d]+[^\\s]*|[\\d]+\\s+\\d+)$");
m = p.matcher(zusammen);
if (m.find()) {
strasse = m.group(1);
@@ -242,8 +234,7 @@
strasse = StringUtils.trimToNull(strasse);
if (strasse == null || strasse.length() < 3) {
- final Pattern p = Pattern
- .compile("(.+?)\\s([\\d]+[-]?[\\d]*)(.*)$");
+ final Pattern p = Pattern.compile("(.+?)\\s([\\d]+[-]?[\\d]*)(.*)$");
m = p.matcher(zusammen);
if (m.find()) {
strasse = m.group(1);
@@ -266,12 +257,10 @@
}
if (warn)
- log.debug("Aus '" + origStrasse + "' wurde Strasse='" + strasse
- + "', HN='" + StringUtils.trimToNull(hn) + "', Zusatz='"
- + StringUtils.trimToNull(zusatz) + "', richtig?");
+ log.debug("Aus '" + origStrasse + "' wurde Strasse='" + strasse + "', HN='" + StringUtils.trimToNull(hn)
+ + "', Zusatz='" + StringUtils.trimToNull(zusatz) + "', richtig?");
- return new String[] { strasse, StringUtils.trimToNull(hn),
- StringUtils.trimToNull(zusatz) };
+ return new String[] { strasse, StringUtils.trimToNull(hn), StringUtils.trimToNull(zusatz) };
}
/**
@@ -287,14 +276,11 @@
* @return
*/
public static String removeKommataAfterStreetname(String zusammen) {
- return zusammen.replaceAll("([A-Za-z][A-Za-z]+)\\s?[,]\\s?(\\d+)",
- "$1 $2");
+ return zusammen.replaceAll("([A-Za-z][A-Za-z]+)\\s?[,]\\s?(\\d+)", "$1 $2");
}
- private static String removeSpacesBetweenHiphenAndDotAndLetters(
- String zusammen) {
- zusammen = zusammen.replaceAll("([A-Za-z]+)\\s+([.-]*)\\s?([.-])+",
- "$1$2$3");
+ private static String removeSpacesBetweenHiphenAndDotAndLetters(String zusammen) {
+ zusammen = zusammen.replaceAll("([A-Za-z]+)\\s+([.-]*)\\s?([.-])+", "$1$2$3");
return zusammen;
}
@@ -319,12 +305,10 @@
}
// TODO sauberes rewrite unter besserer Ausnutzung von Rekursion
- public static List<String> getHausnummernInterpreted(
- final String hausnummern) {
+ public static List<String> getHausnummernInterpreted(final String hausnummern) {
final List<String> result = new ArrayList<String>();
if (hausnummern != null) {
- final Matcher m = Pattern.compile("(\\d)+\\s*([a-z]+)[,]([a-z]+)")
- .matcher(hausnummern);
+ final Matcher m = Pattern.compile("(\\d)+\\s*([a-z]+)[,]([a-z]+)").matcher(hausnummern);
if (m.find()) {
result.addAll(getHausnummern(m.group(1) + m.group(2)));
result.addAll(getHausnummern(m.group(1) + m.group(3)));
@@ -353,8 +337,7 @@
if (m.find()) {
// 15a - f
- if (!m.group(2).isEmpty() && m.group(4).isEmpty()
- && !m.group(5).isEmpty()) {
+ if (!m.group(2).isEmpty() && m.group(4).isEmpty() && !m.group(5).isEmpty()) {
for (char a = m.group(2).charAt(0); a <= m.group(5).charAt(0); a++) {
result.add(m.group(1) + a);
@@ -364,8 +347,7 @@
// TODO Hier stehen manchmal nicht nur zahlen drin!
/**
- * Stefan Tzeggai : Was soll das programm aus "9a - 11d" machen?
- * "9a, 10, 11d" ?
+ * Stefan Tzeggai : Was soll das programm aus "9a - 11d" machen? "9a, 10, 11d" ?
*/
// Überprüfen, ob hinter der Zahl noch was steht...
@@ -374,11 +356,9 @@
final String maxNumStr = m.group(4);
// 12-15
- if (m.group(2).isEmpty() && !maxNumStr.isEmpty()
- && m.group(5).isEmpty()) {
+ if (m.group(2).isEmpty() && !maxNumStr.isEmpty() && m.group(5).isEmpty()) {
// Keine Zusätze in dem Bereich...
- log.debug("Versuche Hausnummernbereich " + minNumStr + " bis "
- + maxNumStr + " aufzulösen...");
+ log.debug("Versuche Hausnummernbereich " + minNumStr + " bis " + maxNumStr + " aufzulösen...");
final int min = Integer.parseInt(minNumStr);
final int max = Integer.parseInt(maxNumStr);
@@ -394,8 +374,7 @@
result.add(Integer.toString(i));
}
} else {
- log.debug("Hausnummernbereich " + minNumStr + m.group(2)
- + " bis " + maxNumStr + m.group(5)
+ log.debug("Hausnummernbereich " + minNumStr + m.group(2) + " bis " + maxNumStr + m.group(5)
+ " kann noch nicht hochgezählt werden.");
if (!minNumStr.isEmpty())
result.add(minNumStr + m.group(2));
@@ -421,17 +400,15 @@
return result;
}
- log.error("Hausnummer raw '" + hausnummerUntested
- + "' nicht verstanden.");
+ log.error("Hausnummer raw '" + hausnummerUntested + "' nicht verstanden.");
return result;
}
/**
- * Interpretiert eine GKZ, KKZ etc anhang Ihrer Länge und liefert ob es sich
- * um einen KREIS oder ein BUNDESLAND handelt
+ * Interpretiert eine GKZ, KKZ etc anhang Ihrer Länge und liefert ob es sich um einen KREIS oder ein BUNDESLAND
+ * handelt
*
- * @return <code>null</code> wenn <code>null</code> übergeben worde oder der
- * code nicht verstanden wurde.
+ * @return <code>null</code> wenn <code>null</code> übergeben worde oder der code nicht verstanden wurde.
*/
static Ebene getEbeneForEbeneCode(String code) {
if (code == null)
@@ -445,4 +422,75 @@
return Ebene.BUNDESLAND;
return null;
}
+
+
+
+ /**
+ * Normalisiert die Schreibweise eines Straßennamens, z.B. "Dr.-Vogeler-Str." -> "drvogelerstrasse"
+ */
+ public static final String normalizeStr(String strasse) {
+ strasse = LangUtil.removeWhitespacesToEmpty(strasse);
+ if (strasse.isEmpty())
+ return "";
+
+ strasse = strasse.toLowerCase();
+
+ strasse = strasse.replaceAll("str(\\.|\\s)", "strasse");
+ strasse = strasse.replaceAll("strase", "strasse");
+ strasse = strasse.replaceAll("\\s*s$", "strasse");
+ strasse = strasse.replaceAll("alle(\b|$)", "allee");
+ strasse = strasse.replaceAll("alee(\b|$)", "allee");
+
+
+ strasse = strasse.replaceAll("ü", "ue");
+ strasse = strasse.replaceAll("ö", "oe");
+ strasse = strasse.replaceAll("ä", "ae");
+ strasse = strasse.replaceAll("ß", "ss");
+ strasse = strasse.replaceAll("é", "e");
+ strasse = strasse.replaceAll("è", "e");
+ strasse = strasse.replaceAll("á", "a");
+ strasse = strasse.replaceAll("à", "a");
+ strasse = strasse.replaceAll("-", "");
+ strasse = strasse.replaceAll(",", "");
+ strasse = strasse.replaceAll("/", "");
+ strasse = strasse.replaceAll("\\.", "");
+ strasse = strasse.replaceAll("\\s*", "");
+
+ return strasse;
+ }
+
+
+
+ /**
+ * Normalisiert die Schreibweise eines Straßennamens, z.B. "Dr.-Vogeler-Str." -> "drvogelerstrasse"
+ */
+ public static final String normalizeOrt(String ort) {
+ ort = LangUtil.removeWhitespacesToEmpty(ort);
+ if (ort.isEmpty())
+ return "";
+
+ ort = ort.toLowerCase();
+
+ ort = ort.replaceAll("st(\\.|\\s)", "sankt");
+ ort = ort.replaceAll("sta(\\.|\\s)", "sankt");
+ ort = ort.replaceAll("im breisgau", "ib");
+
+ ort = ort.replaceAll("a(\\.|\\s)d(\\.|\\s)", "an der");
+ ort = ort.replaceAll("i(\\.|\\s)", "im");
+
+ ort = ort.replaceAll("ü", "ue");
+ ort = ort.replaceAll("ö", "oe");
+ ort = ort.replaceAll("ä", "ae");
+ ort = ort.replaceAll("ß", "ss");
+ ort = ort.replaceAll("é", "e");
+ ort = ort.replaceAll("è", "e");
+ ort = ort.replaceAll("á", "a");
+ ort = ort.replaceAll("à", "a");
+ ort = ort.replaceAll("-", "");
+ ort = ort.replaceAll(",", "");
+ ort = ort.replaceAll("\\.", "");
+ ort = ort.replaceAll("\\s*", "");
+
+ return ort;
+ }
}
Modified: trunk/schmitzm-adresses/src/test/java/de/schmitzm/adresses/AddrStringUtilTest.java
===================================================================
--- trunk/schmitzm-adresses/src/test/java/de/schmitzm/adresses/AddrStringUtilTest.java 2011-11-12 01:13:40 UTC (rev 1777)
+++ trunk/schmitzm-adresses/src/test/java/de/schmitzm/adresses/AddrStringUtilTest.java 2011-11-14 10:44:19 UTC (rev 1778)
@@ -1,6 +1,7 @@
package de.schmitzm.adresses;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import java.util.Collections;
import java.util.List;
@@ -8,11 +9,19 @@
import org.junit.Test;
import de.schmitzm.lang.LangUtil;
+import de.schmitzm.regex.RegexCache;
/**
*
*/
public class AddrStringUtilTest {
+
+ @Test
+ public void testXXX() {
+ final RegexCache rc = RegexCache.getInstance();
+ assertTrue(rc.matches("^.*?BAUGRUNDST..?CK", "BAUGRUNDSTÜCK"));
+ assertTrue(rc.matches("^.*?BAUGRUNDST..?CK", " BAUGRUNDSTÜCK "));
+ }
@Test
public void testGetHausnummernInterpreted() {
@@ -263,4 +272,36 @@
}
+ @Test
+ public void testNormalizeOrt()
+ {
+ assertEquals("sanktaugustin",AddrStringUtil.normalizeOrt("St. Augustin"));
+ assertEquals("freiburgib",AddrStringUtil.normalizeOrt("Freiburg im Breisgau"));
+ }
+
+
+ @Test
+ public void testNormalizeStrasse2() {
+ assertEquals("jaegerndorferzeile", AddrStringUtil.normalizeStr("Jägerndorfer Zeile"));
+ assertEquals("weststrasse", AddrStringUtil.normalizeStr("West Straße"));
+ assertEquals("weststrasse", AddrStringUtil.normalizeStr("West Str."));
+ assertEquals("hatschiergasse", AddrStringUtil.normalizeStr(" hatschiergasse "));
+ assertEquals("eichendorfstrasse", AddrStringUtil.normalizeStr("Eichendorfstr."));
+ assertEquals("burgstrasse", AddrStringUtil.normalizeStr("Burgstr."));
+ assertEquals("burgstrasse",AddrStringUtil.normalizeStr( "Burg Straße"));
+ assertEquals("drosselweg", AddrStringUtil.normalizeStr("Drossel Weg"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr.-Vogeler-Str."));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr. Vogeler Str."));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr. Vogeler Str ."));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr. Vogeler Strasse"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr. Vogeler/Strasse"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr. Vogeler Straße"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr. Vogeler-Straße"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr.Vogeler-Straße"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr.Vogelerstraße"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr.Vogelerstrasse"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr.Vogeler S"));
+ assertEquals("drvogelerstrasse", AddrStringUtil.normalizeStr("Dr.Vogeler Strase"));
+ }
+
}
More information about the Schmitzm-commits
mailing list