दिलचस्प पोस्ट
jquery $ (window) .height () दस्तावेज़ ऊंचाई वापस कर रहा है एंड्रॉइड: गतिविधि के जीवन चक्र के दौरान कहां पर क्रिएट ऑप्शन मेनू पर कॉल किया जाता है? साधारण शब्दों में 3 एनएफ और बीसीएनएफ के बीच अंतर (8 वर्षीय को समझाने में सक्षम होना चाहिए) सी # कोड में पार्स (बड़ा) एक्सएमएल का सबसे अच्छा तरीका क्या है? एंड्रॉइड: अज्ञातहास्ट अपवाद पायथन में विधि पैरामीटर नाम प्राप्त करना कैसे जांच करने के लिए कैसे डेटा स्थानांतरण दो ऑब्जेक्ट में सी # में समान गुण हैं? CubicCurve2D दो JInternalFrame उदाहरणों को जोड़ने कमांड / यूएसआर / बिन / कोडेसिन असफल कोड 1 के साथ विफल हुआ एक टुकड़ा (हनीकॉब) में मानचित्रदृश्य एचटीटीपीआरएल कनेक्शन के साथ पोस्ट का उपयोग करते हुए फाइलें भेज रहा है JQuery.ajax () यूआरएल को एक पैरामीटर क्यों जोड़ता है? बाहरी स्पर्श को बंद करने से एंड्रॉइड गतिविधि संवाद रोकें स्थिर चर को बुरा क्यों माना जाता है? iPhone / iOS JSON पार्सिंग ट्यूटोरियल

यादृच्छिक अल्फा-न्यूमेरिक स्ट्रिंग कैसे उत्पन्न करें?

मैं छद्म-यादृच्छिक अल्फा-न्यूमेरिक स्ट्रिंग उत्पन्न करने के लिए एक सरल जावा एल्गोरिथम की तलाश कर रहा था। मेरी स्थिति में यह एक अद्वितीय सत्र / कुंजी पहचानकर्ता के रूप में उपयोग किया जाएगा जो "संभवतः" 500K + पीढ़ी (मेरी ज़रूरतों को वास्तव में कुछ और अधिक परिष्कृत करने की आवश्यकता नहीं है) पर अद्वितीय होगा। आदर्श रूप से, मैं अपनी विशिष्टता के आधार पर लंबाई निर्दिष्ट करने में सक्षम होगा। उदाहरण के लिए, लंबाई 12 की एक जनरेटेड स्ट्रिंग "AEYGF7K0DM1X" जैसी कुछ दिखाई दे सकती है

Solutions Collecting From Web of "यादृच्छिक अल्फा-न्यूमेरिक स्ट्रिंग कैसे उत्पन्न करें?"

कलन विधि

एक यादृच्छिक स्ट्रिंग उत्पन्न करने के लिए, जब तक कि स्ट्रिंग वांछित लंबाई तक पहुंच न हो जाए, तब तक स्वीकार्य प्रतीकों के सेट से अनियमित वर्णित कन्टेनेट वर्ण।

कार्यान्वयन

यादृच्छिक पहचानकर्ता उत्पन्न करने के लिए यहां कुछ बहुत आसान और बहुत लचीला कोड है महत्वपूर्ण एप्लिकेशन नोट्स के लिए निम्न जानकारी पढ़ें

 import java.security.SecureRandom; import java.util.Locale; import java.util.Objects; import java.util.Random; public class RandomString { /** * Generate a random string. */ public String nextString() { for (int idx = 0; idx < buf.length; ++idx) buf[idx] = symbols[random.nextInt(symbols.length)]; return new String(buf); } public static final String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; public static final String lower = upper.toLowerCase(Locale.ROOT); public static final String digits = "0123456789"; public static final String alphanum = upper + lower + digits; private final Random random; private final char[] symbols; private final char[] buf; public RandomString(int length, Random random, String symbols) { if (length < 1) throw new IllegalArgumentException(); if (symbols.length() < 2) throw new IllegalArgumentException(); this.random = Objects.requireNonNull(random); this.symbols = symbols.toCharArray(); this.buf = new char[length]; } /** * Create an alphanumeric string generator. */ public RandomString(int length, Random random) { this(length, random, alphanum); } /** * Create an alphanumeric strings from a secure generator. */ public RandomString(int length) { this(length, new SecureRandom()); } /** * Create session identifiers. */ public RandomString() { this(21); } } 

उपयोग के उदाहरण

8-वर्ण अभिज्ञापक के लिए असुरक्षित जनरेटर बनाएँ:

 RandomString gen = new RandomString(8, ThreadLocalRandom.current()); 

