గణితం. విమోచన తరగతి:
ఈ క్లాస్ యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి ఉపయోగించబడుతుంది, ఇది 0.0 నుండి 0.99 వరకు పరిధిలో పాజిటివ్ పాక్షిక సంఖ్యగా ఉంటుంది . ఈ తరగతికి ఒక పద్ధతి అనే పేరు ఉంది యాదృచ్ఛిక () పాక్షిక యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి, మరియు ఈ తరగతిని ఉపయోగించడానికి ఒక వస్తువును సృష్టించాల్సిన అవసరం లేదు.
యాదృచ్ఛిక తరగతి:
యాదృచ్ఛిక వివిధ రకాల యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి తరగతికి అనేక పద్ధతులు ఉన్నాయి nextInt (), nextDouble (), nextLong, మొదలైనవి కాబట్టి, ఈ తరగతికి తగిన పద్ధతిని ఉపయోగించి పూర్ణాంకం మరియు భిన్న సంఖ్యలను రూపొందించవచ్చు. ఈ తరగతిలో ఉపయోగించడానికి మీరు ఒక వస్తువును సృష్టించాలి.
ఉదాహరణ -1: Math.amdom ఉపయోగించి పాక్షిక యాదృచ్ఛిక సంఖ్యను రూపొందించండి
ఇది ముందు ప్రస్తావించబడింది గణితం. యాదృచ్ఛిక క్లాస్ డిఫాల్ట్గా పొడవైన పాక్షిక యాదృచ్ఛిక సంఖ్యను ఉత్పత్తి చేస్తుంది, కింది ఉదాహరణలో దశాంశ బిందువులను చూపించిన తర్వాత మీరు రెండు అంకెలతో భిన్నమైన యాదృచ్ఛిక సంఖ్యను ఎలా రూపొందించవచ్చు. దశాంశ ఆకృతి పాక్షిక యాదృచ్ఛిక విలువలను దశాంశ బిందువు తర్వాత రెండు అంకెలతో ఫార్మాట్ చేయడానికి తరగతి ఇక్కడ ఉపయోగించబడుతుంది. కోడ్ను అమలు చేసిన తర్వాత ఐదు భిన్న సంఖ్యలు రూపొందించబడతాయి.
దిగుమతి java.text.DecimalFormat;
ప్రజా తరగతియాదృచ్ఛిక 1{
// దశాంశ బిందువు తర్వాత అంకెలను సెట్ చేయండి
ప్రైవేట్ స్టాటిక్ దశాంశ ఆకృతి dformat= కొత్త దశాంశ ఆకృతి ('0.00');
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
// లూప్ను 5 సార్లు చేయండి
కోసం(inti=0;i< 5;i++)
{
// యాదృచ్ఛిక సంఖ్యను రూపొందించండి
రెట్టింపురాండ్నం= గణితం .యాదృచ్ఛికంగా();
// ఫార్మాట్ చేసిన విలువను ముద్రించండి
వ్యవస్థ .బయటకు.println('రాండమ్ నంబర్'+ (i+1)+':'+dformat.ఫార్మాట్(రాండ్నం));
}
}
}
అవుట్పుట్:
కింది చిత్రం పై కోడ్ యొక్క అవుట్పుట్ను చూపుతుంది.
ఉదాహరణ -2: Math.random ఉపయోగించి పూర్ణాంక రాండమ్ సంఖ్యను రూపొందించండి
Math.random క్లాస్ని ఉపయోగించడం ద్వారా మీరు ఐదు యాదృచ్ఛిక పూర్ణాంక సంఖ్యలను ఎలా సృష్టించవచ్చో కింది ఉదాహరణ చూపుతుంది. ఇక్కడ, దశాంశ బిందువుకు ముందు 2 అంకెల సంఖ్యను పొందడానికి ప్రతి యాదృచ్ఛిక విలువ 100 తో గుణించబడుతుంది మరియు పూర్ణాంక విలువను పొందడానికి Math.round () పద్ధతి ఉపయోగించబడుతుంది.
ప్రజా తరగతియాదృచ్ఛిక 2{ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
వ్యవస్థ .బయటకు.println('మార్పిడి తర్వాత యాదృచ్ఛిక సంఖ్య:');
// లూప్ను 5 సార్లు చేయండి
కోసం(inti=0;i< 5;i++)
{
// యాదృచ్ఛిక సంఖ్యను రూపొందించండి మరియు పొడవుగా మార్చండి
పొడవురాండ్నం= గణితం .రౌండ్( గణితం .యాదృచ్ఛికంగా()*100);
// యాదృచ్ఛిక విలువను ముద్రించండి
వ్యవస్థ .బయటకు.println(రాండ్నం);
}
}
}
అవుట్పుట్:
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది. ఇక్కడ, రెండు అంకెల ఐదు పూర్ణాంక సంఖ్యలు ఉత్పత్తి చేయబడతాయి.
ఉదాహరణ -3: యాదృచ్ఛిక తరగతిని ఉపయోగించి పూర్ణాంక రాండమ్ సంఖ్యను రూపొందించండి
ఉపయోగించి యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి మీరు యాదృచ్ఛిక తరగతి వస్తువును సృష్టించాలి యాదృచ్ఛిక సి కింది ఉదాహరణలో చూపబడిన లాస్. ఇక్కడ, ది తదుపరిది () యొక్క పద్ధతి యాదృచ్ఛిక 'కోసం' లూప్ ఉపయోగించి 10 యాదృచ్ఛిక పూర్ణాంక సంఖ్యలను రూపొందించడానికి తరగతి ఉపయోగించబడుతుంది. కోడ్ ప్రకారం, 0 నుండి 99 వరకు ఉన్న ఏదైనా సంఖ్యను యాదృచ్ఛిక సంఖ్యగా రూపొందించవచ్చు, కానీ ఏదైనా యాదృచ్ఛిక సంఖ్య 95 కంటే ఎక్కువ ఉంటే, అప్పుడు ప్రోగ్రామ్ లూప్ నుండి ముగుస్తుంది.
దిగుమతి java.util. యాదృచ్ఛిక;ప్రజా తరగతియాదృచ్ఛిక 3{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
// వస్తువును ప్రకటించండి
యాదృచ్ఛిక randObj= కొత్త యాదృచ్ఛిక ();
// లూప్ను 10 సార్లు పునరావృతం చేయండి
కోసం (inti= 0;i95)
{
వ్యవస్థ .బయటకు.println('ప్రస్తుత సంఖ్య 95 కంటే ఎక్కువ');
విరామం;
}
// ప్రస్తుత యాదృచ్ఛిక సంఖ్యను ముద్రించండి
వ్యవస్థ .బయటకు.println('ప్రస్తుత సంఖ్య' +r నంబర్);
}
}
}
అవుట్పుట్:
మీరు యాదృచ్ఛిక సంఖ్య కోసం కోడ్ను అమలు చేసిన ప్రతిసారీ అవుట్పుట్ మారుతుంది. కింది అవుట్పుట్ 5 యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేసిన తర్వాత 95 కంటే ఎక్కువ యాదృచ్ఛిక సంఖ్య ఉత్పత్తి చేయబడిందని మరియు లూప్ నుండి ముగిసినట్లు చూపుతుంది.
ఉదాహరణ -4: యాదృచ్ఛిక తరగతిని ఉపయోగించి ఒక పరిధిలో యాదృచ్ఛిక సంఖ్యను రూపొందించండి
రాండమ్ క్లాస్ని ఉపయోగించి యాదృచ్ఛిక సంఖ్యలను రూపొందించే దిగువ పరిమితి డిఫాల్ట్గా 0. యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి ముందు మీరు దిగువ మరియు ఎగువ పరిమితులను ఎలా సెట్ చేయవచ్చో క్రింది ఉదాహరణ చూపుతుంది. దిగువ పరిమితి మరియు ఎగువ పరిమితి వినియోగదారు నుండి ఇన్పుట్గా తీసుకోబడుతుంది. దిగువ మరియు ఎగువ పరిమితుల ద్వారా నిర్వచించబడిన పరిధిలో ఐదు యాదృచ్ఛిక సంఖ్యలు రూపొందించబడతాయి.
దిగుమతి java.util. యాదృచ్ఛిక;దిగుమతి java.util.Scanner;
ప్రజా తరగతియాదృచ్ఛిక 4{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
// స్కానర్ వస్తువును సృష్టించండి
స్కానర్ ఇన్= కొత్తస్కానర్( వ్యవస్థ .లో);
// దిగువ పరిమితిని సెట్ చేయండి
వ్యవస్థ .బయటకు.ముద్రణ('తక్కువ పరిమితిని నమోదు చేయండి:');
intతక్కువ=లోతదుపరిది();
// ఎగువ పరిమితిని సెట్ చేయండి
వ్యవస్థ .బయటకు.ముద్రణ('ఎగువ పరిమితిని నమోదు చేయండి:');
intఅధిక=లోతదుపరిది();
// వస్తువును ప్రకటించండి
యాదృచ్ఛిక randObj= కొత్త యాదృచ్ఛిక ();
// లూప్ను 5 సార్లు పునరావృతం చేయండి
కోసం (inti= 0;i< 5;i++){
// తక్కువ మరియు అధిక మధ్య ఏదైనా యాదృచ్ఛిక సంఖ్యను రూపొందించండి
intr నంబర్=randObj.తదుపరిది((అధిక-తక్కువ) + 1) +తక్కువ;
// ప్రస్తుత యాదృచ్ఛిక సంఖ్యను ముద్రించండి
వ్యవస్థ .బయటకు.println('ప్రస్తుత సంఖ్య:' +r నంబర్);
}
// స్కానర్ వస్తువును మూసివేయండి
లోదగ్గరగా();
}
}
అవుట్పుట్:
10 తక్కువ పరిమితిగా తీసుకోబడింది, మరియు కింది అవుట్పుట్లో 50 గరిష్ట పరిమితిగా తీసుకోబడుతుంది మరియు ఈ పరిధిలో ఐదు యాదృచ్ఛిక సంఖ్యలు ఉత్పత్తి చేయబడతాయి.
ఉదాహరణ -5: యాదృచ్ఛిక తరగతి ఉపయోగించి బూలియన్ యాదృచ్ఛిక విలువలను రూపొందించండి
బూలియన్ యాదృచ్ఛిక విలువను ఉపయోగించడం ద్వారా ఉత్పత్తి చేయవచ్చు తదుపరి బూలియన్ () యొక్క పద్ధతి యాదృచ్ఛిక తరగతి. కింది ఉదాహరణ మూడు బూలియన్ విలువలను యాదృచ్ఛికంగా ఎలా సృష్టించవచ్చో చూపిస్తుంది తదుపరి బూలియన్ () పద్ధతి మరియు 'ఫర్' లూప్.
దిగుమతి java.util. యాదృచ్ఛిక;ప్రజా తరగతియాదృచ్ఛిక 5{
ప్రజా స్టాటిక్ శూన్యంప్రధాన( స్ట్రింగ్ []వాదిస్తుంది) {
// వస్తువును ప్రకటించండి
యాదృచ్ఛిక randObj= కొత్త యాదృచ్ఛిక ();
వ్యవస్థ .బయటకు.println('జనరేటెడ్ యాదృచ్ఛిక బూలియన్ విలువలు:');
// లూప్ను 3 సార్లు చేయండి
కోసం(inti=0;i< 3;i++)
{
// ఏదైనా బూలియన్ విలువను రూపొందించండి
బూలియన్ rValue=randObj.తదుపరి బూలియన్();
// ప్రస్తుత యాదృచ్ఛిక విలువను ముద్రించండి
వ్యవస్థ .బయటకు.println(rValue);
}
}
}
అవుట్పుట్:
యాదృచ్ఛికంగా విలువను ఉత్పత్తి చేయడానికి కోడ్ యొక్క అవుట్పుట్ మారవచ్చు. మూడు నిజం కింది అవుట్పుట్లో విలువలు యాదృచ్ఛికంగా ఉత్పత్తి చేయబడతాయి.
ముగింపు:
ఈ ట్యుటోరియల్లో రెండు జావా క్లాసులను ఉపయోగించి వివిధ రకాల యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి సంభావ్యత తనిఖీ, లాటరీ టికెట్ జనరేషన్ వంటి వివిధ ప్రోగ్రామింగ్ సంబంధిత పనులకు యాదృచ్ఛిక సంఖ్యను రూపొందించడం ఉపయోగపడుతుంది. ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను ప్రాక్టీస్ చేసిన తర్వాత, జావా వినియోగదారుల కోసం యాదృచ్ఛిక సంఖ్య యొక్క భావన క్లియర్ చేయబడుతుంది మరియు వారి ప్రోగ్రామింగ్ అవసరంగా వారు యాదృచ్ఛిక సంఖ్యలను రూపొందించగలరు.