L'exemple de cet article décrit la méthode d'implémentation du poids aléatoire en Java. Partagez-le avec tout le monde pour votre référence. L’analyse spécifique est la suivante :
La pondération aléatoire est souvent utilisée dans les projets, je l'ai donc résumée dans une classe d'outils.
Il existe généralement deux manières d’implémenter des poids aléatoires :
1. Utilisez un tableau pour stocker la cible réelle correspondant au poids. Par exemple, le poids de A est de 2 et le poids de B est de 3. La longueur du tableau est alors de 5. Les deux premiers du tableau stockent A et. les trois derniers magasins B.
Ensuite, randomisez un nombre [0-longueur des données) et prenez directement la valeur de l'indice correspondant du tableau.
Avantages : structure de données simple, algorithme efficace, mise en œuvre simple
Inconvénients : Lorsque la valeur de poids est relativement importante et qu'il y a beaucoup de données, la mémoire sera gaspillée.
2. Utilisez l'algorithme d'intervalle, superposez les poids d'avant en arrière, puis attribuez au hasard un nombre [somme de 1 poids], puis utilisez le poids aléatoire pour soustraire tour à tour le poids de chaque élément lorsque le premier élément est inférieur à ou. égal à 0 est notre recherche d'éléments
Cette implémentation peut emprunter la méthode binaireSearch de Arrays.
Cliquez ici pour télécharger l'exemple de code complet.
Collez le code :
WeightMeta.java :
Copiez le code comme suit :/**
* Il est recommandé d'utiliser la classe RandomUtil pour créer des objets RandomMeta
* @auteur wxf le 14-5-5.
*/
classe publique WeightMeta<T> {
private final Random run = new Random();
nœuds T[] finaux privés ;
poids int[] finaux privés ;
privé final int maxW ;
public WeightMeta (nœuds T[], poids int[]) {
this.nodes = nœuds ;
this.weights = poids ;
this.maxW = poids[poids.longueur - 1] ;
}
/**
* Cette méthode renvoie un objet aléatoire pondéré
* @retour
*/
public T aléatoire() {
int index = Arrays.binarySearch(weights, ran.nextInt(maxW) + 1);
si (indice < 0) {
indice = -1 - indice ;
}
renvoyer les nœuds[index] ;
}
public T aléatoire (int ranInt) {
si (ranInt > maxW) {
ranInt = maxW;
} sinon si(ranInt < 0){
ranInt = 1 ;
} autre {
ranInt++;
}
int index = Arrays.binarySearch(weights, ranInt);
si (indice < 0) {
indice = -1 - indice ;
}
renvoyer les nœuds[index] ;
}
@Outrepasser
chaîne publique versChaîne() {
StringBuilder l1 = nouveau StringBuilder();
StringBuilder l2 = new StringBuilder("[aléatoire]/t");
StringBuilder l3 = new StringBuilder("[noeud]/t/t");
l1.append(this.getClass().getName()).append(":").append(this.hashCode()).append(":/n").append("[index]/t/t ");
pour (int i = 0; i < poids.longueur; i++) {
l1.append(i).append("/t");
l2.append(poids[i]).append("/t");
l3.append(nodes[i]).append("/t");
}
l1.append("/n");
l2.append("/n");
l3.append("/n");
return l1.append(l2).append(l3).toString();
}
}
RandomUtil.java :
Copiez le code comme suit :/**
* Outils aléatoires
*
* Utilisez la carte de collection pondérée pour construire un objet de métadonnées aléatoire
*
* Par exemple:
* Nous avons 3 adresses URL, leurs poids sont 1, 2 et 3. Nous utilisons maintenant RandomUtil pour obtenir aléatoirement l'URL en fonction du poids :
*
* <p><blockquote><pre>
*
* map.put(url1, 1);
* map.put(url2, 2);
* map.put(url3, 3);
* RandomMeta<String, Integer> md = RandomUtil.buildWeightMeta(map);
* ChaîneweightRandomUrl = md.random();
*
* </pre></blockquote><p>
*
* @author wxf le 14-5-5.
*/
classe publique RandomUtil {
public static <T> WeightMeta<T> buildWeightMeta(final Map<T, Integer>weightMap) {
final int size = poidsMap.size();
Noeuds Object[] = new Object[size];
int[] poids = new int[size];
indice int = 0 ;
int poidsAdder = 0 ;
for (Map.Entry<T, Integer> each :weightMap.entrySet()) {
nœuds[index] = each.getKey();
poids[index++] = (weightAdder = poidsAdder + each.getValue());
}
renvoie de nouveaux nœuds WeightMeta<T>((T[]) nœuds, poids);
}
}
J'espère que cet article sera utile à la programmation Java de chacun.