Comment générer des chaînes qui partagent le même code en Java?

Un système existant écrit en Java utilise le hashcode d'une chaîne de caractères comme sa stratégie de routage pour l'équilibrage de charge.

Maintenant, je ne peut pas modifier le système mais besoin de générer des chaînes de caractères qui partagent le même hashcode pour tester les pires conditions.

Je fournir ces chaînes à partir de la ligne de commande, et espérons que le système permettra d'acheminer toutes ces chaînes dans la même destination.

Est-il possible de générer un grand nombre de chaînes qui partagent le même hashcode?

À faire de cette question claire:

String[] getStringsInSameHashCode(int number){
    //return an array in length "number"
    //Every element of the array share the same hashcode. 
    //The element should be different from each other
}

Remarques: Tout hashCode valeur est acceptable. Il n'y a pas de contrainte sur ce que la chaîne est. Mais ils doivent être différents les uns des autres.

EDIT:
Remplacer la méthode de la classe String n'est pas acceptable parce que je me nourris de ceux de la chaîne de ligne de commande.

L'Instrumentation n'est pas acceptable non parce que cela va faire quelques impacts sur le système.

source d'informationauteur StarPinkER

puisque vous pouvez lire le chinois, vous pouvez regarder mon post
http://www.hetaoblog.com/myblogs/post/%E8%AF%B4%E4%B8%80%E8%AF%B4java%E9%87%8C%E9%9D%A2%E7%9A%84hashcode-string-hashcode.jhtml

voir une méthode de test, en gros, tant que vous le match,
a1*31+b1 = a2*31 +b2, ce qui signifie que (a1-a2)*31=b2-b1

public void testHash()
{
    System.out.println("A:" + ((int)'A'));
    System.out.println("B:" + ((int)'B'));
    System.out.println("a:" + ((int)'a'));

    System.out.println(hash("Aa".hashCode()));
    System.out.println(hash("BB".hashCode()));
    System.out.println(hash("Aa".hashCode()));
    System.out.println(hash("BB".hashCode()));


    System.out.println(hash("AaAa".hashCode()));
    System.out.println(hash("BBBB".hashCode()));
    System.out.println(hash("AaBB".hashCode()));
    System.out.println(hash("BBAa".hashCode()));

}

vous obtiendrez

edit: quelqu'un a dit que ce n'est pas assez simple. J'ai ajouté ci-dessous une partie

    @Test
    public void testN() throws Exception {
        List<String> l = HashCUtil.generateN(3);
        for(int i = 0; i < l.size(); ++i){
            System.out.println(l.get(i) + "---" + l.get(i).hashCode());
        }
    }
AaAaAa---1952508096
AaAaBB---1952508096
AaBBAa---1952508096
AaBBBB---1952508096
BBAaAa---1952508096
BBAaBB---1952508096
BBBBAa---1952508096
BBBBBB---1952508096

ci-dessous est le code source, il peut ne pas être efficace, mais ça marche:

public class HashCUtil {

    private static String[] base = new String[] {"Aa", "BB"};

    public static List<String> generateN(int n)
    {
        if(n <= 0)
        {
            return null;
        }

        List<String> list = generateOne(null);
        for(int i = 1; i < n; ++i)
        {
            list = generateOne(list);
        }

        return list;
    }


    public static List<String> generateOne(List<String> strList)
    {   
        if((null == strList) || (0 == strList.size()))
        {
            strList = new ArrayList<String>();
            for(int i = 0; i < base.length; ++i)
            {
                strList.add(base[i]);
            }

            return strList;
        }

        List<String> result = new ArrayList<String>();

        for(int i = 0; i < base.length; ++i)
        {
            for(String str: strList)
            {   
                result.add(base[i]  + str);
            }
        }

        return result;      
    }
}

regarder la Chaîne.hashCode()

   public int hashCode() {
    int h = hash;
    if (h == 0) {
        int off = offset;
        char val[] = value;
        int len = count;

            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
    }

5

Je pense que trouver une égale-chaîne de hachage à partir d'une longue chaîne est trop dur, il est facile, quand même-chaîne de hash d'une chaîne courte (2 ou 3).
Regardez l'équation ci-dessous. (désolé je ne peux pas poster d'image me causer nouveau membre)

