Java-Bibliothek für frei-text-diff

Ich müssen zu entsprechen, zwei fast-das-gleiche lange freetext-strings; d.h., zu finden-index-index Korrespondenzen, wo immer möglich.

Weil das ist freetext, der Vergleich sollte nicht die Linie-wie im code diff.

Anregungen für Java-Bibliotheken?

Einem einfachen Beispiel (Im wirklichen Leben , natürlich, es würde keinen zusätzlichen Leerraum Linie die Dinge, und es kann mehr komplexe Herausforderungen wie die gesamten Klauseln bewegt werden.)

The quick brown  fox jumped over the  lazy     dog.
||||||||||      |||||||||||||||||||||         |||||
The quick yellow fox jumped over the well-bred dog.

InformationsquelleAutor der Frage Joshua Fox | 2009-01-26

  1. 16

    Diese könnte man gut Diff-Match-Patch.

    InformationsquelleAutor der Antwort Joshua Fox

  2. 7

    Je nach Ihren genauen Anforderungen, die StringUtils Klasse der Apache Commons Lang Komponente, die hilfreich sein könnten, z.B.:

    • StringUtils#Differenz: Vergleicht zwei Zeichenfolgen und gibt den Teil, wo Sie sich unterscheiden
    • StringUtils#getLevenshteinDistance: Finden Sie die Die Levenshtein-Distanz zwischen zwei Strings

    InformationsquelleAutor der Antwort Fabian Steeg

  3. 1

    Hier ist ein (leicht-getestet) version der code das tut, was Sie gefragt. Sie können leicht durchqueren das Ergebnis parallel mit den Eingängen zu suchen, Einfügungen und Löschungen.

    public class StringDiff {

    private static int   length(String s) { return s == null ? 0 : s.length(); }
    private static char[] chars(String s) { return s == null ? new char[0] : s.toCharArray(); }

    private final String left;
    private final String right;

    private final char[] lccs;
    private final String lcs;

    public StringDiff(String left, String right) {
        this.left = left;
        this.right = right;
        lccs = init();
        lcs = new String(lccs);
    }

    public String getLcs()  { return lcs; }
    public char[] getLccs() { return lccs.clone(); }

    private char[] init() {
        int lLength = length(left);
        int rLength = length(right);
        char[] lChars = chars(left);
        char[] rChars = chars(right);
        int [][] t = new int [lLength + 1][rLength + 1];
        for (int i = lLength - 1; i >= 0; --i) {
            for (int j = rLength - 1; j >= 0; --j) {
                if (lChars[i] == rChars[j]) {
                    t[i][j] = t[i + 1][j + 1] + 1;
                } else {
                    t[i][j] = Math.max(t[i + 1][j], t[i][j + 1]);
                }
            }
        }
        char[] result = new char[t[0][0]];
        int l = 0, r = 0, p = 0;
        while (l < lLength && r < rLength) {
            if (lChars[l] == rChars[r]) {
                result[p++] = lChars[l++];
                r++;
            } else {
                if (t[l + 1][r] > t[l][r + 1]) {
                    ++l;
                } else {
                    ++r;
                }
            }
        }
        return result;
    }

}

    Entsprechend, die tatsächliche längste Teilfolge von Ihrem ursprünglichen Eingänge:

    The quick brown  fox jumped over the  lazy     dog.
The quick yellow fox jumped over the well-bred dog.

    ist:

    The quick ow fox jumped over the l dog.

    (da "Braun" und "gelb" haben, "ow" in common, etc.)

    Ist es relativ einfach zu ändern die oben genannten split auf Leerzeichen (anstatt in char-arrays) und Ersatz-String#equals für ==, um eine version, die feststellt, die längste gemeinsame Teilfolge von Wörtern anstelle von Zeichen. Für dein Beispiel oben, ändern produzieren würde, das offensichtliche Ergebnis:

    found 7 words
    'The'
    'quick'
    'fox'
    'jumped'
    'over'
    'the'
    'dog.'

    (Ihre Frage implizite Charakter Vergleiche, wie Sie abgestimmt die Leerzeichen zwischen den Wörtern.)

    InformationsquelleAutor der Antwort joel.neely

  4. 0

    Wenn Sie Beispiel ist wirklich das, was Sie tun möchten - ie-untersequenzen nur entsprechen, wenn Sie beginnen, auf den gleichen index (was ist anders, wie diffs arbeiten normalerweise) - das ist alles, was Sie tun müssen:

    import java.util.*;

class StringDiff {
    public static List<int[]> from(String s1, String s2) {
        int start = -1;
        int pos = 0;
        LinkedList<int[]> list = new LinkedList<int[]>();

        for(; pos < s1.length() && pos < s2.length(); ++pos) {
            if(s1.charAt(pos) == s2.charAt(pos)) {
                if(start < 0) start = pos;
            }
            else {
                if(start >= 0) list.add(new int[] { start, pos });
                start = -1;
            }
        }

        if(start >= 0) list.add(new int[] { start, pos });

        return list;
    }

    public static void main(String[] args) {
        for(int[] idx : from(args[0], args[1]))
            System.out.println(args[0].substring(idx[0], idx[1]));
    }
}

    Einer tatsächlichen diff Umsetzung weitaus komplexer.

    InformationsquelleAutor der Antwort Christoph

Schreibe einen Kommentar