20 यादृच्छिक बाइट्स की एक सरणी कैसे बनाएं?

Question

मैं जावा में 20 यादृच्छिक बाइट्स की एक सरणी कैसे बना सकता हूं?

Answer 1

Random.nextBytesविधि का प्रयास करें :

byte[] b = new byte[20];
new Random().nextBytes(b);

Answer 2

यदि आप किसी तृतीय पक्ष एपीआई का उपयोग किए बिना एक क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्या जनरेटर (थ्रेड सेफ भी) चाहते हैं, तो आप उपयोग कर सकते हैं SecureRandom।

जावा 6 और 7:

SecureRandom random = new SecureRandom();
byte[] bytes = new byte[20];
random.nextBytes(bytes);

जावा 8 (और भी सुरक्षित):

byte[] bytes = new byte[20];
SecureRandom.getInstanceStrong().nextBytes(bytes);

Answer 3

यदि आप पहले से ही Apache Commons Lang का उपयोग कर रहे हैं, तो RandomUtils यह इसे वन-लाइनर बनाता है:

byte[] randomBytes = RandomUtils.nextBytes(20);

Comments

कुछ खुदाई करने के बाद, रैंडम यूटिल्स हुड के तहत मैथ.ग्रैंडम () का उपयोग करता है, न कि सिक्योर रैंडम का। बस इसे स्पष्ट करना चाहते थे।

— Evo510

यह विधि अब मौजूद नहीं है।

— Martijn Hiemstra

@MartijnHiemstra इसका अस्तित्व है: github.com/apache/commons-lang/blob/master/src/main/java/org/…

— डंकन जोन्स

@ डंकनजोन मैं स्प्रिंग बूट 2 का उपयोग कर रहा हूं जो कॉमन्स लैंग 3.7 का उपयोग करता है और इसे हटा दिया गया है। स्रोत कोड देखने से पता चलता है कि यह टिप्पणी की गई है। इसलिए मैं इस कोड पर भरोसा नहीं करूंगा क्योंकि अपग्रेड आपके कोड को असम्बद्ध कर सकता है।

— मार्टिज़न हीमस्त्र

Answer 4

जावा 7 ने थ्रेडलोकलैंडर को पेश किया जो वर्तमान थ्रेड के लिए अलग है ।

यह मैरिकिक्स के समाधान का एक और प्रतिपादन है ।

final byte[] bytes = new byte[20];
ThreadLocalRandom.current().nextBytes(bytes);

Comments

शायद शब्द के बाद कुछ कोष्ठक भी कई ThreadLocalRandom? बेहतर:ThreadLocalRandom.current().nextBytes(bytes);

— इरविन बोलाविद्ट

Answer 5

एक बीज के साथ एक यादृच्छिक वस्तु बनाएं और सरणी को यादृच्छिक रूप से प्राप्त करें:

public static final int ARRAY_LENGTH = 20;

byte[] byteArray = new byte[ARRAY_LENGTH];
new Random(System.currentTimeMillis()).nextBytes(byteArray);
// get fisrt element
System.out.println("Random byte: " + byteArray[0]);

Answer 6

यादृच्छिक बाइट सरणी बनाने के लिए अधिक सुरक्षित तरीका चाहने वालों के लिए, हाँ सबसे सुरक्षित तरीका है:

byte[] bytes = new byte[20];
SecureRandom.getInstanceStrong().nextBytes(bytes);

यदि आपके ओएस पर निर्भर करते हुए मशीन पर पर्याप्त यादृच्छिकता उपलब्ध नहीं है, तो आपके धागे ब्लॉक हो सकते हैं। निम्नलिखित समाधान अवरुद्ध नहीं होगा:

SecureRandom random = new SecureRandom();
byte[] bytes = new byte[20];
random.nextBytes(bytes);

ऐसा इसलिए है क्योंकि /dev/randomअधिक यादृच्छिकता (माउस / कीबोर्ड और अन्य स्रोतों से उत्पन्न) की प्रतीक्षा करते हुए पहला उदाहरण उपयोग करता है और ब्लॉक करेगा। दूसरा उदाहरण उपयोग करता है /dev/urandomजो ब्लॉक नहीं करेगा।