Geralmente, amigos com alguma experiência em desenvolvimento podem realizar tal função, mas é apenas uma questão de eficiência. Quando normalmente enfrentamos esse problema, sempre pensamos nele em ordem simples. Primeiro, geramos uma matriz e, em seguida, adicionamos números aleatórios à matriz em um loop. Durante o processo de adição de números, primeiro verificamos se eles existem na matriz. . Se este número não existir, ele será adicionado diretamente ao array; se existir, não será adicionado. Geralmente pensamos sobre os problemas desta forma, e as funções podem ser alcançadas pensando desta forma. Como acabei de dizer, é apenas uma questão de eficiência.
Para entender melhor o significado desta questão, vejamos primeiro o conteúdo específico: gere um array aleatório de 1 a 100, mas os números do array não podem ser repetidos, ou seja, a posição é aleatória, mas os elementos do array não pode ser repetido. Aqui, o comprimento do array não é especificado para nós, podemos deixá-lo ter qualquer comprimento entre 1-100.
A seguir, vamos dar uma olhada em como implementá-lo melhor. Normalmente usaremos ArrayList para implementá-lo, conforme mostrado no código a seguir:
Copie o código do código da seguinte forma:
pacote cn.sunzn.randomnumber;
importar java.util.ArrayList;
importar java.util.Random;
demonstração de classe pública {
public static void main(String[] args) {
Valores do objeto[] = novo objeto[20];
Aleatório aleatório = new Aleatório();
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < valores.comprimento; i++) {
número interno = random.nextInt(100) + 1;
if (!list.contains(número)) {
lista.adicionar(número);
}
}
valores = list.toArray();
/************ Percorre o array e imprime os dados************/
for (int i = 0; i < valores.comprimento; i++) {
System.out.print(valores[i] + "/t");
se ((eu + 1)% 10 == 0) {
System.out.println("/n");
}
}
}
}
O processo de implementação acima é relativamente ineficiente. Porque toda vez que você adiciona, você tem que verificar se o número existe na lista atual, a complexidade de tempo é O (N ^ 2). Podemos pensar desta forma: como não envolve duplicação, podemos pensar nas funções de HashSet e HashMap. HashSet implementa a interface Set. A definição matemática de Set é uma coleção sem duplicação e ordem. HashMap implementa Map e não permite chaves duplicadas. Desta forma, podemos usar HashMap ou HashSet para conseguir isso.
Ao usar HashMap para implementá-lo, você só precisa converter sua chave em um array. O código é o seguinte:
Copie o código do código da seguinte forma:
pacote cn.sunzn.randomnumber;
importar java.util.HashMap;
importar java.util.Random;
demonstração de classe pública {
public static void main(String[] args) {
Valores do objeto[] = novo objeto[20];
Aleatório aleatório = new Aleatório();
HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
/******* Gera números aleatórios e armazena-os no HashMap *******/
for (int i = 0; i < valores.comprimento; i++) {
número interno = random.nextInt(100) + 1;
hashMap.put(número, i);
}
/************ Importar array do HashMap************/
valores = hashMap.keySet().toArray();
/*********** Percorre o array e imprime os dados*************/
for (int i = 0; i < valores.comprimento; i++) {
System.out.print(valores[i] + "/t");
se ((eu + 1)% 10 == 0) {
System.out.println("/n");
}
}
}
}
Como o relacionamento entre HashSet e HashMap é muito próximo, HashSet é implementado usando HashMap na camada inferior. No entanto, não há coleção de valores, apenas uma coleção de chaves, portanto também pode ser implementado usando HashSet. :
Copie o código do código da seguinte forma:
pacote cn.sunzn.randomnumber;
importar java.util.HashSet;
importar java.util.Random;
demonstração de classe pública {
public static void main(String[] args) {
Aleatório aleatório = new Aleatório();
Valores do objeto[] = novo objeto[20];
HashSet<Integer> hashSet = new HashSet<Integer>();
/******* Gera números aleatórios e armazena-os no HashSet *******/
for (int i = 0; i < valores.comprimento; i++) {
número interno = random.nextInt(100) + 1;
hashSet.add(número);
}
valores=hashSet.toArray();
/************* Percorre o array e imprime os dados**********/
for (int i = 0; i < valores.comprimento; i++) {
System.out.print(valores[i] + "/t");
se ((eu + 1)% 10 == 0) {
System.out.println("/n");
}
}
}
}
Esta implementação é um pouco mais eficiente. Se limitarmos o comprimento do array, precisaremos apenas alterar o loop for e configurá-lo para um loop whlie. Conforme mostrado abaixo:
Copie o código do código da seguinte forma:
pacote cn.sunzn.randomnumber;
importar java.util.HashSet;
importar java.util.Random;
demonstração de classe pública {
public static void main(String[] args) {
Aleatório aleatório = new Aleatório();
Valores do objeto[] = novo objeto[20];
HashSet<Integer> hashSet = new HashSet<Integer>();
/****** Gere números aleatórios e armazene-os em HashSet ******/
while (hashSet.size() <valores.length) {
hashSet.add(random.nextInt(100) + 1);
}
valores=hashSet.toArray();
/************ Percorre o array e imprime os dados************/
for (int i = 0; i < valores.comprimento; i++) {
System.out.print(valores[i] + "/t");
se ((eu + 1)% 10 == 0) {
System.out.println("/n");
}
}
}
}