सत्र पहचानकर्ता के लिए एक सुरक्षित जनरेटर बनाएं:

 RandomString session = new RandomString(); 

प्रिंट करने के लिए आसान-से-पढ़ने वाले कोड वाले जनरेटर बनाएं कम प्रतीकों का उपयोग करने के लिए स्ट्रिंग पूर्ण अल्फ़ान्यूमेरिक स्ट्रिंग्स से अधिक है:

 String easy = RandomString.digits + "ACEFGHJKLMNPQRUVWXYabcdefhijkprstuvwx"; RandomString tickets = new RandomString(23, new SecureRandom(), easy); 

सत्र पहचानकर्ता के रूप में उपयोग करें

जेनरेट करने वाले सत्र आइडेंटिफ़ार्स जो अद्वितीय होने की संभावना है, यह काफी अच्छा नहीं है, या आप बस एक साधारण काउंटर का उपयोग कर सकते हैं। हमलावर सत्रों को हाइजैक करते हैं जब अनुमान लगाने योग्य आइडेंटिफ़ायर का उपयोग किया जाता है।

लंबाई और सुरक्षा के बीच तनाव है छोटे पहचानकर्ता आसानी से अनुमान लगाते हैं, क्योंकि कम संभावनाएं हैं लेकिन अधिक पहचानकर्ता अधिक भंडारण और बैंडविड्थ का उपभोग करते हैं प्रतीकों का एक बड़ा समूह मदद करता है, लेकिन अगर पहचानकर्ता को यूआरएल में शामिल किया गया हो या हाथ से पुनः दर्ज किया गया हो तो एन्कोडिंग समस्याओं का कारण हो सकता है

सत्र पहचानकर्ता के लिए यादृच्छिकता, या एन्ट्रापी के अंतर्निहित स्रोत क्रिप्टोग्राफी के लिए डिज़ाइन किए गए एक यादृच्छिक संख्या जनरेटर से आना चाहिए। हालांकि, इन जेनरेटर को शुरू करने के लिए कभी-कभी कम्प्यूटेशनल रूप से महंगा या धीमा हो सकता है, इसलिए संभव है कि उन्हें पुनः उपयोग करने के लिए प्रयास किया जाना चाहिए।

वस्तु पहचानकर्ता के रूप में उपयोग करें

हर एप्लिकेशन को सुरक्षा की आवश्यकता नहीं है रैंडम असाइनमेंट कई संस्थाओं के लिए किसी भी समन्वय या विभाजन के बिना साझा किए गए अंतरिक्ष में पहचानकर्ता उत्पन्न करने के लिए एक कारगर तरीका हो सकता है। समन्वय धीमा हो सकता है, खासकर एक संकलित या वितरित माहौल में, और एक स्थान को विभाजित करने से समस्याओं का कारण बनता है, जब संस्थाएं बहुत छोटे या बहुत बड़े शेयरों के साथ समाप्त होती हैं

आइडेंटिफ़ार्स बिना अनपेक्षित बनाने के उपायों को अन्य तरीकों से संरक्षित किया जाना चाहिए, यदि कोई हमलावर उन्हें देख और उसे हेरफेर कर सकता है, जैसा कि अधिकांश वेब अनुप्रयोगों में होता है एक अलग प्राधिकरण प्रणाली होनी चाहिए जो ऑब्जेक्ट की सुरक्षा करता हो, जिनकी आइडेंटिफ़ायर किसी हमलावर द्वारा एक्सेस की अनुमति के बिना अनुमान लगाया जा सकता है।

पहचाने जाने वालों की अनुमानित कुल संख्या को पहचानने के लिए लंबे समय तक पहचान बनाने वाले पहचानकर्ताओं का उपयोग करने के लिए देखभाल भी ली जानी चाहिए। इसे "जन्मदिन विरोधाभास" कहा जाता है। एक टक्कर की संभावना, पी , लगभग 2/2 ( एक्स ) है, जहां एन वास्तव में उत्पन्न पहचानकर्ताओं की संख्या है, क्यू वर्णमाला में विशिष्ट प्रतीकों की संख्या है, और एक्स आइडेंटिफ़ायर की लंबाई है यह बहुत छोटी संख्या होना चाहिए, जैसे 2 -50 या उससे कम

इस काम से पता चलता है कि 500 ​​के 15-वर्ण पहचानकर्ता के बीच टकराव का मौका लगभग 2-52 है , जो संभवतः कॉस्मिक किरणों से अनदेखा त्रुटियों की तुलना में कम होने की संभावना है।

UUIDs के साथ तुलना करें

