El ejemplo de este artículo describe el método de implementación de peso aleatorio en Java. Compártelo con todos para tu referencia. El análisis específico es el siguiente:
La ponderación aleatoria se usa a menudo en proyectos, así que la resumí en una clase de herramienta.
Generalmente hay dos formas de implementar pesos aleatorios:
1. Utilice una matriz para almacenar el objetivo real correspondiente al peso. Por ejemplo, el peso de A es 2 y el peso de B es 3. Entonces la longitud de la matriz es 5. Los dos primeros de la matriz almacenan A y. las tres últimas tienda B.
Luego, aleatorice un número [longitud de datos 0) y tome directamente el valor del subíndice correspondiente de la matriz.
Ventajas: estructura de datos simple, algoritmo eficiente, implementación simple
Desventajas: cuando el valor de peso es relativamente grande y hay muchos datos, se desperdiciará memoria.
2. Utilice el algoritmo de intervalo, superponga los pesos de adelante hacia atrás, luego asigne aleatoriamente un número [suma de 1 peso] y luego use el peso aleatorio para restar el peso de cada elemento por turno cuando el primer elemento sea menor que o. igual a 0 es nuestra búsqueda de elementos
Esta implementación puede tomar prestado el método binarioSearch de Arrays.
Haga clic aquí para descargar el código de ejemplo completo.
Pega el código:
PesoMeta.java:
Copie el código de código de la siguiente manera:/**
* Se recomienda utilizar la clase RandomUtil para crear objetos RandomMeta
* @author wxf el 14-5-5.
*/
clase pública PesoMeta<T> {
ejecución aleatoria final privada = nueva aleatoria ();
nodos T[] finales privados;
pesos int[] finales privados;
privado final int maxW;
Peso públicoMeta(T[] nodos, int[] pesos) {
this.nodes = nodos;
this.pesos = pesos;
this.maxW = pesos[pesos.longitud - 1];
}
/**
* Este método devuelve un objeto aleatorio ponderado.
* @devolver
*/
público T aleatorio() {
int index = Arrays.binarySearch(pesos, ran.nextInt(maxW) + 1);
si (índice < 0) {
índice = -1 - índice;
}
nodos de retorno [índice];
}
público T aleatorio (int ranInt) {
si (ranInt > maxW) {
ranInt = máxW;
} si no (ranInt < 0){
ranInt = 1;
} demás {
corrióInt++;
}
int index = Arrays.binarySearch(pesos, ranInt);
si (índice < 0) {
índice = -1 - índice;
}
nodos de retorno [índice];
}
@Anular
cadena pública toString() {
StringBuilder l1 = nuevo StringBuilder();
StringBuilder l2 = new StringBuilder("[aleatorio]/t");
StringBuilder l3 = nuevo StringBuilder("[nodo]/t/t");
l1.append(this.getClass().getName()).append(":").append(this.hashCode()).append(":/n").append("[índice]/t/t ");
for (int i = 0; i < pesos.longitud; i++) {
l1.append(i).append("/t");
l2.append(pesos[i]).append("/t");
l3.append(nodos[i]).append("/t");
}
l1.append("/n");
l2.append("/n");
l3.append("/n");
devolver l1.append(l2).append(l3).toString();
}
}
RandomUtil.java:
Copie el código de código de la siguiente manera:/**
* Herramientas aleatorias
*
* Utilice el mapa de colección ponderado para construir un objeto de metadatos aleatorio
*
* Por ejemplo:
* Tenemos 3 direcciones URL, sus pesos son 1, 2 y 3. Ahora usamos RandomUtil para obtener aleatoriamente la URL según el peso:
*
* <p><blockquote><pre>
*
* mapa.put(url1, 1);
* mapa.put(url2, 2);
* mapa.put(url3, 3);
* RandomMeta<Cadena, Entero> md = RandomUtil.buildWeightMeta(mapa);
* Peso de cadenaRandomUrl = md.random();
*
* </pre></blockquote><p>
*
* @author wxf el 14-5-5.
*/
clase pública RandomUtil {
público estático <T> WeightMeta<T> buildWeightMeta(Mapa final<T, Integer> WeightMap) {
tamaño int final = pesoMap.size();
Objeto[] nodos = nuevo Objeto[tamaño];
int[] pesos = nuevo int[tamaño];
índice int = 0;
int pesoAdder = 0;
para (Map.Entry<T, Integer> cada uno: pesoMap.entrySet()) {
nodos[índice] = cada.getKey();
pesos[índice++] = (pesoAdder = pesoAdder + each.getValue());
}
devolver nuevos WeightMeta<T>((T[]) nodos, pesos);
}
}
Espero que este artículo sea útil para la programación Java de todos.