Este artículo le presentará cómo implementar la función de números aleatorios y repetitivos en Java. Si usted es un principiante, es necesario leer este artículo, porque esta característica generalmente se encontrará durante las entrevistas. Incluso cuando reclute personas, también me gusta hacer a otros sobre esta pregunta, principalmente para ver cómo se consideran el modelo y el conocimiento básico del problema.
Espero que este artículo pueda ayudar a los amigos que están en contacto por primera vez, porque he contactado a algunos amigos que no pueden escribirlo o usar una forma de pensar muy plana para lograrlo.
En general, los amigos con cierta experiencia en desarrollo pueden implementar tales funciones, pero es solo una cuestión de eficiencia. Cuando enfrentamos tales problemas, siempre lo pensamos en un orden recto y luego agregamos números aleatorios a la matriz en un bucle. En el proceso de agregar números, primero busque si este número existe en la matriz. Si este número no existe, se agregará directamente a la matriz; Si este número existe, no se agregará. Por lo general, consideramos el problema de esta manera, y podemos implementar funciones de esta manera. Como dije ahora, es solo una cuestión de eficiencia.
Para comprender mejor el significado de esta pregunta, veamos primero el contenido específico: generar una matriz aleatoria de 1-100, pero los números en la matriz no se pueden repetir, es decir, las posiciones son aleatorias, pero los elementos de la matriz no se pueden repetir.
Aquí, no hemos especificado la longitud de la matriz, podemos hacer una longitud entre 1 y 100.
A continuación, echemos un vistazo a varios métodos de implementación y comparemos estos métodos .
Por lo general, usaremos ArrayList o Array para implementarlo. Primero veamos el proceso de implementación de ArrayList, como se muestra en el siguiente código:
import java.util.arrayList; import java.util.random;/** * Implementación usando ArrayList * @Description: * @File: Demo.Java * @Package Ninguno * @Author HanyongLu * @Date 2012-10-18 06:16:55 PM * @version v1.0 */Public Class {Public static. Objeto [] valores = nuevo objeto [20]; Aleatorio aleatorio = new Random (); ArrayList <Integer> list = new ArrayList <Integer> (); for (int i = 0; i <valores.length; i ++) {int number = random.nextint (100)+1; if (! list.contains (número)) {list.add (número); }} valores = list.toarray (); // atraviesa la matriz e imprime los datos para (int i = 0; i <valores.length; i ++) {system.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} El proceso de implementación del uso de matrices es el siguiente:
import java.util.random;/** * Implementación usando matrices * @Description: * @file: Demo4.java * @Package Ninguno * @Author Hanyonglu * @Date 2012-10-18 06:27:38 PM * @version v1.0 */public class Demo4 {Public Static Void Main (String [] [] Args) {INT INT [] valores [20]; Aleatorio aleatorio = new Random (); for (int i = 0; i <valores.length; i ++) {int number = random.nextint (100)+1; for (int j = 0; j <= i; j ++) {if (número! = valores [j]) {valores [i] = number; }}} // atraviesa la matriz e imprime los datos para (int i = 0; i <valores.length; i ++) {system.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Los dos procesos de implementación anteriores son relativamente ineficientes. Debido a que cada vez que agrega, debe atravesar si este número existe en la lista actual, la complejidad del tiempo es O (n^2). Podemos pensar en ello de esta manera: dado que no hay duplicación involucrada, podemos pensar en las funciones de Hashset y Hashmap. Hashset implementa la interfaz SET, y la definición matemática de SET es un conjunto sin duplicación y orden. Hashmap implementa el mapa, y también es una clave que no permite duplicados. De esta manera, podemos usar hashmap o hashset para lograrlo.
Al usar la implementación de HashMap, solo necesita convertir su clave en una matriz y estará bien, como sigue:
import java.util.hashmap; import java.util.iterator; import java.util.random; import java.util.map.entry;/** * Implementación con hashmap * @Description: * @file: delo.Java * @package Ninguno * V1.0 */public class Demo {public static void main (string [] args) {int n = 0; Objeto [] valores = nuevo objeto [20]; Aleatorio aleatorio = new Random (); Hashmap <objeto, objeto> hashmap = nuevo hashmap <objeto, objeto> (); // Generar números aleatorios y almacenar hashmap para (int i = 0; i <valores.length; i ++) {int number = random.nextint (100)+1; hashmap.put (número, i); } // Importar valores de matriz de valores hashmap = hashmap.keyset (). ToArray (); // atraviesa la matriz e imprime los datos 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 ()) {// entry <integer, enteger> entry = (entry) iter.next (); // int key = entry.getkey (); // n ++; // // // System.out.out (key+key+Key+ "/t"); // // if (n % 10 == 0) {// system.out.println ("/n"); //} //}}} Dado que la relación entre hashset y hashmap es demasiado cercana, hashset se implementa usando hashmap en la parte inferior, pero no hay una colección de valor y solo una colección de claves, por lo que también se puede implementar usando hashset, como sigue:
import java.util.hashset; import java.util.random;/** * Implementación usando hashset * @Description: * @file: test.java * @package ninguno * @author hanyonglu * @date 2012-10-18 06:11:41 pm * @version v1.0 */public class test {public static void main (string (string [] stats [] strat [] Aleatorio(); Objeto [] valores = nuevo objeto [20]; Hashset <integer> hashset = new Hashset <Integer> (); // Generar números aleatorios y almacenar hashset para (int i = 0; i <valores.length; i ++) {int number = random.nextint (100)+1; hashset.add (número); } valores = hashset.toarray (); // atraviesa la matriz e imprime los datos para (int i = 0; i <valores.length; i ++) {system.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Esto es un poco más eficiente. Si hemos limitado la longitud de la matriz, solo necesitamos transformar el bucle for y establecerlo en un bucle WHLIE. Como se muestra a continuación:
import java.util.hashset; import java.util.random;/** * Implementación usando hashset * @Description: * @file: test.java * @package ninguno * @author hanyonglu * @date 2012-10-18 05:11:41 pm * @version v1.0 */public class test {public static void main (string (string (string] {] Aleatorio(); Objeto [] valores = nuevo objeto [20]; Hashset <integer> hashset = new Hashset <Integer> (); // Generar números aleatorios y almacenar hashset mientras (hashset.size () <valores.length) {hashset.add (random.nextint (100) + 1); } valores = hashset.toarray (); // atraviesa la matriz e imprime los datos para (int i = 0; i <valores.length; i ++) {system.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}}Podemos establecer la longitud de la matriz en 100 y verificar el efecto de ejecución como se muestra en la figura a continuación:
En comparación con lo anterior, el uso de hashmap es relativamente eficiente. De hecho, es un hashset, una matriz y finalmente una lista de matrices. Si generamos 10000 datos, encontraremos que usar HashMap lleva tiempo: 0.05s, el hashset es 0.07S, la matriz es de 0.20s y ArrayList es 0.25s. Si está interesado, puede establecer el tiempo para verlo.
Por supuesto, además de usar la implementación de HashMap, existen otros métodos eficientes. Por ejemplo, podemos almacenar los números 1-100 en una matriz y luego generar aleatoriamente dos subíndices en el bucle for. Si estos dos subíndices no son iguales, podemos intercambiar elementos en la matriz. El proceso de implementación es el siguiente:
Import java.util.random;/** * Implementación de conversión de posición aleatoria * @Description: * @file: Demo4.java * @Package Ninguno * @Author Hanyonglu * @Date 2012-10-18 06:54:06 PM * @version v1.0 */public class Demo4 {public void main (String [] [] {INT INT VALA []; int temp1, temp2, tempp3; Random r = new Random (); for (int i = 0; i <value.length; i ++) {valores [i] = i+1; } // intercambia aleatoriamente valores. Times de longitud para (int i = 0; i <valores.length; i ++) {temp1 = math.abs (R.NextInt ()) % (valores.length-1); // Generar aleatoriamente una posición temp2 = Math.abs (R.NextInt ()) % (valores.length-1); // Generar aleatoriamente otra posición if (temp1! = Temp2) {tempp3 = valores [temp1]; valores [temp1] = valores [temp2]; valores [temp2] = tempp3; }} // atraviesa la matriz e imprime los datos para (int i = 0; i <20; i ++) {System.out.print (valores [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Este método también es relativamente eficiente. Si se generan 10,000 datos, el tiempo que toma es 0.054s.
Según la implementación de coordenadas en una matriz, se pueden transformar más soluciones relacionadas y puede consultar la información relevante en detalle.
Lo anterior se trata de implementar la función de números aleatorios y no repetitivos en Java. Por supuesto, los métodos no se limitan a estos tipos, pero existen otros métodos de implementación. Espero que sea útil para los amigos que han estado en contacto por un tiempo, y espero que pueda desempeñar un papel para atraer y atraer a Jade.
Sitio web original: http://www.cnblogs.com/hanyonglu/archive/2012/10/18/2730007.html
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.