उनके विनिर्देश के मुताबिक, UUIDs को अप्रत्याशित होने के लिए डिज़ाइन नहीं किया गया है, और सत्र पहचानकर्ता के रूप में उपयोग नहीं किया जाना चाहिए

यूयूआईडी अपने मानक प्रारूप में बहुत सारे स्थान लेते हैं: एन्ट्रापी के केवल 122 बिट के लिए 36 अक्षर। ("यादृच्छिक" यूआईआईडी के सभी बिट बेतरतीब ढंग से चुने गए हैं।) एक बेतरतीब ढंग से चुनी गई अल्फ़ान्यूमेरिक स्ट्रिंग केवल 21 अक्षरों में अधिक एंटरपीपी पैक करती है।

यूयूआईडी लचीला नहीं हैं; उनके पास एक मानकीकृत संरचना और लेआउट है यह उनका मुख्य गुण है और साथ ही उनकी मुख्य कमजोरी है। बाहरी पार्टी के साथ सहयोग करते समय, UUIDs द्वारा प्रदत्त मानकीकरण सहायक हो सकता है। विशुद्ध रूप से आंतरिक उपयोग के लिए, वे अक्षम हो सकते हैं।

जावा सीधे इसे करने का एक तरीका प्रदान करता है यदि आप डैश नहीं चाहते हैं, तो वे पट्टी करना आसान है। बस uuid.replace("-", "")

 import java.util.UUID; public class randomStringGenerator { public static void main(String[] args) { System.out.println(generateString()); } public static String generateString() { String uuid = UUID.randomUUID().toString(); return "uuid = " + uuid; } } 

आउटपुट:

 uuid = 2d7428a6-b58c-4008-8575-f05549f16316 

अगर आप अपाचे वर्गों का उपयोग करने में खुशी रखते हैं, तो आप org.apache.commons.text.RandomStringGenerator (commons-text) का उपयोग कर सकते हैं।

उदाहरण:

 RandomStringGenerator randomStringGenerator = new RandomStringGenerator.Builder() .withinRange('0', 'z') .filteredBy(CharacterPredicates.LETTERS, CharacterPredicates.DIGITS) .build(); randomStringGenerator.generate(12); // toUpperCase() if you want 

कॉमन्स-लैंग 3.6 के बाद से, RandomStringUtils को बहिष्कृत किया गया है।

 static final String AB = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; static SecureRandom rnd = new SecureRandom(); String randomString( int len ){ StringBuilder sb = new StringBuilder( len ); for( int i = 0; i < len; i++ ) sb.append( AB.charAt( rnd.nextInt(AB.length()) ) ); return sb.toString(); } 

एक पंक्ति में:

 Long.toHexString(Double.doubleToLongBits(Math.random())); 

http://mynotes.wordpress.com/2009/07/23/java-generating-random-string/

आप इसके लिए अपाचे लाइब्रेरी का उपयोग कर सकते हैं: RandomStringUtils

 RandomStringUtils.randomAlphanumeric(20).toUpperCase(); 

डॉलर का उपयोग करना सरल होना चाहिए:

 // "0123456789" + "ABCDE...Z" String validCharacters = $('0', '9').join() + $('A', 'Z').join(); String randomString(int length) { return $(validCharacters).shuffle().slice(length).toString(); } @Test public void buildFiveRandomStrings() { for (int i : $(5)) { System.out.println(randomString(12)); } } 

यह कुछ ऐसा उत्पादन करता है:

 DKL1SBH9UJWC JH7P0IT21EA5 5DTI72EO6SFU HQUMJTEBNF7Y 1HCR6SKYWGT7 

यहां यह जावा में है:

 import static java.lang.Math.round; import static java.lang.Math.random; import static java.lang.Math.pow; import static java.lang.Math.abs; import static java.lang.Math.min; import static org.apache.commons.lang.StringUtils.leftPad public class RandomAlphaNum { public static String gen(int length) { StringBuffer sb = new StringBuffer(); for (int i = length; i > 0; i -= 12) { int n = min(12, abs(i)); sb.append(leftPad(Long.toString(round(random() * pow(36, n)), 36), n, '0')); } return sb.toString(); } } 

यहां एक नमूना चलाया गया है:

 scala> RandomAlphaNum.gen(42) res3: java.lang.String = uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy 

यहां आश्चर्यजनक कोई भी यह सुझाव नहीं दिया है कि:

 import java.util.UUID UUID.randomUUID().toString(); 

आसान।

इसका लाभ यूयूआईडी बहुत अच्छा और लंबा है और इसकी टक्कर लगभग असंभव है।

विकिपीडिया में इसके बारे में एक अच्छी व्याख्या है:

