జావాలో రాండమ్ నంబర్ మరియు స్ట్రింగ్ జనరేటర్‌తో ఎలా వ్యవహరించాలి?

ఈ వ్యాసం మీకు పరిచయం చేస్తుంది యాదృచ్ఛిక సంఖ్య మరియు జావాలో స్ట్రింగ్ జనరేటర్ మరియు ప్రోగ్రామాటిక్ ప్రదర్శనతో దాన్ని అనుసరించండి. ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,

• Java.util.Random
• Math.random ()
• Java.util.concurrent.ThreadLocalRandom క్లాస్
• జావాలో యాదృచ్ఛిక స్ట్రింగ్‌ను సృష్టిస్తోంది
• Math.random () ను ఉపయోగించడం
• చార్‌సెట్‌ను ఉపయోగిస్తోంది
• రెగ్యులర్ వ్యక్తీకరణలను ఉపయోగించడం

అంతర్నిర్మిత పద్ధతులు మరియు తరగతులను ఉపయోగించి జావాలో యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి మూడు పద్ధతులు ఉన్నాయి.

• Java.util.Random తరగతి
• Math.random పద్ధతి
• థ్రెడ్ లోకల్ రాండమ్ క్లాస్

కాబట్టి జావాలో యాదృచ్ఛిక సంఖ్య మరియు స్ట్రింగ్ జనరేటర్‌పై కథనాన్ని ప్రారంభిద్దాం,

జావా . ఉపయోగకరమైనది. యాదృచ్ఛికం

అన్నింటిలో మొదటిది, మేము ప్రోగ్రామ్‌లో ఈ తరగతి యొక్క ఉదాహరణను సృష్టించాలి, ఆపై మనం సృష్టించిన ఉదాహరణను ఉపయోగించి నెక్స్ట్ఇంట్ (), నెక్స్ట్ డబుల్ () వంటి వివిధ అంతర్నిర్మిత పద్ధతులను ప్రారంభించాలి.
ఈ తరగతిని ఉపయోగించి యాదృచ్ఛిక సంఖ్యల రకం పూర్ణాంకాలు, ఫ్లోట్, డబుల్, లాంగ్, బూలియన్లను సృష్టించవచ్చు.
సంఖ్యను ఉత్పత్తి చేసే వరకు ఎగువ బౌండ్‌ను నిర్వచించే పద్ధతులకు వాదనలు పంపవచ్చు. ఉదాహరణ కోసం, నెక్స్ట్ఇంట్ (4) 0 నుండి 3 పరిధిలో సంఖ్యలను ఉత్పత్తి చేస్తుంది (రెండూ కలుపుకొని).

ఉదాహరణ 1:

// యాదృచ్ఛిక సంఖ్య ఉత్పత్తిని చూపించడానికి ఒక జావా ప్రోగ్రామ్ // java.util.Random దిగుమతి java.util.Random పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// రాండమ్ క్లాస్ రాండమ్ రాండ్ = క్రొత్త రాండమ్ () // 0 నుండి 99 పరిధిలో యాదృచ్ఛిక పూర్ణాంకాలను ఉత్పత్తి చేస్తుంది int int1 = rand.nextInt (100) int int2 = rand.nextInt (100) // యాదృచ్ఛిక పూర్ణాంకాలను ముద్రించడం System.out.println ('రాండమ్ పూర్ణాంకాలు:>' + int1) System.out.println ('రాండమ్ పూర్ణాంకాలు:>' + int2) // యాదృచ్ఛిక రెట్టింపు రెట్టింపు డబుల్ dub1 = rand.nextDouble () డబుల్ డబ్ 2 = rand.nextDouble () // ప్రింటింగ్ రాండమ్ డబుల్స్ System.out.println (' రాండమ్ డబుల్స్:> '+ డబ్ 1) System.out.println (' రాండమ్ డబుల్స్:> '+ డబ్ 2)}}

అవుట్పుట్:

ఒరాకిల్ pl sql ఉత్తమ పద్ధతులను నిర్వహించడంలో లోపం

ఉదాహరణ:

