Java에서 무작위 반복 없는 숫자를 실현하는 방법

일반적으로 개발 경험이 있는 친구들은 이런 기능을 실현할 수 있지만 단지 효율상의 문제에 불과하다.우리는 일반적으로 이런 문제에 직면할 때 선생이 하나의 수조가 된 다음에 하나의 순환에서 수조에 무작위 숫자를 추가하고 숫자를 추가하는 과정에서 먼저 수조에 이 숫자가 존재하는지 찾아서 이 숫자가 존재하지 않으면 수조에 직접 추가한다.이 숫자가 존재하면 추가하지 않습니다.우리는 일반적으로 이렇게 문제를 고려한다. 이렇게 고려해도 기능을 실현할 수 있다. 나도 방금 말했지만 단지 효율상의 문제에 불과하다.
이 문제의 뜻을 더욱 잘 이해하기 위해 우리는 먼저 구체적인 내용을 살펴보자. 1-100의 무작위 수조를 생성하지만 수조의 숫자는 중복될 수 없다. 즉, 위치는 무작위이지만 수조 요소는 중복될 수 없다.여기에서 우리에게 수조의 길이를 규정하지 않았으니, 우리는 그것을 1-100 사이의 임의의 길이로 할 수 있다.
다음 코드와 같이 일반적으로 ArrayList를 사용하여 구현하는 방법을 살펴보겠습니다.

package cn.sunzn.randomnumber;
import java.util.ArrayList;
import java.util.Random;
public class Demo {
   public static void main(String[] args) {
       Object[] values = new Object[20];
       Random random = new Random();
       ArrayList<Integer> list = new ArrayList<Integer>();
       for (int i = 0; i < values.length; i++) {
           int number = random.nextInt(100) + 1;
           if (!list.contains(number)) {
               list.add(number);
           }
       }
       values = list.toArray();
       /**********   **********/
       for (int i = 0; i < values.length; i++) {
           System.out.print(values[i] + "\t");
           if ((i + 1) % 10 == 0) {
               System.out.println("
");
           }
       }
   }
}

위의 이 실현 과정의 효율은 비교적 낮다.추가할 때마다 현재 목록에 이 숫자가 있는지 훑어봐야 하기 때문에 시간 복잡도는 O(N^2)입니다.우리는 이렇게 생각해 볼 수 있다. 중복이 없는 것과 관련이 있는 이상, 우리는 HashSet과 HashMap의 기능을 생각해 볼 수 있다.HashSet은 Set 인터페이스를 실현하는데 Set의 수학적 정의는 중복이 없고 순서가 없는 집합이다.HashMap이 Map을 실현하는 것도 중복을 허용하지 않는 키입니다.이렇게 하면 우리는 HashMap 또는 HashSet을 사용하여 실현할 수 있다.
HashMap을 사용하여 실행할 때 키의 키를 수조로 바꾸면 됩니다. 코드는 다음과 같습니다.

package cn.sunzn.randomnumber;
import java.util.HashMap;
import java.util.Random;
public class Demo {
   public static void main(String[] args) {
       Object[] values = new Object[20];
       Random random = new Random();
       HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
       /*******   HashMap *******/
       for (int i = 0; i < values.length; i++) {
           int number = random.nextInt(100) + 1;
           hashMap.put(number, i);
       }
       /**********   HashMap   **********/
       values = hashMap.keySet().toArray();
       /***********   ***********/
       for (int i = 0; i < values.length; i++) {
           System.out.print(values[i] + "\t");
           if ((i + 1) % 10 == 0) {
               System.out.println("
");
           }
       }
   }
}

HashSet과 HashMap의 관계가 너무 가깝기 때문에 HashSet은 밑바닥에서 HashMap으로 이루어진다. 단지 가치의 집합이 없고 하나의 키의 집합만 있기 때문에 HashSet을 사용하여 실현할 수 있다. 코드는 다음과 같다.

package cn.sunzn.randomnumber;
import java.util.HashSet;
import java.util.Random;
public class Demo {
   public static void main(String[] args) {
       Random random = new Random();
       Object[] values = new Object[20];
       HashSet<Integer> hashSet = new HashSet<Integer>();
       /*******   HashSet *******/
       for (int i = 0; i < values.length; i++) {
           int number = random.nextInt(100) + 1;
           hashSet.add(number);
       }
       values = hashSet.toArray();
       /***********   **********/
       for (int i = 0; i < values.length; i++) {
           System.out.print(values[i] + "\t");
           if ((i + 1) % 10 == 0) {
               System.out.println("
");
           }
       }
   }
}

이렇게 하면 효율이 좀 좋아진다.만약 우리에게 수조의 길이를 한정해 주었다면, for순환을 바꾸어 whlie 순환으로 설정하면 된다.다음과 같습니다.

package cn.sunzn.randomnumber;
import java.util.HashSet;
import java.util.Random;
public class Demo {
   public static void main(String[] args) {
       Random random = new Random();
       Object[] values = new Object[20];
       HashSet<Integer> hashSet = new HashSet<Integer>();
       /******   HashSet ******/
       while (hashSet.size() < values.length) {
           hashSet.add(random.nextInt(100) + 1);
       }
       values = hashSet.toArray();
       /**********   **********/
       for (int i = 0; i < values.length; i++) {
           System.out.print(values[i] + "\t");
           if ((i + 1) % 10 == 0) {
               System.out.println("
");
           }
       }
   }
}