O exemplo neste artigo descreve o método de implementação de peso aleatório em Java. Compartilhe com todos para sua referência. A análise específica é a seguinte:
A ponderação aleatória é frequentemente usada em projetos, então abstraí-a em uma classe de ferramenta.
Geralmente, existem duas maneiras de implementar pesos aleatórios:
1. Use uma matriz para armazenar o alvo real correspondente ao peso. Por exemplo, o peso de A é 2 e o peso de B é 3. Então, o comprimento da matriz é 5. Os dois primeiros da matriz armazenam A e. as últimas três lojas B.
Em seguida, randomize um número [comprimento de dados 0) e obtenha diretamente o valor do subscrito correspondente da matriz.
Vantagens: estrutura de dados simples, algoritmo eficiente, implementação simples
Desvantagens: Quando o valor do peso é relativamente grande e há muitos dados, a memória será desperdiçada.
2. Use o algoritmo de intervalo, sobreponha os pesos da frente para trás, atribua aleatoriamente um número [soma de 1 peso] e, em seguida, use o peso aleatório para subtrair o peso de cada elemento por vez. igual a 0 são nossos elementos Find
Esta implementação pode pegar emprestado o método binarySearch de Arrays.
Clique aqui para baixar o código de exemplo completo.
Cole o código:
PesoMeta.java:
Copie o código do código da seguinte forma:/**
* Recomenda-se usar a classe RandomUtil para criar objetos RandomMeta
* @autor wxf em 14-5-5.
*/
classe pública PesoMeta<T> {
privado final aleatório executado = new Random();
nós T[] finais privados;
pesos int[] finais privados;
final privado int maxW;
public WeightMeta(T[] nós, int[] pesos) {
isto.nodes = nós;
this.weights = pesos;
this.maxW = pesos[pesos.comprimento - 1];
}
/**
* Este método retorna um objeto aleatório ponderado
* @retornar
*/
público T aleatório() {
índice int = Arrays.binarySearch(pesos, ran.nextInt(maxW) + 1);
se (índice <0) {
índice = -1 - índice;
}
nós de retorno[índice];
}
public T aleatório(int ranInt) {
if (ranInt > maxW) {
ranInt = maxW;
} senão if(ranInt < 0){
ranInt = 1;
} outro {
ranInt++;
}
índice int = Arrays.binarySearch(pesos, ranInt);
se (índice <0) {
índice = -1 - índice;
}
nós de retorno[índice];
}
@Substituir
string pública paraString() {
StringBuilder l1 = new StringBuilder();
StringBuilder l2 = new StringBuilder("[aleatório]/t");
StringBuilder l3 = new StringBuilder("[nó]/t/t");
l1.append(this.getClass().getName()).append(":").append(this.hashCode()).append(":/n").append("[index]/t/t ");
for (int i = 0; i < pesos.comprimento; i++) {
l1.append(i).append("/t");
l2.append(pesos[i]).append("/t");
l3.append(nodes[i]).append("/t");
}
l1.append("/n");
l2.append("/n");
l3.append("/n");
retornar l1.append(l2).append(l3).toString();
}
}
RandomUtil.java:
Copie o código do código da seguinte forma:/**
* Ferramentas aleatórias
*
* Use o mapa de coleção ponderado para construir um objeto de metadados aleatório
*
* por exemplo:
* Temos 3 endereços de URL, seus pesos são 1, 2 e 3. Agora usamos RandomUtil para obter aleatoriamente o URL com base no peso:
*
* <p><blockquote><pre>
*
* mapa.put(url1, 1);
* map.put(url2, 2);
* map.put(url3, 3);
* RandomMeta<String, Integer> md = RandomUtil.buildWeightMeta(mapa);
* String pesoRandomUrl = md.random();
*
* </pre></blockquote><p>
*
* @autor wxf em 14-5-5.
*/
classe pública RandomUtil {
public static <T> WeightMeta<T> buildWeightMeta(Mapa final<T, Integer> WeightMap) {
tamanho int final = pesoMap.size();
Objeto[] nós = novo Objeto[tamanho];
int[] pesos = new int[tamanho];
índice interno = 0;
int pesoAdder = 0;
for (Map.Entry<T, Integer> each:weightMap.entrySet()) {
nós[índice] = cada.getKey();
pesos[index++] = (weightAdder = pesoAdder + each.getValue());
}
retornar novos WeightMeta<T>((T[]) nós, pesos);
}
}
Espero que este artigo seja útil para a programação Java de todos.