ஜாவா ரேண்டம் நெக்ஸ்ட்இண்ட்() முறை

ஜாவா மொழியில் போலி-ரேண்டம் எண் ஜெனரேட்டரை உருவாக்க பல விருப்பங்கள் உள்ளன. இந்த விருப்பங்களில் ஒன்று java.util.Random class மற்றும் nextInt() முறையின் பயன்பாடு ஆகும் . இந்த கட்டுரையில், நாம் Random nextInt() முறையைப் பற்றி பேசப் போகிறோம் மற்றும் அதன் பயன்பாட்டிற்கான சில குறியீட்டு எடுத்துக்காட்டுகளைத் தருகிறோம்.

java.util.Random class பற்றி சுருக்கமாக

java.util.Random class, நாம் சொன்னது போல், ஒரு போலி ரேண்டம் எண் ஜெனரேட்டர் . வகுப்பு இரண்டு கட்டமைப்பாளர்களால் குறிப்பிடப்படுகிறது

• ரேண்டம்() - தனித்துவமான விதையைப் பயன்படுத்தி எண் ஜெனரேட்டரை உருவாக்குகிறது

• சீரற்ற (நீண்ட விதை) - விதையை கைமுறையாகக் குறிப்பிட உங்களை அனுமதிக்கிறது

வகுப்பு ஒரு போலி-சீரற்ற எண்ணை உருவாக்குவதால், ஒரு விதையைக் குறிப்பிடுவதன் மூலம், சீரற்ற வரிசையின் தொடக்கப் புள்ளியை நீங்கள் தீர்மானிக்கிறீர்கள். நீங்கள் அதே சீரற்ற காட்சிகளைப் பெறுவீர்கள். அத்தகைய பொருத்தத்தைத் தவிர்க்க, தற்போதைய நேரத்தை ஆரம்ப மதிப்பாகப் பயன்படுத்தி இரண்டாவது கட்டமைப்பாளரைப் பயன்படுத்துவது பொதுவானது.

Random nextInt() முறை

java.util.Random.nextInt() Method என இரண்டு விருப்பங்கள் உள்ளன

• int nextInt(int n) — 0 முதல் n வரையிலான வரம்பில் int வகையின் அடுத்த சீரற்ற மதிப்பை வழங்குகிறது. n நேர்மறையாக இல்லாவிட்டால், முறையானது IllegalArgumentException ஐ வீசுகிறது.

• int nextInt() — அடுத்த ரேண்டம் int மதிப்பை வழங்குகிறது

Random nextInt() முறை குறியீடு எடுத்துக்காட்டு

குறியீடு எடுத்துக்காட்டுகளுடன் java.util.Random.nextInt() முறையின் இரண்டு வகைகளையும் முயற்சிப்போம் . வாதங்கள் இல்லாத nextInt() முறையின் எடுத்துக்காட்டு இங்கே :

import java.util.*;
public class RandomTest {
   public static void main(String[] args)
   {
       //creating a Random Object ran
       Random ran = new Random();

       //generating a number using nextInt() method
       int randomNumber = ran.nextInt();

       System.out.println("Randomly generated number = " + randomNumber);
   }
}

வெளியீடு இருக்கும்…எங்களுக்கு நிச்சயமாகத் தெரியாது! குறியீட்டை முயற்சிக்கவும், தோராயமாக உருவாக்கப்பட்ட முழு எண் எண்ணைப் பெறுவீர்கள். ஒரு வாதத்துடன் Random.nextInt() ஐ முயற்சிப்போம் . இருப்பினும், இந்த முறை எங்கள் பிரச்சனை மிகவும் சுவாரஸ்யமாக இருக்கும். ஆன்லைன் கேசினோ விளம்பரங்களை நீங்கள் ஒன்றுக்கு மேற்பட்ட முறை பார்த்திருக்கலாம், அவை உண்மையில் இணையத்தை நிரப்பின. எனவே, இதுபோன்ற கேம்களில் எண் ஜெனரேட்டரின் வரிசை பொதுவாக ரேண்டம் போன்ற முறைகள் மற்றும் வகுப்புகளைப் பயன்படுத்தி உருவாக்கப்படுகிறது . ஒவ்வொரு பக்கத்திலும் 1 முதல் 6 வரை எழுதப்பட்ட இரண்டு பகடைகளை உருட்ட ஒரு நிரலை உருவாக்குவோம்.

import java.util.*;
public class RandomTest2 {
   public static void main(String args[])
   {

       // create Random Object
       Random random = new Random();

       // Printing the 6 random numbers between 1 and 6 using //random.nextInt()
       

      for (int i = 1; i < 7; i++) {
          System.out.println("throwing a dice for the " + i + " time");
       System.out.println ("Random number between 1 and 6 is = " + (1 + random.nextInt(6)));
   }
   }
}

இந்த திட்டத்தில், வீரர் ஒரு வரிசையில் 6 முறை பகடைகளை "உருட்டுகிறார்". Random.nextInt() அடுத்த எண்ணைத் தீர்மானிக்கிறது. முடிவுகளில் ஒன்று இங்கே: இதேபோல், நீங்கள் இரண்டு வீரர்களுக்கு பகடை விளையாட்டை செயல்படுத்தலாம். எடுத்துக்காட்டாக, லாட்டரி அல்லது சில்லி. நடைமுறை உலக தலைமுறையுடன் நீங்கள் எப்போதாவது ஒரு விளையாட்டை விளையாடியிருந்தால், அது எவ்வாறு செயல்படுகிறது என்பது பற்றிய ஆரம்ப யோசனை உங்களுக்கு இப்போது உள்ளது.