Extrait de la différence entre deux chaînes de caractères en Java

Salut, j'ai deux chaînes :

    String hear = "Hi My name is Deepak"
            + "\n"
            + "How are you ?"
            + "\n"
            + "\n"
            + "How is everyone";
    String dear = "Hi My name is Deepak"
            + "\n"
            + "How are you ?"
            + "\n"
            + "Hey there \n"
            + "How is everyone";

Je veux obtenir ce qui n'est pas présent dans la entendre chaîne "salut \n". J'ai trouvé une méthode , mais il ne parvient pas pour ce cas :

static String strDiffChop(String s1, String s2) {
    if (s1.length() > s2.length()) {
        return s1.substring(s2.length() - 1);
    } else if (s2.length() > s1.length()) {
        return s2.substring(s1.length() - 1);
    } else {
        return "";
    }
}

Quelqu'un peut-il aider ?

Je pense à une autre approche peut être fractionné de Chaîne en fonction de l'espace et puis boucle sur chaque élément?
Oui Nambari, Merci . C'est ce que j'ai fait .

OriginalL'auteur N Deepak Prasath | 2013-08-20

23

google-diff-match-patch

La Diff Match et Patch bibliothèques offrent des algorithmes robustes pour effectuer les opérations nécessaires pour la synchronisation de texte brut.

Diff:

Comparer les deux blocs de texte simple et efficace de renvoyer une liste de différences.

Match:

Donné une chaîne de recherche, de trouver sa meilleure correspondance floue dans un bloc de texte en clair. Pondérée à la fois l'exactitude et de l'emplacement.

Patch:

Appliquer une liste de patchs sur le texte brut. Utilisez les meilleurs efforts pour appliquer le patch, même lorsque le texte ne correspond pas.

Actuellement disponibles dans Java, JavaScript, Dart, C++, C#, Objective-C, Lua et Python. Quelle que soit la langue, chaque bibliothèque dispose de la même interface de programmation API et les mêmes fonctionnalités. Toutes les versions ont aussi complet harnais de test.

Il y a un Ligne ou mot de diff page wiki qui explique comment le faire ligne par ligne de diff.

Merci Mike . 🙂
Quelle merveilleuse lib. Merci.

OriginalL'auteur Mike Samuel

On peut utiliser le StringUtils de Apache Commons. Voici la StringUtils API.

public static String difference(String str1, String str2) {
    if (str1 == null) {
        return str2;
    }
    if (str2 == null) {
        return str1;
    }
    int at = indexOfDifference(str1, str2);
    if (at == -1) {
        return EMPTY;
    }
 return str2.substring(at);
}
public static int indexOfDifference(String str1, String str2) {
    if (str1 == str2) {
        return -1;
    }
    if (str1 == null || str2 == null) {
        return 0;
    }
    int i;
    for (i = 0; i < str1.length() && i < str2.length(); ++i) {
        if (str1.charAt(i) != str2.charAt(i)) {
            break;
        }
    }
    if (i < str2.length() || i < str1.length()) {
        return i;
    }
    return -1;
}

OriginalL'auteur Fly

2

convertir la chaîne de listes et ensuite utiliser la méthode suivante pour obtenir le résultat Comment faire pour supprimer des valeurs communes à partir de deux tableau liste

J'ai divisé l'une des chaînes et de parcourir le tableau et a trouvé le rare dans la deuxième chaîne .

OriginalL'auteur Aditya Rai

J'ai utilisé le StringTokenizer de trouver la solution. Ci-dessous l'extrait de code

public static List<String> findNotMatching(String sourceStr, String anotherStr){
    StringTokenizer at = new StringTokenizer(sourceStr, " ");
    StringTokenizer bt = null;
    int i = 0, token_count = 0;
    String token = null;
    boolean flag = false;
    List<String> missingWords = new ArrayList<String>();
    while (at.hasMoreTokens()) {
        token = at.nextToken();
        bt = new StringTokenizer(anotherStr, " ");
        token_count = bt.countTokens();
        while (i < token_count) {
            String s = bt.nextToken();
            if (token.equals(s)) {
                flag = true;
                break;
            } else {
                flag = false;
            }
            i++;
        }
        i = 0;
        if (flag == false)
            missingWords.add(token);
    }
    return missingWords;
}

l'aide de base du langage Java, de l'objet au lieu de la 3ème partie de la dépendance pour les moins de code compliqué!

OriginalL'auteur VJ THAKUR

1

Vous devez utiliser StringUtils de Apache Commons

Oui, j'ai entendu parler beaucoup .

OriginalL'auteur gurbieta
0

Je cherchais une solution, mais ne pouvait pas trouver celui dont j'avais besoin, j'ai donc créé une classe utilitaire pour comparer deux versions d'un texte - nouveaux et anciens - et la suite du texte avec les modifications entre les balises [ajouté] et [supprimé]. Il peut être facilement remplacé par le marqueur de vous choisir à la place de cette balises, par exemple: une balise html. chaîne-version-comparaison

Tous les commentaires seront appréciés.

*il pourrait ne pas bien fonctionné avec texte long en raison de la hausse de la probabilité de trouver même des phrases comme supprimé.

OriginalL'auteur ahanook

Si vous préférez ne pas utiliser une bibliothèque externe, vous pouvez utiliser le Java suivant extrait efficacement calculer la différence:

/**
* Returns an array of size 2. The entries contain a minimal set of characters
* that have to be removed from the corresponding input strings in order to
* make the strings equal.
*/
public String[] difference(String a, String b) {
return diffHelper(a, b, new HashMap<>());
}
private String[] diffHelper(String a, String b, Map<Long, String[]> lookup) {
return lookup.computeIfAbsent(((long) a.length()) << 32 | b.length(), k -> {
if (a.isEmpty() || b.isEmpty()) {
return new String[]{a, b};
} else if (a.charAt(0) == b.charAt(0)) {
return diffHelper(a.substring(1), b.substring(1), lookup);
} else {
String[] aa = diffHelper(a.substring(1), b, lookup);
String[] bb = diffHelper(a, b.substring(1), lookup);
if (aa[0].length() + aa[1].length() < bb[0].length() + bb[1].length()) {
return new String[]{a.charAt(0) + aa[0], aa[1]};
} else {
return new String[]{bb[0], b.charAt(0) + bb[1]};
}
}
});
}

Cette approche est à l'aide de la programmation dynamique. Il essaie toutes les combinaisons dans une attaque par force brute façon, mais se souvient déjà calculés sous-chaînes et, par conséquent, s'exécute en O(n^2).

Exemples:

String hear = "Hi My name is Deepak"
+ "\n"
+ "How are you ?"
+ "\n"
+ "\n"
+ "How is everyone";
String dear = "Hi My name is Deepak"
+ "\n"
+ "How are you ?"
+ "\n"
+ "Hey there \n"
+ "How is everyone";
difference(hear, dear); //returns {"","Hey there "}
difference("Honda", "Hyundai"); //returns {"o","yui"}
difference("Toyota", "Coyote"); //returns {"Ta","Ce"}

OriginalL'auteur jjoller

-1

à propos de cet extrait ?
```
public static void strDiff(String hear, String dear){
String[] hr = dear.split("\n");
for (String h : hr) {
if (!hear.contains(h)) {
System.err.println(h);
}
}
}
```
a posté la bonne solution. Qui ne un vrai diff. String.contains() serait un échec si le contenu du texte en cours d'appariement ont ses lignes ré-arrangé.

OriginalL'auteur N Deepak Prasath

Vous devez vous connecter pour publier un commentaire.

Diff:

Match:

Patch: