주로 Java에서 랜덤 숫자를 얻는 세 가지 방법을 소개합니다.
방법 1
(데이터 유형) (최소 값 + math.random ()*(최대 값 -최소 값 +1)) 예 :
(int) (1+math.random ()*(10-1+1))
int 유형 1에서 10까지
방법 2
임의의 숫자를 얻으십시오
for (int i = 0; i <30; i ++) {System.out.println ((int) (1+math.random ()*10);} (int) (1+math.random ()*10) java.math 패키지의 임의 메소드는 1-10의 int 랜덤 번호를 얻습니다.
공식은 : 최소값 ---- 임의의 최대 값 (적분)입니다.
(유형) min + math.random () * 최대 값
방법 3
random ra = new random (); for (int i = 0; i <30; i ++) {system.out.println (ra.nextint (10) +1);} java.util 패키지에서 랜덤 클래스의 NextInt 메소드를 사용하여 1-10의 int random 번호를 얻으십시오.
0과 1 사이의 임의의 소수를 생성합니다.
간격 [0, d)에서 임의의 소수점을 생성하고 d는 양수 소수점이므로 다음 Double 메소드의 리턴 값에 d를 곱하면됩니다.
[N1, N2]
Ra.NextDouble () * (N2-N1)+N1입니다
Java에서 랜덤 숫자를 생성하는 몇 가지 방법
1. 생성 된 랜덤 숫자는 0-1 사이의 두 배입니다. 예를 들어 특정 숫자, 예를 들어 100을 곱할 수 있습니다. 100 내에 무작위로 J2ME에 존재하지 않습니다.
2. java.util 패키지에서 임의의 클래스가 제공됩니다. 무작위 숫자를 생성하기 위해 새로운 랜덤 객체를 만들 수 있습니다. 임의의 정수, 임의의 부유물, 임의의 복식 및 임의의 길이를 생성 할 수 있습니다. 이것은 또한 J2ME 프로그램에서 자주 사용하는 임의의 숫자를 취하는 방법입니다.
3. 시스템 클래스에는 CurrentTimeMillis () 메소드가 있습니다. 이 메소드는 1970 년 1 월 1 일 0:00:00에서 현재의 숫자로 밀리 초 숫자를 반환합니다. 반환 유형이 길다. 우리는 그것을 무작위로 사용할 수 있습니다. 우리는 그것을 사용하여 일부 숫자를 모듈화하고 범위로 제한 할 수 있습니다.
실제로 Random의 기본 구성 방법에서 위의 세 번째 방법은 랜덤 숫자를 생성하는 데 사용됩니다.
메소드 2의 랜덤 클래스에는 다음과 같은 설명이 있습니다.
java.util.random 클래스를 만드는 방법에는 두 가지가 있습니다 : 씨앗과 씨앗없이
씨앗 없음 :
이 메소드는 임의 숫자를 반환하며 실행마다 결과가 다릅니다.
public class randomtest {public static void main (string [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {system.out.println (r.nextint ());}} 씨앗으로 :
이런 식으로 프로그램의 몇 번이나 실행 되더라도 반환 결과는 동일합니다.
public static void main (String [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {system.out.println ();}} 두 방법의 차이점은 다음과 같습니다
(1) 먼저, Java Doc을 열어 주시면, 우리는 임의의 클래스에 대한 설명을 볼 수 있습니다.
이 클래스의 예는 유사 랜덤 번호 스트림을 생성하는 데 사용되며, 이는 선형 합동 공식을 사용하여 수정할 수있는 48 비트 시드를 사용합니다.
동일한 시드로 두 개의 임의 인스턴스가 생성되면 각 인스턴스에 동일한 메소드 호출 시퀀스가 이루어지며 동일한 숫자를 생성하고 반환합니다. 이 기능이 구현되도록하기 위해 클래스 랜덤에 대한 특정 알고리즘을 지정합니다. Java 코드의 완전한 휴대 성을 위해 Java 구현에는 여기에 표시된 모든 알고리즘을 무작위로 사용해야합니다. 그러나 랜덤 클래스의 서브 클래스는 모든 방법의 기존 계약을 준수하는 한 다른 알고리즘을 사용할 수 있습니다.
Java Doc은 랜덤 클래스를 잘 설명했으며 테스트에서이를 확인했습니다.
(2) 종자 수가 제공되지 않으면 임의 인스턴스의 씨앗 수는 현재 시간의 밀리 초입니다. System.CurrentTimeMillis ()를 통해 현재 시간의 밀리 초를 얻을 수 있습니다. JDK의 소스 코드를 열면 이것을 매우 명확하게 볼 수 있습니다.
public random () {this (System.CurrentTimeMillis ()); } 게다가:
랜덤 오브젝트의 NextInt (), NextInt (int n) 메소드에 대한 설명 :
int nextint () // 다음 의사-랜덤 번호를 반환합니다.이 랜덤 번호 생성기의 순서에서 균일하게 분산 된 int 값입니다.
int nextInt (int n) //이 랜덤 숫자 생성기의 시퀀스에서 가져온 0 (포함)과 지정된 값 (제외) 사이에 균일하게 분산 된 int 값 인 의사 랜덤 번호를 반환합니다.
자바 랜덤 번호 요약
임의의 숫자는 고정 길이 문자열 또는 숫자를 생성하는 것과 같이 실제로 널리 사용됩니다. 그런 다음 여러 불확실한 길이를 생성하거나 시뮬레이션 된 랜덤 선택 등을 수행합니다. Java는 개발자 가이 모든 것을 달성하는 데 도움이되는 가장 기본적인 도구를 제공합니다.
1. 자바 랜덤 숫자를 생성하는 방법
Java에는 랜덤 숫자의 세 가지 일반적인 개념이 있습니다.
1. System.CurrentTimeMillis ()를 사용하여 현재 시간에 긴 유형 수의 밀리 초를 얻으십시오.
2. Math.random ()에서 0에서 1 사이의 이중 값을 반환합니다.
3. 랜덤 클래스를 통해 임의의 숫자를 생성합니다. 이것은 강력한 기능을 갖춘 전문적인 랜덤 툴 클래스입니다.
2. 랜덤 API 설명
1. Java API 설명
랜덤 클래스의 인스턴스는 의사 랜덤 번호 스트림을 생성하는 데 사용됩니다. 이 클래스는 48 비트 씨앗을 사용하고 선형 합동 공식을 사용하여이를 수정합니다 (Donald Knuth의 The Art of Computer Programming, Volume 2, 3.2.1 참조).
동일한 시드로 두 개의 임의 인스턴스가 생성되면 각 인스턴스에 동일한 메소드 호출 시퀀스가 이루어지며 동일한 숫자를 생성하고 반환합니다. 속성의 구현을 보장하기 위해 클래스 랜덤에 특정 알고리즘이 지정됩니다.
많은 응용 프로그램에서 수학 클래스의 임의 메소드를 사용하기가 더 쉽습니다.
2. 방법 요약
random () // 새 랜덤 번호 생성기를 만듭니다.
랜덤 (긴 시드) // 단일 긴 씨앗을 사용하여 새 랜덤 숫자 생성기를 만듭니다 : public random (long seed) {setseed (seed); } 다음 메소드는이를 사용하여 랜덤 번호 생성기의 상태를 저장합니다.
보호 된 int 다음 (INT 비트) : 다음 의사 랜덤 번호를 생성합니다.
부울 NextBoolean () :이 임의의 숫자 생성기의 시퀀스에서 가져온 균일하게 분산 된 부울 값 인 다음 의사 랜덤 번호를 반환합니다.
void nextbytes (byte [] bytes) : 임의 바이트를 생성하여 사용자가 제공하는 바이트 배열에 배치합니다.
Double NextDouble () :이 난수 생성기의 시퀀스에서 가져온 0.0에서 1.0 사이의 이중 값 인 다음 의사 랜덤 번호를 반환합니다.
float nextFloat () : 다음 의사-랜덤 번호를 반환합니다.이 랜덤 랜덤 번호는이 난수 생성기의 시퀀스에서 가져온 0.0에서 1.0 사이의 플로트 값입니다.
Double Nextgaussian () :이 난수 생성기의 시퀀스에서 가져온 가우스 ( "정상적으로") 분포 인 다음 의사 랜덤 번호를 반환합니다. 평균 값은 0.0이고 표준 편차는 1.0입니다.
int nextint () : 다음 의사-랜덤 번호를 반환합니다.
int NextInt (int n) :이 랜덤 번호 생성기의 시퀀스에서 가져온 균일하게 분산 된 int 값인 의사-랜덤 번호를 반환하고 0 (포함)과 지정된 값 (제외) 사이에 균일하게 분포됩니다.
Long NextLong () :이 임의의 숫자 생성기의 시퀀스에서 가져온 균일하게 분산 된 긴 값인 다음 의사 랜덤 번호를 반환합니다.
void setseed (긴 씨앗) : 단일 긴 씨앗을 사용 하여이 임의의 숫자 생성기의 씨앗을 설정합니다.
3. 임의의 클래스 사용 지침
1. 씨앗을 복용하는 것과 씨앗을 복용하지 않는 것의 차이. 임의의 클래스의 근본적인 사용은 무작위의 예를 씨앗과 씨앗없이 나누는 것입니다.
평신도의 용어로는, 둘 사이의 차이점은 다음과 같습니다. 씨앗이 생성되면 각 실행에 의해 생성 된 결과는 동일합니다.
씨앗이없는 경우, 생성하는 것은 달릴 때마다 무작위이며 전혀 패턴이 없습니다.
2. 씨앗이없는 임의의 물체를 만듭니다
랜덤 random = new random ();
3. 씨앗이없는 임의의 물체를 만드는 두 가지 방법이 있습니다.
1) 랜덤 랜덤 = 새로운 랜덤 (555L);
2) random random = new random (); random.setseed (555L);
4. 테스트
위의 사용법을 설명하려면 예제를 사용하십시오
java.util.random import; public class testrandomnum {public static void main (String [] args) {randomtest (); testnoseed (); testseed1 (); testseed2 (); } public static void randomtest () { System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- long R1 = CurrentTimeMillis (); System.out.println ( "r2 =" + r3); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Random(); for (int i = 0; i <3; i ++) {system.out.println (random.nextint ()); }} public static void testseed1 () { System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 실행 결과 :
--------------시험()--------------
R1 = 1227108626582
R3 = 0.532487850155043
R2 = -368083737
--------------- testNoseed () --------------
809503475
1585541532
-645134204
---------------- testseed1 () -------------
-1367481220
292886146
-1462441651
-------------- TestSEED2 () --------------
-1367481220
292886146
-1462441651
Exit 코드 0으로 프로세스가 완료되었습니다
testseed1 () 및 testseed2 () 메소드의 결과를 통해 두 인쇄 결과가 동일하게 보이기 때문에 동일하다는 것을 알 수 있습니다. 그들이 다시 실행되면 결과는 여전히 동일합니다. 이것은 씨앗이있는 임의의 숫자의 특성입니다. 씨앗이없는 경우 각 실행 결과는 무작위입니다.
V. 포괄적 인 응용 프로그램
다음은 사용법을 보여주기 위해 최근에 쓰여진 임의 번호 도구 클래스입니다.
java.util.random import; 공개 클래스 randomutils {public static final string allchar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"; 공개 정적 최종 문자열 Letterchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; 공개 정적 최종 문자열 번호 차르 = "0123456789"; public static string generatestring (int length) {StringBuffer sb = new StringBuffer (); 랜덤 random = new random (); for (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (allchar.length ())); } return sb.toString (); } public static string generatemixString (int length) {StringBuffer sb = new StringBuffer (); 랜덤 random = new random (); for (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextInt (letterchar.length ())); } return sb.toString (); } public static string generatelowerstring (int length) {return generatemixstring (length) .tolowercase (); } public static string generateUpperstring (int length) {return generatemixString (length) .toupperCase (); } public static string generatezeroString (int length) {StringBuffer sb = new StringBuffer (); for (int i = 0; i <길이; i ++) {sb.append ( '0'); } return sb.toString (); } public static string tofixdlengthstring (long num, int fixlenth) {StringBuffer sb = new StringBuffer (); 문자열 strnum = string.valueof (num); if (fixlenth -strnum.length ()> = 0) {sb.append (generatezeroString (fixlenth -strnum.length ())); } else {Throw new runtimeexception ( "변환 번호" + num + "예외는 길이" + fixlenth + ");} sb.append (strnum); return sb.toString ();} 공개 정적 문자열 tofixdlengthstring (int num, int fixdlenth) {stringbuffer (); string.valueof (num); if (fixlenth -length ()> = 0) {sb.append (fixlenth -strnum.length ()) { " + runtimeexception (" + num + "); } sb.append (strnum); 반환 sb.toString (); } public static void main (String [] args) {System.out.println (Generatestring (15)); System.out.println (GeneratemixString (15)); System.out.println (Generatelowerstring (15)); System.out.println (GenerateUpperstring (15)); System.out.println (GenerateZeroString (15)); System.out.println (tofixdlengthstring (123, 15)); System.out.println (tofixdlengthstring (123l, 15)); System.out.println (tofixdlengthstring (123l, 15)); }}실행 결과 :
vwmbpinbzfgcph
23Hyrahdjkkpwmv
tigowetbwkm1nde
BPZ1KNEJPHB115N
000000000000000000
00000000000000123
00000000000000123
Exit 코드 0으로 프로세스가 완료되었습니다
6. 요약
1. 임의 숫자는 일반적으로 사용됩니다. 자바에서이를 생성하는 세 가지 방법이 있습니다. 임의의 임의 숫자가 가장 복잡합니다.
2. 임의의 클래스 객체는 씨앗을 운반하는지 간의 차이가 있습니다. 씨앗이 동일하다면 여러 번 실행되며 임의 숫자를 생성 한 결과는 항상 동일합니다.
3. 동일한 효과로 임의의 숫자를 가진 종자 객체를 만드는 두 가지 방법이 있습니다. 그러나 씨앗이있는 임의의 숫자는 많이 사용되지 않는 것 같습니다.
4. Random의 함수는 Math.random ()의 기능을 다룹니다.
5. 임의의 숫자를 사용하여 임의의 문자열과 같은 복잡한 랜덤 데이터를 구현할 수 있습니다.
6. 반복되지 않는 임의의 숫자를 공부하지 마십시오. 그다지 의미가 없습니다.
Java에서는 java.util.random 클래스를 사용하여 임의의 숫자 생성기를 생성 할 수 있습니다. 그것은 두 가지 형태의 생성자, 즉 Random ()과 랜덤 (긴 시드)을 가지고 있습니다. Random ()는 발전기의 시드로 현재 시간, System.currenttimeMillis ()를 사용하고 임의 (긴 씨앗)는 지정된 씨앗을 발전기의 시드로 사용합니다.
임의의 숫자 생성기 (랜덤) 객체가 생성 된 후, 다른 방법을 호출하여 다른 유형의 임의 숫자를 얻습니다 : nextint (), nextlong (), nextfloat (), nextDouble () 등.
1> 랜덤 숫자를 생성합니다
랜덤 random = new random (); 랜덤 랜덤 = 새로운 랜덤 (100); // 씨앗 수를 지정하십시오 100
랜덤 숫자를 얻기 위해 다른 방법을 호출합니다.
2 개의 임의의 물체가 동일한 시드 (예 : 둘 다 100)를 사용하고 동일한 함수가 동일한 순서로 호출되면 반환 값이 정확히 동일합니다. 다음 코드에서와 같이 두 임의 객체의 출력은 정확히 동일합니다.
java.util.*; 클래스 testrandom {public static void main (String [] args) {random random1 = new random (100); System.out.println (random1.nextint ()); System.out.println (random1.nextfloat ()); System.out.println (random1.nextBoolean ()); 랜덤 random2 = 새로운 랜덤 (100); System.out.println (random2.nextint ()); System.out.println (random2.nextfloat ()); System.out.println (random2.nextBoolean ()); }} 2> 지정된 범위의 임의 숫자
임의 숫자는 계수 연산자 %를 사용하여 특정 범위 내에서 제어됩니다.
java.util.*; 클래스 testrandom {public static void main (String [] args) {random random = new random (); for (int i = 0; i <10; i ++) {system.out.println (math.abs (random.nextint ()); }}}얻은 임의의 숫자는 양수이고 음수입니다. Math.abs를 사용하여 데이터 범위를 비 음성 숫자로 검색하십시오.
3> 지정된 범위 내에서 비 반복 랜덤 번호를 얻습니다
java.util.*; 클래스 testrandom {public static void main (String [] args) {int [] intret = new int [6]; intrd = 0; // 저장 무작위 숫자 int count = 0; // 생성 된 랜덤 숫자를 기록 int flag = 0; // 플래그가 생성되었는지 여부 (count <6) {random rdm = new random (System.CurrentTimeMillis ()); intrd = math.abs (rdm.nextint ()) 2+1; for (int i = 0; i <count; i ++) {if (intret [i] == intrd) {flag = 1; 부서지다; } else {flag = 0; }} if (flag == 0) {intret [count] = intrd; 카운트 ++; }} for (int t = 0; t <6; t ++) {system.out.println (t+"->"+intret [t]); }}} Java의 임의 숫자를 반복 할 수 있습니까? Java에서 생성 된 랜덤 숫자를 사용하여 데이터베이스 기본 키를 생성 할 수 있습니까? 이 질문을 염두에두고 일련의 테스트를 수행했습니다.
1. 테스트 1 : 매개 변수가없는 임의 () 생성자를 사용하십시오
public class randomtest {public static void main (String [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {system.out.println (r.nextint ()); }}} 프로그램 실행 결과 :
-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157
프로그램을 다시 실행하십시오.
-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608
위의 테스트에서 파라미터없이 랜덤 () 생성자를 사용하여 생성 된 랜덤 숫자는 반복되지 않음을 알 수 있습니다. 그렇다면 Java는 어떤 상황에서 중복 랜덤 숫자를 생성합니까? 아래 테스트를 봅시다.
2. 테스트 2 : 무작위 종자 수를 설정
public class randomtest_repeat {public static void main (String [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {system.out.println (r.nextint ()); }}} 프로그램의 몇 번이나 실행 되더라도 결과는 항상 다음과 같습니다.
-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428
다른 기계에서 테스트하더라도 테스트 결과는 변경되지 않습니다!
3. 원인 분석 :
(1) 먼저, Java Doc을 열어 주시면, 우리는 임의의 클래스에 대한 설명을 볼 수 있습니다.
이 클래스의 예는 선형 합동 공식을 사용하여 수정할 수있는 48 비트 시드를 사용하는 의사 랜덤 숫자 스트림을 생성하는 데 사용됩니다 (Donald Knuth의 The Art of Computer Programming, Volume 3.2.1 참조).
동일한 시드로 두 개의 임의 인스턴스가 생성되면 각 인스턴스에 동일한 메소드 호출 시퀀스가 이루어지며 동일한 숫자를 생성하고 반환합니다. 이 기능이 구현되도록하기 위해 클래스 랜덤에 대한 특정 알고리즘을 지정합니다. Java 코드의 완전한 휴대 성을 위해 Java 구현에는 여기에 표시된 모든 알고리즘을 무작위로 사용해야합니다. 그러나 랜덤 클래스의 서브 클래스는 모든 방법의 기존 계약을 준수하는 한 다른 알고리즘을 사용할 수 있습니다.
Java Doc은 랜덤 클래스를 잘 설명했으며 테스트에서이를 확인했습니다.
(2) 종자 수가 제공되지 않으면 임의 인스턴스의 씨앗 수는 현재 시간의 밀리 초입니다. System.CurrentTimeMillis ()를 통해 현재 시간의 밀리 초를 얻을 수 있습니다. JDK의 소스 코드를 열면 이것을 매우 명확하게 볼 수 있습니다.
public random () {this (System.CurrentTimeMillis ()); } 4. 결론 :
위의 테스트 및 분석을 통해 임의의 클래스에 대한 더 깊은 이해를 가질 것입니다. 동시에, 나는 Java Doc API 문서를 읽음으로써 우리의 Java 프로그래밍 기능을 크게 개선 할 수 있고 "진실을 아는 것"을 달성 할 수 있다고 생각합니다. 당황한 문제에 직면하면 Java 소스 코드를 열면서 "진실을 아는"것입니다.
Java에는 일반적으로 2 가지 유형의 랜덤 숫자가 있으며, 하나는 수학의 임의 () 메소드이고 다른 하나는 랜덤 클래스입니다.
1. Math.random ()
10 진수 수 <x <1이 생성됩니다.
예 : 0에서 100까지의 숫자 중 하나를 무작위로 작성하고 생성하는 방법은 무엇입니까?
Math.random ()은 0에서 1까지 소수점 만 반환합니다. 50 ~ 100을 원한다면 먼저 50 배, 즉 0에서 50 사이입니다. 여기에 여전히 소수점이 있습니다. 정수를 원한다면 int를 캐스트 한 다음 50 ~ 50 ~ 100을 추가합니다.
최종 코드 : (int) (Math.Random ()*50) + 50
2. 랜덤 클래스
random random = new random (); // 기본 생성자 랜덤 랜덤 = new random (1000); // 종자 번호 지정
무작위 배정을 수행 할 때 무작위 알고리즘의 원점 수를 종자라고하며, 이는 시드에 기초하여 특정 변환을 수행하여 필요한 임의 숫자를 생성합니다.
같은 수의 씨앗을 가진 임의의 물체, 동일한 숫자로 생성 된 임의의 숫자는 정확히 동일합니다. 다시 말해, 시드 숫자가 동일한 두 개의 임의의 물체의 경우 처음으로 생성 된 임의의 숫자는 정확히 동일하며 두 번째로 생성 된 임의 숫자는 정확히 동일합니다.
2. 임의의 클래스의 일반적인 방법
랜덤 클래스의 방법은 비교적 간단하며 각 방법의 기능도 이해하기 쉽습니다. 랜덤 클래스에서 각 방법에 의해 생성 된 랜덤 숫자는 균일하게 분포되어 있으며, 이는 간격 내에서 수치 생성의 확률이 동일하다는 것을 의미합니다. 다음은 이러한 방법에 대한 기본 소개입니다.
A, Public Boolean NextBoolean ()
이 방법의 기능은 임의의 부울 값을 생성하는 것이며, 참와 거짓 값을 생성 할 확률은 동일합니다. 즉, 둘 다 50%입니다.
B, 공개 더블 NextDouble ()
이 방법의 목적은 임의의 이중 값을 생성하는 것입니다. 값은 [0, 1.0) 사이입니다. 여기서, 브래킷은 간격을 포함하는 엔드 포인트를 나타내고, 브래킷은 간격, 즉 0과 1 사이의 임의의 소수점을 포함하지만 0을 포함하지만 1.0은 포함하지 않는 종점을 나타냅니다.
C, public int nextint ()
이 방법의 목적은 2의 -1st power -2의 31 번째 전력과 31 번째 전력 사이의 임의의 int 값을 생성하는 것입니다.
지정된 간격에 대한 Int 값을 생성 해야하는 경우 특정 수학적 변환을 수행해야합니다. 자세한 내용은 아래 사용 예제의 코드를 참조하십시오.
D, Public Int NextInt (int n)
이 방법의 기능은 [0, n)의 간격, 즉 0과 n 사이의 랜덤 int 값, 즉 0을 포함하지만 n이 아닌 임의의 int 값을 생성하는 것입니다.
지정된 간격에 대해 Int 값을 생성하려면 특정 수학적 변환을 수행해야합니다. 자세한 내용은 아래 사용 예제의 코드를 참조하십시오.
e, 공공 공간 setseed (긴 씨앗)
이 방법의 목적은 임의의 물체에서 종자 수를 재설정하는 것입니다. 씨앗 수를 설정 한 후, 임의의 객체는 새 키워드로 생성 된 임의의 객체와 동일합니다.
3. 임의의 클래스 사용 예제
랜덤 클래스를 사용하면 일반적으로 지정된 간격에 대해 난수를 생성하는 것입니다. 다음은 해당 간격에 대해 임의의 숫자를 하나씩 생성하는 방법을 소개합니다. 임의 숫자를 생성하는 다음 코드는 다음 랜덤 객체 r을 사용하여 생성됩니다.
랜덤 r = 새로운 랜덤 ();
에이. 간격의 소수성 생성 [0,1.0)
이중 D1 = R.NextDouble ();
NextDouble 방법을 사용하여 직접 얻습니다.
비. 간격의 소수성 생성 [0,5.0)
Double D2 = R.NextDouble () * 5;
NextDouble 방법에 의해 생성 된 숫자 간격은 [0, 1.0)이므로 간격을 5 배 늘리는 것이 필요한 간격입니다.
마찬가지로, 간격 [0, d)에서 임의의 소수점을 생성하고 d는 양수 소수점이므로 다음 double 메소드의 반환 값에 d를 곱하면됩니다.
기음. 간격 [1, 2.5) [1]의 십진수 [n1, n2]를 생성하십시오.
Double D3 = R.NextDouble () * 1.5 + 1;
간격 [1, 2.5)의 임의 소수점을 생성하려면 먼저 [0, 1.5) 간격의 랜덤 숫자 만 생성 한 다음 생성 된 임의 번호 간격에 1을 추가하면됩니다.
마찬가지로, 0에서 시작하지 않는 10 진수 간격 [D1, D2)의 범위에서 임의의 숫자를 생성하려면 (D1이 0이 아닌 경우) 먼저 [0, D2-D1)의 난수를 생성 한 다음 생성 된 임의 숫자 간격을 D1에 추가하면됩니다.
디. 정수를 생성하십시오
int n1 = r.nextint ();
NextInt 메소드를 직접 사용하십시오.
이자형. 간격으로 정수 생성 [0,10)
int n2 = r.nextint (10); n2 = math.abs (r.nextint () % 10);
위의 두 줄의 코드는 간격으로 정수를 생성 할 수 있습니다 [0,10).
첫 번째 구현은 랜덤 클래스에서 NextInt (int n) 메소드를 사용하여 직접 구현됩니다.
두 번째 구현에서 먼저 다음 호출 다음 int 번호를 생성하기 위해 다음 번에 다음으로 호출하십시오. 수학적 사양에 따라 나머지의 절대 값은 제수보다 작고 간격의 절대 값이 계산되고 결과 간격은 [0,10)이기 때문에 숫자 10의 숫자 합에 의해 생성 된 간격은 (-10,10)입니다.
마찬가지로, 모든 간격으로 임의의 정수를 생성하려면 [0, n) 다음 코드를 사용할 수 있습니다.
int n2 = r.nextint (n); n2 = math.abs (r.nextint () % n);
에프. 간격으로 정수 생성 [0,10]
int n3 = r.nextint (11); n3 = math.abs (r.nextint () % 11);
정수 간격과 비교하여 [0,10] 간격 및 [0,11) 간격은 동일하므로 [0,11) 간격의 정수가 생성됩니다.
g. 간격으로 정수 생성 [-3,15)
int n4 = r.nextint (18) -3; // r.nextint () * (n2 -n1)+n1】 n1은 음수 n4 = math.abs (r.nextint () % 18) -3;
0부터 시작하지 않는 임의의 정수를 생성하려면 0부터 시작하지 않는 소수점 간격의 구현 원리에 대한 위의 설명을 참조 할 수 있습니다.
위는이 기사의 모든 내용입니다. 모든 사람의 학습에 도움이되기를 바랍니다. 모든 사람이 wulin.com을 더 지원하기를 바랍니다.