"… अगले 100 वर्षों के लिए हर दूसरे 1 अरब यूयूआईडी बनाने के बाद, सिर्फ एक डुप्लिकेट बनाने की संभावना लगभग 50% होगी।"

http://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates

पहले 4 बिट संस्करण प्रकार और 2 भिन्न के लिए हैं, इसलिए आपको 122 बिट्स यादृच्छिक मिलेंगे। इसलिए यदि आप चाहते हैं कि आप UUID के आकार को कम करने के लिए अंत से कम कर सकते हैं। यह अनुशंसित नहीं है लेकिन आपके पास अभी भी यादृच्छिकता का भार है, आपके 500k रिकॉर्ड के लिए आसान है

यह बिना किसी बाहरी पुस्तकालयों के आसानी से प्राप्त हो सकता है

1. क्रिप्टोग्राफिक छद्म यादृच्छिक डेटा जनरेशन

पहले आपको क्रिप्टोग्राफिक पीआरएनजी की जरूरत है। जावा में SecureRandom है जो आमतौर पर मशीन पर सबसे अच्छा एन्ट्रापी स्रोत का उपयोग करता है (जैसे /dev/random )। यहां अधिक पढ़ें

 SecureRandom rnd = new SecureRandom(); byte[] token = new byte[byteLength]; rnd.nextBytes(token); 

नोट: SecureRandom यादृच्छिक बाइट्स उत्पन्न करने के जावा में सबसे धीमी, लेकिन सबसे सुरक्षित तरीका है। मैं हालांकि यहां प्रदर्शन पर विचार नहीं करने की सिफारिश करता हूं क्योंकि आमतौर पर आपके आवेदन पर कोई वास्तविक असर नहीं होता है, जब तक आपको प्रति सेकंड लाखों टोकन नहीं उत्पन्न होते हैं।

2. संभावित मानों की आवश्यक जगह

इसके बाद आपको यह तय करना होगा कि आपके टोकन को कितना "अनूठा" होना चाहिए। एंट्रोपी पर विचार करने का पूरा और एकमात्र बिंदु यह सुनिश्चित करना है कि सिस्टम ब्रूट बल के हमलों का विरोध कर सकता है: संभावित मूल्यों की जगह इतनी बड़ी होनी चाहिए कि किसी भी हमलावर केवल गैर-लुदक समय 1 में मूल्यों का नगण्य अनुपात का प्रयास कर सके। यादृच्छिक यूयूआईडी जैसे अद्वितीय पहचानकर्ता 122 बिट एंटरपी (यानी 2 ^ 122 = 5.3×10 ^ 36) हैं – टक्कर की संभावना "* (…) है क्योंकि दोहरीकरण की एक अरब संभावना में एक हो, 103 खरब संस्करण 4 यूयूआईडी 2 उत्पन्न होनी चाहिए " हम 128 बिट का चयन करेंगे क्योंकि यह बिल्कुल 16 बाइट्स में फिट बैठता है और मूल रूप से प्रत्येक के लिए अद्वितीय होने के लिए अत्यधिक पर्याप्त रूप में देखा जाता है, लेकिन सबसे चरम, मामलों का उपयोग करें और आपको डुप्लिकेट के बारे में सोचना नहीं पड़ता है यहां जन्मदिन की समस्या के सरल विश्लेषण सहित एन्ट्रोपी की एक सरल तुलना तालिका है ।

टोकन आकार की तुलना

साधारण आवश्यकताओं के लिए 8 या 12 बाइट लंबाई पर्याप्त हो सकती है, लेकिन 16 बाइट्स के साथ आप "सुरक्षित पक्ष" पर हैं

और वह मूल रूप से यह है आखिरी बात एन्कोडिंग के बारे में सोचना है ताकि इसे प्रिंट करने योग्य पाठ (पढ़ा, एक String ) के रूप में प्रदर्शित किया जा सके।

3. पाठ एन्कोडिंग के लिए बाइनरी

