Este artigo apresentará a você como implementar a função da aleatória, sem números repetitivos no Java. Se você é iniciante, é necessário ler este artigo, porque esse recurso geralmente será encontrado durante as entrevistas. Incluindo quando recruto pessoas, também gosto de perguntar aos outros sobre essa pergunta, principalmente para ver como o modelo e o conhecimento básico do problema são considerados.
Espero que este artigo possa ajudar amigos que estão em contato pela primeira vez, porque entrei em contato com alguns amigos que não podem escrever ou usar uma maneira muito plana de pensar para alcançá -lo.
Geralmente, amigos de alguma experiência de desenvolvimento podem implementar essas funções, mas é apenas uma questão de eficiência. Quando enfrentamos esses problemas, sempre pensamos nisso em uma ordem direta e, em seguida, adicionamos números aleatórios à matriz em um loop. No processo de adição de números, primeiro procure se esse número existe na matriz. Se esse número não existir, ele será adicionado diretamente à matriz; Se esse número existir, não será adicionado. Geralmente consideramos o problema dessa maneira e podemos implementar funções dessa maneira. Como eu disse agora, é apenas uma questão de eficiência.
Para entender melhor o significado desta questão, vamos primeiro olhar para o conteúdo específico: gerar uma matriz aleatória de 1 a 100, mas os números na matriz não podem ser repetidos, ou seja, as posições são aleatórias, mas os elementos da matriz não podem ser repetidos.
Aqui, não especificamos o comprimento da matriz, podemos fazer qualquer comprimento entre 1-100.
Em seguida, vamos dar uma olhada em vários métodos de implementação e comparar esses métodos .
Normalmente, usaremos o ArrayList ou o Array para implementá -lo. Vamos primeiro olhar para o processo de implementação do ArrayList, conforme mostrado no código a seguir:
importar java.util.ArrayList; importar java.util.random;/** * implementação usando ArrayList * @Description: * @File: Demo.java * @package nenhum * @author hanyonglu * @date 2012-10-18 06:16:55 @Author Demonsts V1.0 * @Date 2012-10-18 06:16:16:55 Pm *version Objeto [] valores = novo objeto [20]; Aleatório aleatório = novo aleatório (); ArrayList <Teger> list = new ArrayList <Teger> (); for (int i = 0; i <valores.length; i ++) {int number = aleatom.nextInt (100)+1; if (! list.contains (número)) {list.add (número); }} valores = list.toarray (); // atravessa a matriz e imprima os dados para (int i = 0; i <valores.length; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} O processo de implementação do uso de matrizes é o seguinte:
importar java.util.random;/** * Implementação usando matrizes * @Description: * @File: Demo4.java * @package nenhum * @author hanyonglu * @date 2012-10-18 06:27:38 Aleatório aleatório = novo aleatório (); for (int i = 0; i <valores.length; i ++) {int number = aleatom.nextInt (100)+1; for (int j = 0; j <= i; j ++) {if (número! = valores [j]) {valores [i] = número; }}} // atravessa a matriz e imprima os dados para (int i = 0; i <valores.length; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Os dois processos de implementação acima são relativamente ineficientes. Como toda vez que você adiciona, você precisa atravessar se esse número existe na lista atual, a complexidade do tempo é O (n^2). Podemos pensar da seguinte maneira: como não há duplicação envolvida, podemos pensar nas funções de Hashset e Hashmap. O hashset implementa a interface definida e a definição matemática de conjunto é um conjunto sem duplicação e ordem. HashMap implementa mapa e também é uma chave que não permite duplicatas. Dessa forma, podemos usar hashmap ou hashset para alcançá -lo.
Ao usar a implementação do Hashmap, você só precisa converter sua chave em uma matriz e tudo bem, como segue:
importar java.util.hashmap; importar java.util.iterator; importar java.util.random; importar java.util.map.entry;/** * implementação usando hashmap * @description: * @File: Demo.Java * @Package NOTE * @Author HanyonGluNenkLUTE *d *d *d *d1111111 @mankluenate * @file *d *d11111 @manyate *d11 @manyate * @file *d111111 @manklenate * @File *d *d1111111 @mankluenate * @file *d *d11111 @manklue: * @file * @filate *d11 @packate * @Author HanyOngLaTe: V1.0 */public class Demo {public static void main (string [] args) {int n = 0; Objeto [] valores = novo objeto [20]; Aleatório aleatório = novo aleatório (); Hashmap <objeto, objeto> hashmap = new hashmap <object, object> (); // gera números aleatórios e armazenar hashmap para (int i = 0; i <valores.length; i ++) {int number = aleatom.nextInt (100)+1; hashmap.put (número, i); } // Importar valores da matriz de hashmap valores = hashmap.keyset (). ToArray (); // atravessa a matriz e imprima dados para (int i = 0; i <valores.length; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }} // iterator iter = hashmap.entryset (). Iterator (); // // traversal hashmap // while (iter.hasnext ()) {// entradas <integ.get.get.gerge> entrada = (entrada) iter.next (); "/t"); // // if (n % 10 == 0) {// System.out.println ("/n"); //} //}}} Como a relação entre hashset e hashmap está muito próxima, o hashset é implementado usando o hashmap na parte inferior, mas não há coleção de valor e apenas uma coleção de chaves, para que também possa ser implementada usando hashset, como segue:
importar java.util.hashset; importar java.util.random;/** * Implementação usando hashset * @Description: * @File: test.java * @package nenhum * @author hanyonglu-fgum * @date 2012-10-18 06:11:41 pm * @version v1.0 */publicsty @Date 2012-10-18 06:11:41 pm * @version v1.0 * Aleatório(); Objeto [] valores = novo objeto [20]; HASHSET <TEGER> hashSet = new HashSet <Teger> (); // gera números aleatórios e armazenar hashset para (int i = 0; i <valores.length; i ++) {int number = aleatom.nextInt (100)+1; hashset.add (número); } valores = hashset.toArray (); // atravessa a matriz e imprima dados para (int i = 0; i <valores.length; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Isso é um pouco mais eficiente. Se limitarmos o comprimento da matriz, precisamos apenas transformar o loop for e configurá -lo em um loop whlie. Como mostrado abaixo:
importar java.util.hashset; importar java.util.random;/** * Implementação usando hashset * @Description: * @File: test.java * @package nenhum * @author hanyonglu * @date 2012-10-18 05:11:41 pm * @version v1.0 */publicsty @Date 2012-10-18 05:11:41 pm * @version v1.0 */ Aleatório(); Objeto [] valores = novo objeto [20]; HASHSET <TEGER> hashSet = new HashSet <Teger> (); // gera números aleatórios e armazenar hashset while (hashset.size () <valores.length) {hashset.add (random.nextint (100) + 1); } valores = hashset.toArray (); // atravessa a matriz e imprima os dados para (int i = 0; i <valores.length; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}}Podemos definir o comprimento da matriz como 100 e verificar o efeito em execução, como mostrado na figura abaixo:
Comparado com o acima, o uso de hashmap é relativamente eficiente. De fato, é um hashset, uma matriz e, finalmente, um Arraylist. Se gerarmos 10000 dados, descobriremos que o uso do hashmap leva tempo: 0,05s, o hashset é de 0,07s, a matriz é de 0,20s e o Arraylist é de 0,25s. Se você estiver interessado, pode definir a hora de conferir.
Obviamente, além de usar a implementação do hashmap, existem outros métodos eficientes. Por exemplo, podemos armazenar números 1-100 em uma matriz e, em seguida, gerar aleatoriamente dois subscritos no loop for. Se esses dois subscritos não forem iguais, podemos trocar elementos na matriz. O processo de implementação é o seguinte:
importar java.util.random;/** * Implementação de conversão de posição aleatória * @Description: * @File: Demo4.java * @package nenhum * @author hanyonglu * @date 2012-10-18 06:54:06 int temp1, temp2, temp3; Aleatório r = novo aleatório (); for (int i = 0; i <valores.Length; i ++) {valores [i] = i+1; } // troca aleatoriamente valores. // gerar aleatoriamente uma posição temp2 = math.abs (r.NextInt ()) % (valores.length-1); // gerar aleatoriamente outra posição se (temp1! = Temp2) {temp3 = valores [temp1]; valores [temp1] = valores [temp2]; valores [temp2] = temp3; }} // Atravesse a matriz e imprima os dados (int i = 0; i <20; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Este método também é relativamente eficiente. Se 10.000 dados forem gerados, o tempo que leva é de 0,054s.
Com base na implementação de coordenadas em uma matriz, mais soluções relacionadas podem ser transformadas e você pode se referir a informações relevantes em detalhes.
O exposto acima é sobre a implementação da função de números aleatórios e nãopetitivos em Java. Obviamente, os métodos não se limitam a esses tipos, mas existem outros métodos de implementação. Espero que seja útil para os amigos que estão em contato há um tempo, e espero que isso possa desempenhar um papel na atraição e na atração de Jade.
Site original: http://www.cnblogs.com/hanyonglu/archive/2012/10/18/2730007.html
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.