Das Beispiel in diesem Artikel beschreibt die Implementierungsmethode der Zufallsgewichtung in Java. Teilen Sie es als Referenz mit allen. Die spezifische Analyse lautet wie folgt:
In Projekten wird häufig eine zufällige Gewichtung verwendet, daher habe ich sie in eine Toolklasse abstrahiert.
Es gibt im Allgemeinen zwei Möglichkeiten, Zufallsgewichte zu implementieren:
1. Verwenden Sie ein Array, um das tatsächliche Ziel zu speichern, das dem Gewicht entspricht. Beispielsweise beträgt das Gewicht von A 2 und das Gewicht von B 3. Dann beträgt die Länge des Arrays 5. Die ersten beiden des Arrays speichern A und die letzten drei speichern B.
Dann randomisieren Sie eine Zahl [0-Datenlänge] und nehmen Sie direkt den Wert des entsprechenden Index des Arrays.
Vorteile: einfache Datenstruktur, effizienter Algorithmus, einfache Implementierung
Nachteile: Wenn der Gewichtswert relativ groß ist und viele Daten vorhanden sind, wird Speicher verschwendet.
2. Verwenden Sie den Intervallalgorithmus, überlagern Sie die Gewichte von vorne nach hinten, weisen Sie dann zufällig eine Zahl [1-Gewichtssumme] zu und subtrahieren Sie dann nacheinander das Gewicht jedes Elements mit dem Zufallsgewicht gleich 0 ist unser Suchelement
Diese Implementierung kann die Methode „binarySearch“ von Arrays ausleihen.
Klicken Sie hier, um den vollständigen Beispielcode herunterzuladen.
Fügen Sie den Code ein:
WeightMeta.java:
Kopieren Sie den Codecode wie folgt:/**
* Es wird empfohlen, die RandomUtil-Klasse zum Erstellen von RandomMeta-Objekten zu verwenden
* @author wxf am 14.5.5.
*/
öffentliche Klasse WeightMeta<T> {
private final Random ran = new Random();
private finale T[]-Knoten;
private final int[] Gewichte;
private final int maxW;
public WeightMeta(T[] nodes, int[]weights) {
this.nodes = Knoten;
this.weights = Gewichte;
this.maxW = Gewichte[Gewichte.Länge - 1];
}
/**
* Diese Methode gibt ein gewichtetes Zufallsobjekt zurück
* @zurückkehren
*/
öffentliches T random() {
int index = Arrays.binarySearch(weights, ran.nextInt(maxW) + 1);
if (index < 0) {
Index = -1 - Index;
}
return nodes[index];
}
public T random(int ranInt) {
if (ranInt > maxW) {
ranInt = maxW;
} else if(ranInt < 0){
ranInt = 1;
} anders {
ranInt++;
}
int index = Arrays.binarySearch(weights, ranInt);
if (index < 0) {
Index = -1 - Index;
}
return nodes[index];
}
@Override
öffentlicher String toString() {
StringBuilder l1 = new StringBuilder();
StringBuilder l2 = new StringBuilder("[random]/t");
StringBuilder l3 = new StringBuilder("[node]/t/t");
l1.append(this.getClass().getName()).append(":").append(this.hashCode()).append(":/n").append("[index]/t/t ");
for (int i = 0; i <weights.length; i++) {
l1.append(i).append("/t");
l2.append(weights[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:
Kopieren Sie den Codecode wie folgt:/**
* Zufällige Werkzeuge
*
* Verwenden Sie die gewichtete Sammlungskarte, um ein zufälliges Metadatenobjekt zu erstellen
*
* Zum Beispiel:
* Wir haben 3 URL-Adressen, ihre Gewichtungen sind 1, 2 und 3. Jetzt verwenden wir RandomUtil, um die URL basierend auf dem Gewicht zufällig zu erhalten:
*
* <p><blockquote><pre>
*
* map.put(url1, 1);
* map.put(url2, 2);
* map.put(url3, 3);
* RandomMeta<String, Integer> md = RandomUtil.buildWeightMeta(map);
* StringweightRandomUrl = md.random();
*
* </pre></blockquote><p>
*
* @author wxf am 14.5.5.
*/
öffentliche Klasse RandomUtil {
public static <T> WeightMeta<T> buildWeightMeta(final Map<T, Integer>weightMap) {
final int size =weightMap.size();
Object[] nodes = new Object[size];
int[]weights = new int[size];
int index = 0;
int WeightAdder = 0;
for (Map.Entry<T, Integer> Each :weightMap.entrySet()) {
nodes[index] = every.getKey();
Gewichte[index++] = (weightAdder = WeightAdder + every.getValue());
}
return new WeightMeta<T>((T[]) nodes,weights);
}
}
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.