विशिष्ट एन्कोडिंग में शामिल हैं:

  • Base64 प्रत्येक अक्षर 6 बीट बनाकर 33% ओवरहेड का निर्माण करते हैं। दुर्भाग्य से जेडीके में कोई मानक कार्यान्वयन नहीं है ( एंड्रॉइड में है ) लेकिन कई लाइब्रेरी मौजूद हैं जो इसे जोड़ते हैं नकारात्मक पक्ष यह है कि Base64 उदाहरण के लिए सुरक्षित नहीं है। यूआरएल और अधिक फ़ाइल सिस्टम में अतिरिक्त एनकोडिंग की आवश्यकता होती है (जैसे यूआरएल एन्कोडिंग )। उदाहरण पैडिंग के साथ 16 बाइट एन्कोडिंग: XfJhfv3C0P6ag7y9VQxSbw==

  • Base32 प्रत्येक अक्षर 5 बीट बनाते हुए 40% ओवरहेड बनाते हैं। यह 2-7 और 2-7 उपयोग करेगा, जबकि केस-असंवेदनशील अल्फा-न्यूमेरिक होने के दौरान यह काफी कुशलता से स्थान बना रहा है। Base64 तरह Base64 में कोई मानक कार्यान्वयन नहीं है। WUPIL5DQTZGMF4D3NX5L7LNFOY बिना 16 बाइट्स एन्कोडिंग: WUPIL5DQTZGMF4D3NX5L7LNFOY

  • Base16 (हेक्स) प्रत्येक वर्ण 4 Base16 प्रत्येक बाइट में 2 वर्णों की आवश्यकता होती है (यानी 16 बाइट लंबाई 32 की स्ट्रिंग बनाते हैं)। इसलिए हेक्स Base32 तुलना में कम जगह कुशल है, लेकिन अधिकांश मामलों (यूआरएल) में उपयोग करने के लिए सुरक्षित है क्योंकि यह केवल 0-9 और A से F का उपयोग करता है। उदाहरण एन्कोडिंग 16 बाइट्स: 4fa3dd0f57cb3bf331441ed285b27735 यहाँ हेक्स को परिवर्तित करने के बारे में एक SO चर्चा देखें

बेसएटी और विदेशी बेस 122 जैसी अतिरिक्त एन्कोडिंग बेहतर / बदतर स्थान की दक्षता के साथ मौजूद हैं। आप अपना स्वयं का एन्कोडिंग बना सकते हैं (जो मूल तौर पर इस धागे में सबसे अधिक उत्तर देते हैं) लेकिन मैं इसके विरुद्ध सलाह दूंगा, अगर आपके पास बहुत विशिष्ट आवश्यकताएं नहीं हैं विकिपीडिया लेख में अधिक एन्कोडिंग योजनाएं देखें

4. सारांश और उदाहरण

  • सुरक्षितरेन्डम का उपयोग करें
  • संभावित मूल्यों के कम से कम 16 बाइट्स (2 ^ 128) का उपयोग करें
  • आपकी आवश्यकताओं (आमतौर पर hex या base32 यदि आपको इसकी ज़रूरत है तो अल्फ़ा-संख्यात्मक) के अनुसार एन्कोड करें

नहीं

  • … अपने घर का काढ़ा एन्कोडिंग का उपयोग करें: बेहतर बनाए रखने योग्य और दूसरों के लिए पठनीय यदि वे देखते हैं कि एक बार में छड़ें बनाने के लिए लूपों के लिए अजीब के बजाय आप किस मानक एन्कोडिंग का उपयोग करते हैं
  • यूयूआईडी का उपयोग करें: आप एन्ट्रापी के 6 बिट्स को बर्बाद कर रहे हैं और वर्बोज़ स्ट्रिंग का प्रतिनिधित्व करते हैं

