Trouver des caractères différents dans deux chaînes

Question

Comment puis-je trouver différents caractères dans les chaînes aux mêmes positions? Ex:

String string1 = "Anand has 2 bags and 4 apples"; 
String n = /* ??? */; 
String n2 = /* ??? */; 
String string2 = "Anand has " + n + " bags and " + n2 + " apples"; 

Je veux n = "2" et n1 = "4".

S'il vous plaît laissez-moi savoir comment nous pouvons le faire? (Espace ajouté entre les mots uniquement à des fins de clarté.) Je ne peux pas utiliser l'espace comme délimiteur.

Answer 1

Vous pouvez utiliser la classe StringTemplate que j'ai développé (je l'avais développé une classe UriTemplate pour correspondre restlike uri mais ont modifié pour utiliser des chaînes ainsi)

// Licensed Apache2 (http://www.apache.org/licenses/LICENSE-2.0.txt) 
    import java.util.List; 

    import java.net.URL; 
    import java.net.URLConnection; 

    import java.util.Map; 
    import java.util.ArrayList; 
    import java.util.LinkedHashMap; 
    import java.util.regex.Matcher; 
    import java.util.regex.Pattern; 

    /** 
    * <pre> 
    * StringTemplate t = new StringTemplate("/catalog/{categoryId}/products/{productId}/summary"); 
    * t.matches("/catalog/23/products/12375/summary"); // returns true 
    * t.match("/catalog/23/products/12375/summary"); // returns a map {categoryId=23, productId=12375} 
    * </pre> 
    * 
    * @author anaik 
    */ 
    public class StringTemplate { 
    /** The meta pattern for template to match sequence such as: {someVar} */ 
    private static final Pattern patternPattern = Pattern.compile("\\{([^\\{\\}]+)\\}"); 
    /** The pattern string */ 
    private String stringPattern; 
    /** The generated pattern when the stringPattern is parsed */ 
    private Pattern thisStringPattern; 
    /** Variable names found in this pattern in that order */ 
    private List<String> vars = new ArrayList<String>(); 

    /** 
     * Creates a new StringTemplate from the specified pattern 
     * @param Pattern 
     */ 
    private StringTemplate(String stringPattern) { 
     this.stringPattern = stringPattern; 
     initialize(); 
    } 

    /** 
     * Gets the names of variables - those defined in {variable-name} constructs - in this StringTemplate 
     * in the order they were specified 
     * @return a list of variables or an empty list if no variables were found 
     */ 
    public List<String> getVars() { 
     return vars; 
    } 

    /** 
     * Determine whether the specified <tt>actualString</code> matches with this StringTemplate 
     * @param actualString The actual to match 
     * @return true iff successfull match 
     */ 
    public boolean matches(String actualString) { 
     return thisStringPattern.matcher(actualString).matches(); 
    } 

    /** 
     * Matches the <tt>actualString</tt> with this StringTemplate and extracts values for all the variables 
     * in this template and returns them as an ordered map (keys defined in the same order as that of 
     * the StringTemplate. If the match was unsuccessfull, an empty map is returned. Note that this method 
     * should be ideally be called after {@link #matches(java.lang.String) } to check whether the 
     * specified actually matches the template 
     */ 
    public Map<String, String> match(String actualString) { 
     Matcher m = thisStringPattern.matcher(actualString); 
     Map<String, String> map = new LinkedHashMap<String, String>(); 
     if(m.matches()) { 
      int gc = m.groupCount(); 
      for(int i = 0; i < gc; i++) { 
       int g = i + 1; 
       map.put(vars.get(i), actualString.substring(m.start(g), m.end(g))); 
      } 
     } 
     return map; 
    } 

    private void initialize() { 
     Matcher m = patternPattern.matcher(stringPattern); 
     StringBuffer builder = new StringBuffer(); 

     while(m.find()) { 
      String var = m.group(1); 
      vars.add(var); 
      m.appendReplacement(builder, "(.*)"); 
     } 
     m.appendTail(builder); 
     String genPattern = builder.toString(); 
     thisStringPattern = Pattern.compile(genPattern); 
    } 

    public static void main(String[] args) throws Throwable { 
     StringTemplate t = new StringTemplate(args[0]); 
     System.out.println("Matches with actual Class Identifier: java.lang.String: " + t.matches(args[1])); 
     System.out.println("Var values: " + t.match(args[1])); 
    } 
    } 

et compilé ce test comme suit:

tmp$ java StringTemplate "Anand has {n} bags and {n1} apples" "Anand has 23 bags and 500 apples" 

C'est la sortie

Matches with actual URI: true 
Var values: {n=23, n1=500} 

Les matchs (String) retourne la carte contenant les noms de variables de modèle et les valeurs. Cette classe peut être utilisée pour faire correspondre n'importe quelle chaîne avec n'importe quel nombre de vars. Son liscensed apache2

Si votre chaîne d'entrée contient des caractères regex, vous devrez leur échapper:

input = input.replaceAll("\\$", "\\\\\\$"); 
    input = input.replaceAll("\\(", "\\\\("); 
    input = input.replaceAll("\\)", "\\\\)"); 
    StringTemplate st = new StringTemplate(input); 

Notez que vous avez besoin regexps plus précis pour des conditions où la chaîne d'entrée a déjà des personnages comme « $ \ »

Answer 2

Une expression régulière devrait le faire correctement.

Answer 3

Vous pouvez utiliser une boucle for en boucle sur la longueur de la plus petite des cordes et vérifier à chaque position individuelle

Answer 4

Si les longueurs ne sont pas les mêmes:

for(int i = 0; i < Math.min(str1.length, str2.length); i++){ 
    if(str1.charAt(i) != str2.charAt(i)){ 
     //Different 
    } 
} 

for(int i = Math.min(str1.length, str2.length); 
      i < Math.max(str1.length, str2.length); i++){ 
    //Each is in one but not the other. 
} 

Si les longueurs sont les mêmes:

for(int i = 0; i < str1.length; i++){ 
    if(str1.charAt(i) != str2.charAt(i)){ 
     //Different 
    } 
} 

Answer 5

Je diviserait les cordes par des « espaces », alors je ferais une boucle à la recherche de numéros dans le tableau résultant. Voici un petit exemple, il est clumpsy mais il obtient le travail accompli:

import java.util.ArrayList; 

public class XXX{ 
    public static void main(String[] args){ 
     String str = "Anand has 2 bags and 4 apples"; 

     System.out.println("Start..."); 
     System.out.println(str); 
     String words[] = str.split("\\s+"); 

     ArrayList<String> values = new ArrayList<String>(); 

     for(String s:words){ 
      System.out.println(s); 
      try{ 
       Integer.parseInt(s); 
       values.add(s); 
      } 
      catch(NumberFormatException ex){ 
       System.out.println(s + " is not a number"); 
      }  
     } 

     System.out.println("Anand has " + values.get(0) + " bags and " + values.get(1) + " apples"); 

    } 
} 

Answer 6

Si vous êtes sûr de votre texte dans la chaîne reste la même que vous pouvez faire quelque chose comme ça -

String string1 ="Anand has 2 bags and 4 apples"; 
String[] parts = string1.split("\\s+"); 
System.out.println("n = " + parts[2] + " n1 = " + parts [5]);