యాదృచ్ఛిక సంఖ్య ఉత్పత్తిని చూపించడానికి // జావా ప్రోగ్రామ్ // ఉపయోగించి java.util.Random దిగుమతి java.util.Random పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// రాండమ్ క్లాస్ రాండమ్ రాండ్ = క్రొత్తది యాదృచ్ఛిక () // 0 నుండి 9 పరిధిలో యాదృచ్ఛిక పూర్ణాంకాలను ఉత్పత్తి చేస్తుంది int int1 = rand.nextInt (10) // యాదృచ్ఛిక పూర్ణాంక వ్యవస్థను ముద్రించడం System.out.println ('రాండమ్ పూర్ణాంకం:>' + int1)}}

అవుట్పుట్:

ఈ వ్యాసంతో ముందుకు సాగుతోంది

మఠం . యాదృచ్ఛిక ( )

మఠం అని పిలువబడే తరగతి అనేక రకాలైన సంఖ్యా కార్యకలాపాలను నిర్వహించడానికి వివిధ పద్ధతులను కలిగి ఉంటుంది, ఇందులో లాగరిథమ్‌లు, ఎక్స్‌పోనెన్షియేషన్ పరిష్కరించడం మొదలైనవి ఉన్నాయి. ఈ కార్యకలాపాలలో యాదృచ్ఛిక () ఉంది, ఇది 0.0 మరియు 1.0 పరిధి మధ్య యాదృచ్ఛిక సంఖ్యల రకం డబుల్స్ ఉత్పత్తి చేయడానికి ఉపయోగించబడుతుంది. . ఈ పద్ధతి డబుల్ విలువను 0.0 కంటే ఎక్కువ లేదా సమానంగా ఉంటుంది మరియు సానుకూల సంకేతంతో పాటు 1.0 కంటే తక్కువ లేదా సమానంగా ఉంటుంది. యాదృచ్ఛిక () ద్వారా తిరిగి ఇవ్వబడే విలువలు యంత్రం ద్వారా యాదృచ్ఛికంగా ఎంపిక చేయబడతాయి.

ఉదాహరణ 1:

// యాదృచ్ఛిక సంఖ్యలను దిగుమతి చేసుకోవటానికి // Math.random () యొక్క పనిని ప్రదర్శించడానికి ఒక జావా ప్రోగ్రామ్ java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// డేటా రకం యొక్క యాదృచ్ఛిక విలువను రెట్టింపు చేస్తుంది System.out.println ('రాండమ్ విలువ:' + Math.random ())}}

అవుట్పుట్:

యాదృచ్ఛికతను తనిఖీ చేయడానికి ప్రోగ్రామ్‌ను మరోసారి అమలు చేయడానికి అనుమతిస్తుంది.

// యాదృచ్ఛిక సంఖ్యలను దిగుమతి చేసుకోవటానికి // Math.random () యొక్క పనిని ప్రదర్శించడానికి ఒక జావా ప్రోగ్రామ్ java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// డేటా రకం యొక్క యాదృచ్ఛిక విలువను రెట్టింపు చేస్తుంది System.out.println ('మరొక రాండమ్ విలువ:' + Math.random ())}}

అవుట్పుట్:

జావాలో యాదృచ్ఛిక సంఖ్య మరియు స్ట్రింగ్ జనరేటర్‌పై ఈ కథనంతో కదులుతోంది

Java.util.concurrent.ThreadLocalRandom క్లాస్

డేటా రకం పూర్ణాంకాలు, డబుల్స్, బూలియన్లు మొదలైన వాటి యొక్క యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడానికి జావా 1.7 లో ఈ తరగతి ప్రవేశపెట్టబడింది.
ఉదాహరణ 1:

// యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడానికి థ్రెడ్‌లోకల్ రాండమ్ // యొక్క పనిని ప్రదర్శించడానికి జావా ప్రోగ్రామ్. దిగుమతి java.util.concurrent.ThreadLocalRandom పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// 0 నుండి 99 int పరిధిలో యాదృచ్ఛిక పూర్ణాంకాలను ఉత్పత్తి చేస్తుంది int2 = ThreadLocalRandom.current (). NextInt () // యాదృచ్ఛిక పూర్ణాంకాన్ని ముద్రించడం System.out.println ('రాండమ్ ఇంటీజర్స్:' + int2) // రాండమ్ డబుల్స్ డబుల్ డబ్ 1 = థ్రెడ్‌లోకల్ రాండమ్.కరెంట్ (). తదుపరి డబుల్ () డబుల్ డబ్ 2 = థ్రెడ్‌లోకల్ రాండమ్.కరెంట్ (). నెక్స్ట్‌డబుల్ () // రాండమ్ డబుల్స్ సిస్టమ్‌ను ముద్రించడం. out.println ('రాండమ్ డబుల్స్:' + డబ్ 1) System.out.println ('రాండమ్ డబుల్స్:' + డబ్ 2)}}

అవుట్పుట్:

ఉదాహరణ 2:

యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడానికి థ్రెడ్ లోకల్ రాండమ్ // యొక్క పనిని ప్రదర్శించడానికి // జావా ప్రోగ్రామ్. దిగుమతి java.util.concurrent.ThreadLocalRandom పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// యాదృచ్ఛిక బూలియన్లను ఉత్పత్తి చేస్తుంది బూలియన్ bool1 = ThreadLocalRandom.current (). NextBoolean () బూలియన్ bool2 = ThreadLocalRandom.current (). () // రాండమ్ బూలియన్స్ System.out.println ('రాండమ్ బూలియన్స్:' + bool1) System.out.println ('రాండమ్ బూలియన్స్:' + bool2)}}

అవుట్పుట్:

జావాలో యాదృచ్ఛిక సంఖ్య మరియు స్ట్రింగ్ జనరేటర్‌పై ఈ కథనంతో కదులుతోంది

జావాలో యాదృచ్ఛిక స్ట్రింగ్‌ను సృష్టిస్తోంది

మేము ఈ క్రింది పద్ధతులను ఉపయోగించి యాదృచ్ఛిక ఆల్ఫాన్యూమరిక్ స్ట్రింగ్‌ను రూపొందించవచ్చు:

జావాలో యాదృచ్ఛిక సంఖ్య మరియు స్ట్రింగ్ జనరేటర్‌పై ఈ కథనంతో కదులుతోంది

గణితాన్ని ఉపయోగించడం . యాదృచ్ఛిక ( )

భావనను మంచి మార్గంలో అర్థం చేసుకోవడానికి క్రింద ఒక ఉదాహరణ ఉంది.

// యాదృచ్ఛిక ఆల్ఫాన్యూమరిక్ స్ట్రింగ్‌ను ఉత్పత్తి చేసే జావా ప్రోగ్రామ్ // Math.random () పద్ధతిని ఉపయోగించి పబ్లిక్ క్లాస్ మెయిన్ {// యాదృచ్ఛిక స్ట్రింగ్ నిడివిని సృష్టించడానికి ఒక ఫంక్షన్‌ను నిర్వచించండి n స్టాటిక్ స్ట్రింగ్ అవసరం స్ట్రింగ్ (int n) {// అక్షర యాదృచ్ఛికంగా ఎంచుకుంది ఈ స్ట్రింగ్ స్ట్రింగ్ నుండి
 అవుట్పుట్: 
జావాలో యాదృచ్ఛిక సంఖ్య మరియు స్ట్రింగ్ జనరేటర్‌పై ఈ కథనంతో కదులుతోంది
 చార్‌సెట్‌ను ఉపయోగిస్తోంది 
