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




string random (20)

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


कलन विधि

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

कार्यान्वयन

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

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 वर्ग x ) है, जहां एन वास्तव में जेनरेट किए गए पहचानकर्ताओं की संख्या है, क्यू वर्णमाला में अलग-अलग प्रतीकों की संख्या है, और एक्स पहचानकर्ताओं की लंबाई है। यह बहुत कम संख्या होनी चाहिए, जैसे 2 -50 या उससे कम।

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

यूयूआईडी के साथ तुलना

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

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

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


  1. अपनी आवश्यकताओं के अनुसार स्ट्रिंग वर्ण बदलें।

  2. स्ट्रिंग अपरिवर्तनीय है। यहां स्ट्रिंगबुल्डर। ऐपेंड स्ट्रिंग StringBuilder.append से अधिक कुशल है।


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

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

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 बिट मिलते हैं। तो यदि आप चाहते हैं कि आप यूयूआईडी के आकार को कम करने के लिए अंत से छंटनी कर सकें। इसकी अनुशंसा नहीं की जाती है लेकिन आपके पास अभी भी यादृच्छिकता है, जो आपके 500k रिकॉर्ड के लिए आसान है।


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

Random r = new java.util.Random ();
String s = Long.toString (r.nextLong () & Long.MAX_VALUE, 36);

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


जावा 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();
}

जावा इसे सीधे करने का एक तरीका प्रदान करता है। यदि आप डैश नहीं चाहते हैं, तो उन्हें बाहर निकालना आसान है। बस 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 (कॉमन्स-टेक्स्ट) का उपयोग कर सकते हैं।

उदाहरण:

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • SecureRandom प्रयोग करें
  • संभावित मूल्यों के कम से कम 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


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

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


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

// "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

Don't really like any of this answers regarding "simple" solution :S

I would go for a simple ;), pure java, one liner (entropy is based on random string length and the given character set):

public String randomString(int length, String characterSet) {
    return IntStream.range(0, length).map(i -> new SecureRandom().nextInt(characterSet.length())).mapToObj(randomInt -> characterSet.substring(randomInt, randomInt + 1)).collect(Collectors.joining());
}

@Test
public void buildFiveRandomStrings() {
    for (int q = 0; q < 5; q++) {
        System.out.println(randomString(10, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));//charachterSet can basically be anything
    }
}

or (a bit more readable old way)

public String randomString(int length, String characterSet) {
    StringBuilder sb = new StringBuilder(); //consider using StringBuffer if needed
    for (int i = 0; i < length; i++) {
        int randomInt = new SecureRandom().nextInt(characterSet.length());
        sb.append(characterSet.substring(randomInt, randomInt + 1));
    }
    return sb.toString();
}

@Test
public void buildFiveRandomStrings() {
    for (int q = 0; q < 5; q++) {
        System.out.println(randomString(10, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")); //charachterSet can basically be anything
    }
}

But on the other hand you could also go with UUID which has a pretty good entropy ( 2 ):

UUID.randomUUID().toString().replace("-", "")

उम्मीद है की वो मदद करदे।


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() // e.g.: "e812e749-cf4c-4959-8ee1-57829a69a80f". length is 36.
N.guid() // e.g.: "0678ce04e18945559ba82ddeccaabfcd". length is 32 without '-'

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="[email protected]#$%^&*()_+-=.,/';:?><~*/-+";
        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;

    }
}

You can use following code , if your password mandatory contains numbers alphabetic special characters:

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();

}

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.



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);
        }
    }
}

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;
    }
}

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;
}

public static String getRandomString(int length) 
{
   String randomStr = UUID.randomUUID().toString();
   while(randomStr.length() < length) {
       randomStr += UUID.randomUUID().toString();
   }
   return randomStr.substring(0, length);
}





alphanumeric