Generalmente, los amigos con cierta experiencia en desarrollo pueden realizar dicha función, pero es solo una cuestión de eficiencia. Cuando nos enfrentamos a un problema de este tipo, siempre lo pensamos en orden plano. Primero, generamos una matriz y luego agregamos números aleatorios a la matriz en un bucle. Durante el proceso de sumar números, primero verificamos si existen en la matriz. Si este número no existe, se agregará directamente a la matriz; si existe, no se agregará. Generalmente pensamos en los problemas de esta manera y se pueden lograr funciones pensando de esta manera. Como acabo de decir, es solo una cuestión de eficiencia.
Para comprender mejor el significado de esta pregunta, primero veamos el contenido específico: genere una matriz aleatoria del 1 al 100, pero los números en la matriz no se pueden repetir, es decir, la posición es aleatoria, pero los elementos de la matriz no se puede repetir. Aquí, la longitud de la matriz no está especificada para nosotros, podemos dejar que tenga cualquier longitud entre 1 y 100.
A continuación, echemos un vistazo a cómo implementarlo mejor. Generalmente usaremos ArrayList para implementarlo, como se muestra en el siguiente código:
Copie el código de código de la siguiente manera:
paquete cn.sunzn.randomnumber;
importar java.util.ArrayList;
importar java.util.Random;
Demostración de clase pública {
público estático vacío principal (String [] argumentos) {
Valores de objeto [] = nuevo objeto [20];
Aleatorio aleatorio = nuevo Aleatorio();
ArrayList<Integer> lista = nueva ArrayList<Integer>();
for (int i = 0; i < valores.longitud; i++) {
número int = aleatorio.nextInt(100) + 1;
if (!lista.contiene(número)) {
lista.add(número);
}
}
valores = lista.toArray();
/************ Recorre la matriz e imprime los datos************/
for (int i = 0; i < valores.longitud; i++) {
System.out.print(valores[i] + "/t");
si ((yo + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
El proceso de implementación anterior es relativamente ineficiente. Debido a que cada vez que lo agrega, debe verificar si el número existe en la lista actual, la complejidad del tiempo es O (N ^ 2). Podemos pensarlo de esta manera: dado que no implica duplicación, podemos pensar en las funciones de HashSet y HashMap. HashSet implementa la interfaz Set. La definición matemática de Set es una colección sin duplicación ni orden. HashMap implementa Map y no permite claves duplicadas. De esta forma podemos usar HashMap o HashSet para lograr esto.
Cuando use HashMap para implementarlo, solo necesita convertir su clave en una matriz. El código es el siguiente:
Copie el código de código de la siguiente manera:
paquete cn.sunzn.randomnumber;
importar java.util.HashMap;
importar java.util.Random;
Demostración de clase pública {
público estático vacío principal (String [] argumentos) {
Valores de objeto [] = nuevo objeto [20];
Aleatorio aleatorio = nuevo Aleatorio();
HashMap<Objeto, Objeto> hashMap = nuevo HashMap<Objeto, Objeto>();
/******* Genera números aleatorios y guárdalos en HashMap *******/
for (int i = 0; i < valores.longitud; i++) {
número int = aleatorio.nextInt(100) + 1;
hashMap.put(número, i);
}
/************ Importar matriz desde HashMap************/
valores = hashMap.keySet().toArray();
/************ Recorre la matriz e imprime los datos **************/
for (int i = 0; i < valores.longitud; i++) {
System.out.print(valores[i] + "/t");
si ((yo + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Dado que la relación entre HashSet y HashMap es demasiado estrecha, HashSet se implementa usando HashMap en la capa inferior. Sin embargo, no hay una colección de Valores, solo una colección de Claves, por lo que también se puede implementar usando HashSet. :
Copie el código de código de la siguiente manera:
paquete cn.sunzn.randomnumber;
importar java.util.HashSet;
importar java.util.Random;
Demostración de clase pública {
público estático vacío principal (String [] argumentos) {
Aleatorio aleatorio = nuevo Aleatorio();
Valores de objeto [] = nuevo objeto [20];
HashSet<Integer> hashSet = nuevo HashSet<Integer>();
/******* Genera números aleatorios y guárdalos en HashSet *******/
for (int i = 0; i < valores.longitud; i++) {
número int = aleatorio.nextInt(100) + 1;
hashSet.add(número);
}
valores = hashSet.toArray();
/************* Recorre la matriz e imprime los datos**********/
for (int i = 0; i < valores.longitud; i++) {
System.out.print(valores[i] + "/t");
si ((yo + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Esta implementación es ligeramente más eficiente. Si limitamos la longitud de la matriz, solo necesitamos cambiar el bucle for y configurarlo como un bucle whlie. Como se muestra a continuación:
Copie el código de código de la siguiente manera:
paquete cn.sunzn.randomnumber;
importar java.util.HashSet;
importar java.util.Random;
Demostración de clase pública {
público estático vacío principal (String [] argumentos) {
Aleatorio aleatorio = nuevo Aleatorio();
Valores de objeto [] = nuevo objeto [20];
HashSet<Integer> hashSet = nuevo HashSet<Integer>();
/****** Genera números aleatorios y guárdalos en HashSet ******/
mientras (hashSet.size() <valores.longitud) {
hashSet.add(random.nextInt(100) + 1);
}
valores = hashSet.toArray();
/************ Recorre la matriz e imprime los datos************/
for (int i = 0; i < valores.longitud; i++) {
System.out.print(valores[i] + "/t");
si ((yo + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}