మేము ఇక్కడ వేరే ప్యాకేజీని ఉపయోగించాలి, అనగా java.nio.charset ప్యాకేజీ. 
క్రింద ఇలస్ట్రేటెడ్ ఉదాహరణ.
// జావా ప్రోగ్రామ్ చార్సెట్ దిగుమతి java.util ను ఉపయోగించి యాదృచ్ఛిక ఆల్ఫా న్యూమరిక్ స్ట్రింగ్‌ను ఉత్పత్తి చేస్తుంది. * దిగుమతి java.nio.charset. * క్లాస్ మెయిన్ {స్టాటిక్ స్ట్రింగ్ అవసరం స్ట్రింగ్ (int n) length // పొడవు డిక్లరేషన్ బైట్ [] శ్రేణి = కొత్త బైట్ [256] క్రొత్త రాండమ్ (). తదుపరి బైట్స్ (శ్రేణి) స్ట్రింగ్ రాండమ్‌స్ట్రింగ్ = కొత్త స్ట్రింగ్ (శ్రేణి, చార్సెట్.ఫోర్నేమ్ ('యుటిఎఫ్ -8')) // స్ట్రింగ్‌బఫర్ స్ట్రింగ్‌బఫర్‌ను సృష్టించడం రా = కొత్త స్ట్రింగ్‌బఫర్ () // మొదటి 20 ఆల్ఫాన్యూమరిక్ అక్షరాలను జోడించడం (int i = 0 i = 'a' && ch = 'A' && ch = '0' && ch 0)) {ra.append (ch) n--}} // ఫలిత స్ట్రింగ్ రిటర్న్ తిరిగి రా.ట్రాస్ట్రింగ్ ()} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {// యాదృచ్ఛిక ఆల్ఫాన్యూమరిక్ స్ట్రింగ్ యొక్క పరిమాణం int n = 10 // ఆల్ఫాన్యూమరిక్ స్ట్రింగ్‌ను పొందండి మరియు ప్రదర్శించండి System.out.println (RequiredString (n))}}
 అవుట్పుట్: 
జావాలో యాదృచ్ఛిక సంఖ్య మరియు స్ట్రింగ్ జనరేటర్‌పై ఈ కథనంతో కదులుతోంది
 రెగ్యులర్ వ్యక్తీకరణలను ఉపయోగించడం 
అమలు క్రింది విధంగా ఉంది.
// జావా ప్రోగ్రామ్ యాదృచ్ఛిక ఆల్ఫాన్యూమరిక్ స్ట్రింగ్‌ను ఉత్పత్తి చేస్తుంది // రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ పద్ధతిని ఉపయోగించి దిగుమతి java.util. * దిగుమతి java.nio.charset. * క్లాస్ మెయిన్ {స్టాటిక్ స్ట్రింగ్ getAlphaNumericString (int n) length // పొడవు డిక్లరేషన్ బైట్ [] శ్రేణి = క్రొత్త బైట్ [256] కొత్త రాండమ్ (). నెక్స్ట్‌బైట్స్ (అర్రే) స్ట్రింగ్ రాండమ్‌స్ట్రింగ్ = కొత్త స్ట్రింగ్ (శ్రేణి, చార్సెట్.ఫోర్నేమ్ ('యుటిఎఫ్ -8')) // స్ట్రింగ్‌బఫర్ స్ట్రింగ్‌బఫర్‌ను సృష్టిస్తోంది రా = కొత్త స్ట్రింగ్‌బఫర్ () // అన్ని స్పేషియల్‌లను తొలగించండి చార్ స్ట్రింగ్ ఆల్ఫాన్యూమరిక్ స్ట్రింగ్ = రాండమ్ స్ట్రింగ్ .రేప్లేస్అల్ ('[^ A-Za-z0-9]', '') // ఉత్పత్తి చేసిన యాదృచ్ఛిక స్ట్రింగ్ నుండి మొదటి 20 ఆల్ఫాన్యూమరిక్ అక్షరాలను // జోడించండి (int k = 0 k 0) || Character.isDigit (AlphaNumericString.charAt (k)) && (n> 0)) {ra.append (AlphaNumericString.charAt (k)) n--}} // ఫలిత స్ట్రింగ్ రిటర్న్ రా.టో స్ట్రింగ్ ()} పబ్లిక్ స్టాటిక్ void main (స్ట్రింగ్ [] అర్గ్స్) {// యాదృచ్ఛిక ఆల్ఫాన్యూమరిక్ స్ట్రింగ్ యొక్క పరిమాణం int n = 15 // ఆల్ఫాన్యూమరిక్ స్ట్రింగ్‌ను పొందండి మరియు ప్రదర్శించండి System.out.println (getAlphaNumericString (n))}}
 అవుట్పుట్: 
జావాలో అనామక తరగతి అంటే ఏమిటి
ఈ విధంగా మేము ఈ వ్యాసం ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి    విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.