उदाहरण: हेक्स टोकन जेनरेटर

 public static String generateRandomHexToken(int byteLength) { SecureRandom secureRandom = new SecureRandom(); byte[] token = new byte[byteLength]; secureRandom.nextBytes(token); return new BigInteger(1, token).toString(16); //hex encoding } //generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd 

उदाहरण: उपकरण

यदि आप तैयार-से-उपयोग करने वाले क्लॉ उपकरण चाहते हैं तो आप पासा का उपयोग कर सकते हैं: https://github.com/patrickfav/dice

एक छोटा और आसान समाधान है, लेकिन केवल छोटे और संख्यात्मक उपयोग करता है:

  r = new util.Random (); Long.toString (Math.abs (r.nextLong ()), 36); 

आकार का आधार 36 के आधार पर होता है और इसे आगे सुधार नहीं किया जा सकता है। बेशक आप कई उदाहरण जोड़ सकते हैं

 public static String generateSessionKey(int length){ String alphabet = new String("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); //9 int n = alphabet.length(); //10 String result = new String(); Random r = new Random(); //11 for (int i=0; i<length; i++) //12 result = result + alphabet.charAt(r.nextInt(n)); //13 return result; } 

जावा 8 में एक विकल्प है:

 static final Random random = new Random(); // Or SecureRandom static final int startChar = (int) '!'; static final int endChar = (int) '~'; static String randomString(final int maxLength) { final int length = random.nextInt(maxLength + 1); return random.ints(length, startChar, endChar + 1) .mapToObj((i) -> (char) i) .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) .toString(); } 
 import java.util.Random; public class passGen{ //Verison 1.0 private static final String dCase = "abcdefghijklmnopqrstuvwxyz"; private static final String uCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private static final String sChar = "!@#$%^&*"; private static final String intChar = "0123456789"; private static Random r = new Random(); private static String pass = ""; public static void main (String[] args) { System.out.println ("Generating pass..."); while (pass.length () != 16){ int rPick = r.nextInt(4); if (rPick == 0){ int spot = r.nextInt(25); pass += dCase.charAt(spot); } else if (rPick == 1) { int spot = r.nextInt (25); pass += uCase.charAt(spot); } else if (rPick == 2) { int spot = r.nextInt (7); pass += sChar.charAt(spot); } else if (rPick == 3){ int spot = r.nextInt (9); pass += intChar.charAt (spot); } } System.out.println ("Generated Pass: " + pass); } } 

तो यह क्या करता है बस स्ट्रिंग में पासवर्ड जोड़ता है और … अच्छा काम करता है इसे जांचें … बहुत सरल। मैने यह लिखा

यूयूआईडी का प्रयोग करना असुरक्षित है, क्योंकि यूयूआईडी के कुछ हिस्सों को यादृच्छिक नहीं है। @ एरिकसन की प्रक्रिया बहुत ही सुव्यवस्थित है, लेकिन वही लम्बाई का तार नहीं बनाती है निम्नलिखित स्निपेट पर्याप्त होना चाहिए:

 /* * The random generator used by this class to create random keys. * In a holder class to defer initialization until needed. */ private static class RandomHolder { static final Random random = new SecureRandom(); public static String randomKey(int length) { return String.format("%"+length+"s", new BigInteger(length*5/*base 32,2^5*/, random) .toString(32)).replace('\u0020', '0'); } } 

length*5 क्यों चुनना length*5 चलो लंबाई 1 की एक यादृच्छिक स्ट्रिंग के सरल मामले को मान लेते हैं, इसलिए एक यादृच्छिक चरित्र सभी अंक 0-9 और अक्षर az युक्त एक यादृच्छिक वर्ण पाने के लिए, हमें 0 और 35 के बीच एक यादृच्छिक संख्या की आवश्यकता होगी ताकि प्रत्येक एक वर्ण में से एक हो। BigInteger एक यादृच्छिक संख्या उत्पन्न करने के लिए एक निर्माता प्रदान करता है, समान रूप से श्रेणी 0 to (2^numBits - 1) पर वितरित किया जाता है। दुर्भाग्य से 35 कोई संख्या नहीं है जिसे 2 ^ numbits – 1 से प्राप्त किया जा सकता है। 1. तो हमारे पास दो विकल्प हैं: या तो 2^5-1=31 या 2^6-1=63 । अगर हम 2^6 चुनते हैं तो हमें बहुत से "अनएक्सिसरी" / "लम्बी" संख्याएं मिलेंगी इसलिए 2^5 बेहतर विकल्प है, भले ही हम 4 अक्षर (wz) खोले। अब एक निश्चित लंबाई की एक स्ट्रिंग उत्पन्न करने के लिए, हम बस 2^(length*numBits)-1 नंबर का उपयोग कर सकते हैं। आखिरी समस्या, अगर हम एक निश्चित लंबाई वाली स्ट्रिंग चाहते हैं, तो यादृच्छिक एक छोटी सी संख्या उत्पन्न कर सकता है, इसलिए लंबाई पूरी नहीं हुई है, इसलिए हमें स्ट्रिंग को पैड करना होगा जिसमें शून्य की आवश्यक लंबाई है।

मुझे यह समाधान मिला है जो एक यादृच्छिक हेक्स एन्कोडेड स्ट्रिंग उत्पन्न करता है। प्रदान की गई यूनिट परीक्षा मेरे प्राथमिक उपयोग के मामले को रोकती है। हालांकि, प्रदान की गई कुछ अन्य उत्तरों की तुलना में यह थोड़ा अधिक जटिल है।

 /** * Generate a random hex encoded string token of the specified length * * @param length * @return random hex string */ public static synchronized String generateUniqueToken(Integer length){ byte random[] = new byte[length]; Random randomGenerator = new Random(); StringBuffer buffer = new StringBuffer(); randomGenerator.nextBytes(random); for (int j = 0; j < random.length; j++) { byte b1 = (byte) ((random[j] & 0xf0) >> 4); byte b2 = (byte) (random[j] & 0x0f); if (b1 < 10) buffer.append((char) ('0' + b1)); else buffer.append((char) ('A' + (b1 - 10))); if (b2 < 10) buffer.append((char) ('0' + b2)); else buffer.append((char) ('A' + (b2 - 10))); } return (buffer.toString()); } @Test public void testGenerateUniqueToken(){ Set set = new HashSet(); String token = null; int size = 16; /* Seems like we should be able to generate 500K tokens * without a duplicate */ for (int i=0; i<500000; i++){ token = Utility.generateUniqueToken(size); if (token.length() != size * 2){ fail("Incorrect length"); } else if (set.contains(token)) { fail("Duplicate token generated"); } else{ set.add(token); } } } 
 import java.util.Date; import java.util.Random; public class RandomGenerator { private static Random random = new Random((new Date()).getTime()); public static String generateRandomString(int length) { char[] values = {'a','b','c','d','e','f','g','h','i','j', 'k','l','m','n','o','p','q','r','s','t', 'u','v','w','x','y','z','0','1','2','3', '4','5','6','7','8','9'}; String out = ""; for (int i=0;i<length;i++) { int idx=random.nextInt(values.length); out += values[idx]; } return out; } } 
 import java.util.*; import javax.swing.*; public class alphanumeric{ public static void main(String args[]){ String nval,lenval; int n,len; nval=JOptionPane.showInputDialog("Enter number of codes you require : "); n=Integer.parseInt(nval); lenval=JOptionPane.showInputDialog("Enter code length you require : "); len=Integer.parseInt(lenval); find(n,len); } public static void find(int n,int length) { String str1="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; StringBuilder sb=new StringBuilder(length); Random r = new Random(); System.out.println("\n\t Unique codes are \n\n"); for(int i=0;i<n;i++){ for(int j=0;j<length;j++){ sb.append(str1.charAt(r.nextInt(str1.length()))); } System.out.println(" "+sb.toString()); sb.delete(0,length); } } } 
  1. अपनी आवश्यकताओं के अनुसार स्ट्रिंग वर्ण बदलें

  2. स्ट्रिंग अपरिवर्तनीय है स्ट्रिंगबइल्डर.एफ़ेंड स्ट्रिंग संयोजन से अधिक कुशल है।

 public static String getRandomString(int length) { final String characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+"; StringBuilder result = new StringBuilder(); while(length > 0) { Random rand = new Random(); result.append(characters.charAt(rand.nextInt(characters.length()))); length--; } return result.toString(); } 

आप निम्नलिखित कोड का उपयोग कर सकते हैं, यदि आपके पासवर्ड में अनिवार्य संख्या वर्णमाला विशेष वर्ण शामिल हैं:

 private static final String NUMBERS = "0123456789"; private static final String UPPER_ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private static final String LOWER_ALPHABETS = "abcdefghijklmnopqrstuvwxyz"; private static final String SPECIALCHARACTERS = "@#$%&*"; private static final int MINLENGTHOFPASSWORD = 8; public static String getRandomPassword() { StringBuilder password = new StringBuilder(); int j = 0; for (int i = 0; i < MINLENGTHOFPASSWORD; i++) { password.append(getRandomPasswordCharacters(j)); j++; if (j == 3) { j = 0; } } return password.toString(); } private static String getRandomPasswordCharacters(int pos) { Random randomNum = new Random(); StringBuilder randomChar = new StringBuilder(); switch (pos) { case 0: randomChar.append(NUMBERS.charAt(randomNum.nextInt(NUMBERS.length() - 1))); break; case 1: randomChar.append(UPPER_ALPHABETS.charAt(randomNum.nextInt(UPPER_ALPHABETS.length() - 1))); break; case 2: randomChar.append(SPECIALCHARACTERS.charAt(randomNum.nextInt(SPECIALCHARACTERS.length() - 1))); break; case 3: randomChar.append(LOWER_ALPHABETS.charAt(randomNum.nextInt(LOWER_ALPHABETS.length() - 1))); break; } return randomChar.toString(); } 

Here is the one line code by AbacusUtil

 String.valueOf(CharStream.random('0', 'z').filter(c -> N.isLetterOrDigit(c)).limit(12).toArray()) 

Random doesn't mean it must be unique. to get unique strings, using:

 N.uuid() // eg: "e812e749-cf4c-4959-8ee1-57829a69a80f". length is 36. N.guid() // eg: "0678ce04e18945559ba82ddeccaabfcd". length is 32 without '-' 

You mention "simple", but just in case anyone else is looking for something that meets more stringent security requirements, you might want to take a look at jpwgen . jpwgen is modeled after pwgen in Unix, and is very configurable.

Here it is a Scala solution:

 (for (i <- 0 until rnd.nextInt(64)) yield { ('0' + rnd.nextInt(64)).asInstanceOf[Char] }) mkString("") 

using apache library it can be done in one line

 import org.apache.commons.lang.RandomStringUtils; RandomStringUtils.randomAlphanumeric(64); 

here is doc http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/RandomStringUtils.html

You can use the UUID class with its getLeastSignificantBits() message to get 64bit of Random data, then convert it to a radix 36 number (ie a string consisting of 0-9,AZ):

 Long.toString(Math.abs( UUID.randomUUID().getLeastSignificantBits(), 36)); 

This yields a String up to 13 characters long. We use Math.abs() to make sure there isn't a minus sign sneaking in.

Maybe this is helpful

 package password.generater; import java.util.Random; /** * * @author dell */ public class PasswordGenerater { /** * @param args the command line arguments */ public static void main(String[] args) { int length= 11; System.out.println(generatePswd(length)); // TODO code application logic here } static char[] generatePswd(int len){ System.out.println("Your Password "); String charsCaps="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; String Chars="abcdefghijklmnopqrstuvwxyz"; String nums="0123456789"; String symbols="!@#$%^&*()_+-=.,/';:?><~*/-+"; String passSymbols=charsCaps + Chars + nums +symbols; Random rnd=new Random(); char[] password=new char[len]; for(int i=0; i<len;i++){ password[i]=passSymbols.charAt(rnd.nextInt(passSymbols.length())); } return password; } } 

Best Random String Generator Method

 public class RandomStringGenerator{ private static int randomStringLength = 25 ; private static boolean allowSpecialCharacters = true ; private static String specialCharacters = "!@$%*-_+:"; private static boolean allowDuplicates = false ; private static boolean isAlphanum = false; private static boolean isNumeric = false; private static boolean isAlpha = false; private static final String alphabet = "abcdefghijklmnopqrstuvwxyz"; private static boolean mixCase = false; private static final String capAlpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private static final String num = "0123456789"; public static String getRandomString() { String returnVal = ""; int specialCharactersCount = 0; int maxspecialCharacters = randomStringLength/4; try { StringBuffer values = buildList(); for (int inx = 0; inx < randomStringLength; inx++) { int selChar = (int) (Math.random() * (values.length() - 1)); if (allowSpecialCharacters) { if (specialCharacters.indexOf("" + values.charAt(selChar)) > -1) { specialCharactersCount ++; if (specialCharactersCount > maxspecialCharacters) { while (specialCharacters.indexOf("" + values.charAt(selChar)) != -1) { selChar = (int) (Math.random() * (values.length() - 1)); } } } } returnVal += values.charAt(selChar); if (!allowDuplicates) { values.deleteCharAt(selChar); } } } catch (Exception e) { returnVal = "Error While Processing Values"; } return returnVal; } private static StringBuffer buildList() { StringBuffer list = new StringBuffer(0); if (isNumeric || isAlphanum) { list.append(num); } if (isAlpha || isAlphanum) { list.append(alphabet); if (mixCase) { list.append(capAlpha); } } if (allowSpecialCharacters) { list.append(specialCharacters); } int currLen = list.length(); String returnVal = ""; for (int inx = 0; inx < currLen; inx++) { int selChar = (int) (Math.random() * (list.length() - 1)); returnVal += list.charAt(selChar); list.deleteCharAt(selChar); } list = new StringBuffer(returnVal); return list; } } 
 public static String getRandomString(int length) { String randomStr = UUID.randomUUID().toString(); while(randomStr.length() < length) { randomStr += UUID.randomUUID().toString(); } return randomStr.substring(0, length); } 

Lots of use of StringBuilder above. I guess it's easy, but requires a function call per char, growing an array, etc… If using the stringbuilder, a suggestion is to specify the required capacity of the string ie.,

 new StringBuilder(int capacity); 

Here's a version that doesn't use a StringBuilder or String appending, and no dictionary.

 public static String randomString(int length) { SecureRandom random = new SecureRandom(); char[] chars = new char[length]; for(int i=0;i<chars.length;i++) { int v = random.nextInt(10 + 26 + 26); char c; if (v < 10) { c = (char)('0' + v); } else if (v < 36) { c = (char)('a' - 10 + v); } else { c = (char)('A' - 36 + v); } chars[i] = c; } return new String(chars); } 
  public static String randomSeriesForThreeCharacter() { Random r = new Random(); String value=""; char random_Char ; for(int i=0; i<10;i++) { random_Char = (char) (48 + r.nextInt(74)); value=value+random_char; } return value; }