జావా రాండమ్ నెక్స్ట్ఇంట్() పద్ధతి

జావా భాషలో నకిలీ యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను రూపొందించడానికి అనేక ఎంపికలు ఉన్నాయి. ఈ ఎంపికలలో ఒకటి java.util.Random class మరియు nextInt() పద్ధతిని ఉపయోగించడం . ఈ వ్యాసంలో, మేము రాండమ్ nextInt() పద్ధతి గురించి మాట్లాడబోతున్నాము మరియు దాని ఉపయోగం యొక్క కొన్ని కోడ్ ఉదాహరణలను ఇస్తాము.

java.util.Random class గురించి క్లుప్తంగా

java.util.Random class, మేము చెప్పినట్లుగా, ఒక సూడో-రాండమ్ నంబర్ జనరేటర్ . తరగతిని ఇద్దరు కన్స్ట్రక్టర్‌లు సూచిస్తారు

• రాండమ్() — ఒక ప్రత్యేక విత్తనాన్ని ఉపయోగించి సంఖ్య జనరేటర్‌ను సృష్టిస్తుంది

• యాదృచ్ఛిక (దీర్ఘ విత్తనం) - విత్తనాన్ని మానవీయంగా పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది

తరగతి నకిలీ-యాదృచ్ఛిక సంఖ్యను సృష్టిస్తుంది కాబట్టి, విత్తనాన్ని పేర్కొనడం ద్వారా, మీరు యాదృచ్ఛిక క్రమం యొక్క ప్రారంభ బిందువును నిర్ణయిస్తారు. మరియు మీరు అదే యాదృచ్ఛిక సన్నివేశాలను పొందుతారు. అటువంటి సరిపోలికను నివారించడానికి, ప్రస్తుత సమయాన్ని ప్రారంభ విలువగా ఉపయోగించి రెండవ కన్స్ట్రక్టర్‌ను ఉపయోగించడం సర్వసాధారణం.

రాండమ్ nextInt() పద్ధతి

java.util.Random.nextInt() మెథడ్ అనే రెండు ఎంపికలు ఉన్నాయి

• int nextInt(int n) — 0 నుండి n పరిధిలోని టైప్ int యొక్క తదుపరి యాదృచ్ఛిక విలువను అందిస్తుంది. n సానుకూలంగా లేకుంటే, పద్ధతి IllegalArgumentExceptionని విసురుతుంది.

• int nextInt() — తదుపరి యాదృచ్ఛిక పూర్ణాంక విలువను అందిస్తుంది

రాండమ్ 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() తదుపరి సంఖ్యను నిర్ణయిస్తుంది. ఫలితాలలో ఒకటి ఇక్కడ ఉంది: ఇదే విధంగా, మీరు ఇద్దరు ఆటగాళ్ల కోసం పాచికల ఆటను అమలు చేయవచ్చు. మరియు లాటరీ, లేదా రౌలెట్, ఉదాహరణకు. మీరు ఎప్పుడైనా ప్రొసీజర్ వరల్డ్ జనరేషన్‌తో గేమ్‌ను ఆడి ఉంటే, అది ఎలా పని చేస్తుందనే దాని గురించి మీకు ఇప్పుడు ప్రాథమిక ఆలోచన ఉంది.