Avis que, "FB" et "Ea" ont le même hashcode, et deux chaînes de caractères comme s1+"FB"+s2 et s1+"Ea"+s2 aura le même hashcode.
Donc, la solution facile est de trouver toutes les 2-char sous-chaîne de la chaîne existante et la remplacer par une 2-char sous-chaîne avec le même hashcode

Exemple, nous avons la chaîne "helloworld"
obtenez 2-char de la sous-chaîne "il", hashcode("il") = 'h'*31 + 'e' = ('h'*31 + 31) + ('e' - 31) = (h+1)*31 + 'F' = 'i' + 'F' = hashcode("si")
ainsi le désir de la chaîne est "iFlloworld"
nous avons augmenté le 'h' par 1, on peut augmenter par 2, ou 3, etc (mais sera mal si ce dépassement de la valeur char)

Le code ci-dessous fonctionne bien avec un petit niveau, il sera mauvais si le niveau est grand, prendre le char de la valeur de débordement, je vais corriger ça plus tard si vous le voulez (ce changement de code sur 2 caractères, mais je vais modifier le code pour les 2 derniers caractères parce que les 2 premiers caractères sont calc avec la plus grande valeur)
```
    public static String samehash(String s, int level) {
    if (s.length() < 2)
        return s;
    String sub2 = s.substring(0, 2);
    char c0 = sub2.charAt(0);
    char c1 = sub2.charAt(1);
    c0 = (char) (c0 + level);
    c1 = (char) (c1 - 31 * level);
    String newsub2 = new String(new char[] { c0, c1 });
    String re =  newsub2 + s.substring(2);
    return re;
}
```
1

Vous pouvez instrument de la java.lang.Classe String ainsi que sa méthode hashCode() renverra toujours le même nombre.

Je suppose que Javassist est le moyen le plus facile pour faire une telle instrumentation.

En bref:
- obtenir une instance de java.lang.de l'instrument.L'Instrumentation à l'aide d'un Java-agent (voir package java.lang.documentation de l'appareil pour plus de détails)
- redéfinir java.lang.Chaîne de classe à l'aide de l'Instrumentation.redefineClasses(ClassDefinition[]) méthode
Le code ressemblera à (environ):
```
ClassPool classPool = new ClassPool(true);
CtClass stringClass = classPool.get("java.lang.String");
CtMethod hashCodeMethod = stringClass.getDeclaredMethod("hashCode", null);
hashCodeMethod.setBody("{return 0;}");
byte[] bytes = stringClass.toBytecode();
ClassDefinition[] classDefinitions = new ClassDefinition[] {new ClassDefinition(String.class, bytes);
instrumentation.redefineClasses(classDefinitions);//this instrumentation can be obtained via Java-agent
```
Aussi, ne pas oublier que l'agent manifeste fichier doit spécifier Can-Redefine-Classes: true pour être en mesure d'utiliser redefineClasses(ClassDefinition[]) méthode.
1

Je me demandais si il y avait un "universel" de la solution; par exemple, certains de chaîne constante XYZtels que
```
    s.hashCode() == (s + XYZ).hashCode() 
```
pour toute chaîne s. La recherche d'une telle chaîne consiste à résoudre une assez compliqué équation ... qui était au-delà de mon rusty aptitudes en mathématiques. Mais alors, il m'est apparu que h == 31*h + ch est toujours true quand h et ch sont tous deux nuls!

Basé sur cette idée, la méthode suivante doit créer une autre Chaîne avec le même hashcode comme argument:
```
    public String collider(String s) { 
        return "    public String collider(String s) { 
return "\0" + s;
}
" + s;
    }
```
Si NUL, les personnages sont problématiques pour vous, ajoutant tout chaîne dont le hashcode est zéro serait trop de travail ... mais que la collision des chaînes serait plus long que si vous avez utilisé zéro.

String s = "Some String"
for (int i = 0; i < SOME_VERY_BIG_NUMBER; ++i) {
    String copy = new String(s);

    //Do something with copy.
}

Fera ce travail pour vous? Il crée un grand nombre de copies de la même Chaîne de caractères littérale que vous pouvez utiliser dans votre essai.

Vous devez vous connecter pour publier un commentaire.