svn commit: r1087362 [15/50] - in /websites/production/commons/content/proper/commons-lang: ./ apidocs/ apidocs/org/apache/commons/lang3/ apidocs/org/apache/commons/lang3/arch/ apidocs/org/apache/commons/lang3/arch/class-use/ apidocs/org/apache/commons...

Thu, 29 Aug 2024 12:59:43 -0700 

Modified: 
websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/RandomStringUtils.html
==============================================================================
--- 
websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/RandomStringUtils.html
 (original)
+++ 
websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/RandomStringUtils.html
 Thu Aug 29 19:59:17 2024
@@ -38,778 +38,778 @@
 <span class="source-line-no">025</span><span id="line-25">/**</span>
 <span class="source-line-no">026</span><span id="line-26"> * Generates random 
{@link String}s.</span>
 <span class="source-line-no">027</span><span id="line-27"> * &lt;p&gt;</span>
-<span class="source-line-no">028</span><span id="line-28"> * Starting in 
version 3.16.0, this class uses {@link #secure()} for static methods and adds 
{@link #insecure()}.</span>
-<span class="source-line-no">029</span><span id="line-29"> * &lt;/p&gt;</span>
-<span class="source-line-no">030</span><span id="line-30"> * &lt;p&gt;</span>
-<span class="source-line-no">031</span><span id="line-31"> * Starting in 
version 3.15.0, this class uses {@link SecureRandom#getInstanceStrong()} for 
static methods.</span>
-<span class="source-line-no">032</span><span id="line-32"> * &lt;/p&gt;</span>
-<span class="source-line-no">033</span><span id="line-33"> * &lt;p&gt;</span>
-<span class="source-line-no">034</span><span id="line-34"> * Before version 
3.15.0, this class used {@link ThreadLocalRandom#current()} for static methods, 
which is not</span>
-<span class="source-line-no">035</span><span id="line-35"> * cryptographically 
secure.</span>
-<span class="source-line-no">036</span><span id="line-36"> * &lt;/p&gt;</span>
-<span class="source-line-no">037</span><span id="line-37"> * &lt;p&gt;</span>
-<span class="source-line-no">038</span><span id="line-38"> * Use {@link 
#secure()} to get the singleton instance based on {@link 
SecureRandom#getInstanceStrong()} which uses an</span>
-<span class="source-line-no">039</span><span id="line-39"> * 
algorithms/providers specified in the {@code securerandom.strongAlgorithms} 
{@link Security} property.</span>
-<span class="source-line-no">040</span><span id="line-40"> * &lt;/p&gt;</span>
-<span class="source-line-no">041</span><span id="line-41"> * &lt;p&gt;</span>
-<span class="source-line-no">042</span><span id="line-42"> * Use {@link 
#insecure()} to get the singleton instance based on {@link 
ThreadLocalRandom#current()}; &lt;b&gt;which is not</span>
-<span class="source-line-no">043</span><span id="line-43"> * cryptographically 
secure&lt;/b&gt;.</span>
-<span class="source-line-no">044</span><span id="line-44"> * &lt;/p&gt;</span>
-<span class="source-line-no">045</span><span id="line-45"> * &lt;p&gt;</span>
-<span class="source-line-no">046</span><span id="line-46"> * RandomStringUtils 
is intended for simple use cases. For more advanced use cases consider using 
Apache Commons Text's</span>
-<span class="source-line-no">047</span><span id="line-47"> * &lt;a href=</span>
-<span class="source-line-no">048</span><span id="line-48"> * 
"https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/RandomStringGenerator.html"&gt;</span>
-<span class="source-line-no">049</span><span id="line-49"> * 
RandomStringGenerator&lt;/a&gt; instead.</span>
-<span class="source-line-no">050</span><span id="line-50"> * &lt;/p&gt;</span>
-<span class="source-line-no">051</span><span id="line-51"> * &lt;p&gt;</span>
-<span class="source-line-no">052</span><span id="line-52"> * The Apache 
Commons project provides &lt;a 
href="https://commons.apache.org/proper/commons-rng/"&gt;Commons 
RNG&lt;/a&gt;</span>
-<span class="source-line-no">053</span><span id="line-53"> * dedicated to 
pseudo-random number generation, that may be a better choice for applications 
with more stringent</span>
-<span class="source-line-no">054</span><span id="line-54"> * requirements 
(performance and/or correctness).</span>
-<span class="source-line-no">055</span><span id="line-55"> * &lt;/p&gt;</span>
-<span class="source-line-no">056</span><span id="line-56"> * &lt;p&gt;</span>
-<span class="source-line-no">057</span><span id="line-57"> * Note that 
&lt;em&gt;private high surrogate&lt;/em&gt; characters are ignored. These are 
Unicode characters that fall between the</span>
-<span class="source-line-no">058</span><span id="line-58"> * values 56192 
(db80) and 56319 (dbff) as we don't know how to handle them. High and low 
surrogates are correctly dealt</span>
-<span class="source-line-no">059</span><span id="line-59"> * with - that is if 
a high surrogate is randomly chosen, 55296 (d800) to 56191 (db7f) then it is 
followed by a low</span>
-<span class="source-line-no">060</span><span id="line-60"> * surrogate. If a 
low surrogate is chosen, 56320 (dc00) to 57343 (dfff) then it is placed after a 
randomly chosen high</span>
-<span class="source-line-no">061</span><span id="line-61"> * surrogate.</span>
-<span class="source-line-no">062</span><span id="line-62"> * &lt;/p&gt;</span>
-<span class="source-line-no">063</span><span id="line-63"> * &lt;p&gt;</span>
-<span class="source-line-no">064</span><span id="line-64"> * 
#ThreadSafe#</span>
-<span class="source-line-no">065</span><span id="line-65"> * &lt;/p&gt;</span>
-<span class="source-line-no">066</span><span id="line-66"> *</span>
-<span class="source-line-no">067</span><span id="line-67"> * @see 
RandomUtils</span>
-<span class="source-line-no">068</span><span id="line-68"> * @since 1.0</span>
-<span class="source-line-no">069</span><span id="line-69"> */</span>
-<span class="source-line-no">070</span><span id="line-70">public class 
RandomStringUtils {</span>
-<span class="source-line-no">071</span><span id="line-71"></span>
-<span class="source-line-no">072</span><span id="line-72">    private static 
final Supplier&lt;RandomUtils&gt; SECURE_SUPPLIER = RandomUtils::secure;</span>
-<span class="source-line-no">073</span><span id="line-73"></span>
-<span class="source-line-no">074</span><span id="line-74">    private static 
RandomStringUtils INSECURE = new 
RandomStringUtils(RandomUtils::insecure);</span>
-<span class="source-line-no">075</span><span id="line-75"></span>
-<span class="source-line-no">076</span><span id="line-76">    private static 
RandomStringUtils SECURE = new RandomStringUtils(SECURE_SUPPLIER);</span>
-<span class="source-line-no">077</span><span id="line-77"></span>
-<span class="source-line-no">078</span><span id="line-78">    private static 
final char[] ALPHANUMERICAL_CHARS = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
'i', 'j', 'k', 'l',</span>
-<span class="source-line-no">079</span><span id="line-79">            'm', 
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 
'D', 'E', 'F', 'G',</span>
-<span class="source-line-no">080</span><span id="line-80">            'H', 
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 
'Y', 'Z', '0', '1',</span>
-<span class="source-line-no">081</span><span id="line-81">            '2', 
'3', '4', '5', '6', '7', '8', '9' };</span>
+<span class="source-line-no">028</span><span id="line-28"> * Use {@link 
#secure()} to get the singleton instance based on {@link 
SecureRandom#SecureRandom()} which uses a secure random number generator 
implementing the</span>
+<span class="source-line-no">029</span><span id="line-29"> * default random 
number algorithm.</span>
+<span class="source-line-no">030</span><span id="line-30"> * &lt;/p&gt;</span>
+<span class="source-line-no">031</span><span id="line-31"> * &lt;p&gt;</span>
+<span class="source-line-no">032</span><span id="line-32"> * Use {@link 
#secureStrong()} to get the singleton instance based on {@link 
SecureRandom#getInstanceStrong()} which uses an instance that was selected by 
using</span>
+<span class="source-line-no">033</span><span id="line-33"> * the 
algorithms/providers specified in the {@code securerandom.strongAlgorithms} 
{@link Security} property.</span>
+<span class="source-line-no">034</span><span id="line-34"> * &lt;/p&gt;</span>
+<span class="source-line-no">035</span><span id="line-35"> * &lt;p&gt;</span>
+<span class="source-line-no">036</span><span id="line-36"> * Use {@link 
#insecure()} to get the singleton instance based on {@link 
ThreadLocalRandom#current()} &lt;b&gt;which is not cryptographically 
secure&lt;/b&gt;. In addition,</span>
+<span class="source-line-no">037</span><span id="line-37"> * instances do not 
use a cryptographically random seed unless the {@linkplain System#getProperty 
system property} {@code java.util.secureRandomSeed} is set to</span>
+<span class="source-line-no">038</span><span id="line-38"> * {@code 
true}.</span>
+<span class="source-line-no">039</span><span id="line-39"> * &lt;/p&gt;</span>
+<span class="source-line-no">040</span><span id="line-40"> * &lt;p&gt;</span>
+<span class="source-line-no">041</span><span id="line-41"> * Starting in 
version 3.17.0, the method {@link #secure()} uses {@link 
SecureRandom#SecureRandom()} instead of {@link 
SecureRandom#getInstanceStrong()}, and</span>
+<span class="source-line-no">042</span><span id="line-42"> * adds {@link 
#secureStrong()}.</span>
+<span class="source-line-no">043</span><span id="line-43"> * &lt;/p&gt;</span>
+<span class="source-line-no">044</span><span id="line-44"> * &lt;p&gt;</span>
+<span class="source-line-no">045</span><span id="line-45"> * Starting in 
version 3.16.0, this class uses {@link #secure()} for static methods and adds 
{@link #insecure()}.</span>
+<span class="source-line-no">046</span><span id="line-46"> * &lt;/p&gt;</span>
+<span class="source-line-no">047</span><span id="line-47"> * &lt;p&gt;</span>
+<span class="source-line-no">048</span><span id="line-48"> * Starting in 
version 3.15.0, this class uses {@link SecureRandom#getInstanceStrong()} for 
static methods.</span>
+<span class="source-line-no">049</span><span id="line-49"> * &lt;/p&gt;</span>
+<span class="source-line-no">050</span><span id="line-50"> * &lt;p&gt;</span>
+<span class="source-line-no">051</span><span id="line-51"> * Before version 
3.15.0, this class used {@link ThreadLocalRandom#current()} for static methods, 
which is not cryptographically secure.</span>
+<span class="source-line-no">052</span><span id="line-52"> * &lt;/p&gt;</span>
+<span class="source-line-no">053</span><span id="line-53"> * &lt;p&gt;</span>
+<span class="source-line-no">054</span><span id="line-54"> * RandomStringUtils 
is intended for simple use cases. For more advanced use cases consider using 
Apache Commons Text's</span>
+<span class="source-line-no">055</span><span id="line-55"> * &lt;a href= 
"https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/RandomStringGenerator.html"&gt;
 RandomStringGenerator&lt;/a&gt;</span>
+<span class="source-line-no">056</span><span id="line-56"> * instead.</span>
+<span class="source-line-no">057</span><span id="line-57"> * &lt;/p&gt;</span>
+<span class="source-line-no">058</span><span id="line-58"> * &lt;p&gt;</span>
+<span class="source-line-no">059</span><span id="line-59"> * The Apache 
Commons project provides &lt;a 
href="https://commons.apache.org/proper/commons-rng/"&gt;Commons RNG&lt;/a&gt; 
dedicated to pseudo-random number generation,</span>
+<span class="source-line-no">060</span><span id="line-60"> * that may be a 
better choice for applications with more stringent requirements (performance 
and/or correctness).</span>
+<span class="source-line-no">061</span><span id="line-61"> * &lt;/p&gt;</span>
+<span class="source-line-no">062</span><span id="line-62"> * &lt;p&gt;</span>
+<span class="source-line-no">063</span><span id="line-63"> * Note that 
&lt;em&gt;private high surrogate&lt;/em&gt; characters are ignored. These are 
Unicode characters that fall between the values 56192 (db80) and 56319 (dbff) 
as</span>
+<span class="source-line-no">064</span><span id="line-64"> * we don't know how 
to handle them. High and low surrogates are correctly dealt with - that is if a 
high surrogate is randomly chosen, 55296 (d800) to 56191</span>
+<span class="source-line-no">065</span><span id="line-65"> * (db7f) then it is 
followed by a low surrogate. If a low surrogate is chosen, 56320 (dc00) to 
57343 (dfff) then it is placed after a randomly chosen high</span>
+<span class="source-line-no">066</span><span id="line-66"> * surrogate.</span>
+<span class="source-line-no">067</span><span id="line-67"> * &lt;/p&gt;</span>
+<span class="source-line-no">068</span><span id="line-68"> * &lt;p&gt;</span>
+<span class="source-line-no">069</span><span id="line-69"> * 
#ThreadSafe#</span>
+<span class="source-line-no">070</span><span id="line-70"> * &lt;/p&gt;</span>
+<span class="source-line-no">071</span><span id="line-71"> *</span>
+<span class="source-line-no">072</span><span id="line-72"> * @see 
#secure()</span>
+<span class="source-line-no">073</span><span id="line-73"> * @see 
#secureStrong()</span>
+<span class="source-line-no">074</span><span id="line-74"> * @see 
#insecure()</span>
+<span class="source-line-no">075</span><span id="line-75"> * @see 
SecureRandom#SecureRandom()</span>
+<span class="source-line-no">076</span><span id="line-76"> * @see 
SecureRandom#getInstanceStrong()</span>
+<span class="source-line-no">077</span><span id="line-77"> * @see 
ThreadLocalRandom#current()</span>
+<span class="source-line-no">078</span><span id="line-78"> * @see 
RandomUtils</span>
+<span class="source-line-no">079</span><span id="line-79"> * @since 1.0</span>
+<span class="source-line-no">080</span><span id="line-80"> */</span>
+<span class="source-line-no">081</span><span id="line-81">public class 
RandomStringUtils {</span>
 <span class="source-line-no">082</span><span id="line-82"></span>
-<span class="source-line-no">083</span><span id="line-83">    /**</span>
-<span class="source-line-no">084</span><span id="line-84">     * Gets the 
singleton instance based on {@link ThreadLocalRandom#current()}; &lt;b&gt;which 
is not cryptographically</span>
-<span class="source-line-no">085</span><span id="line-85">     * 
secure&lt;/b&gt;; use {@link #secure()} to use an algorithms/providers 
specified in the</span>
-<span class="source-line-no">086</span><span id="line-86">     * {@code 
securerandom.strongAlgorithms} {@link Security} property.</span>
-<span class="source-line-no">087</span><span id="line-87">     * 
&lt;p&gt;</span>
-<span class="source-line-no">088</span><span id="line-88">     * The method 
{@link ThreadLocalRandom#current()} is called on-demand.</span>
-<span class="source-line-no">089</span><span id="line-89">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">090</span><span id="line-90">     *</span>
-<span class="source-line-no">091</span><span id="line-91">     * @return the 
singleton instance based on {@link ThreadLocalRandom#current()}.</span>
-<span class="source-line-no">092</span><span id="line-92">     * @see 
ThreadLocalRandom#current()</span>
-<span class="source-line-no">093</span><span id="line-93">     * @see 
#secure()</span>
-<span class="source-line-no">094</span><span id="line-94">     * @since 
3.16.0</span>
-<span class="source-line-no">095</span><span id="line-95">     */</span>
-<span class="source-line-no">096</span><span id="line-96">    public static 
RandomStringUtils insecure() {</span>
-<span class="source-line-no">097</span><span id="line-97">        return 
INSECURE;</span>
-<span class="source-line-no">098</span><span id="line-98">    }</span>
-<span class="source-line-no">099</span><span id="line-99"></span>
-<span class="source-line-no">100</span><span id="line-100">    /**</span>
-<span class="source-line-no">101</span><span id="line-101">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">102</span><span id="line-102">     *</span>
-<span class="source-line-no">103</span><span id="line-103">     * 
&lt;p&gt;</span>
-<span class="source-line-no">104</span><span id="line-104">     * Characters 
will be chosen from the set of all characters.</span>
-<span class="source-line-no">105</span><span id="line-105">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">106</span><span id="line-106">     *</span>
-<span class="source-line-no">107</span><span id="line-107">     * @param count 
the length of random string to create</span>
-<span class="source-line-no">108</span><span id="line-108">     * @return the 
random string</span>
-<span class="source-line-no">109</span><span id="line-109">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
-<span class="source-line-no">110</span><span id="line-110">     */</span>
-<span class="source-line-no">111</span><span id="line-111">    public static 
String random(final int count) {</span>
-<span class="source-line-no">112</span><span id="line-112">        return 
secure().next(count);</span>
-<span class="source-line-no">113</span><span id="line-113">    }</span>
-<span class="source-line-no">114</span><span id="line-114"></span>
-<span class="source-line-no">115</span><span id="line-115">    /**</span>
-<span class="source-line-no">116</span><span id="line-116">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">117</span><span id="line-117">     *</span>
-<span class="source-line-no">118</span><span id="line-118">     * 
&lt;p&gt;</span>
-<span class="source-line-no">119</span><span id="line-119">     * Characters 
will be chosen from the set of alpha-numeric characters as indicated by the 
arguments.</span>
-<span class="source-line-no">120</span><span id="line-120">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">121</span><span id="line-121">     *</span>
-<span class="source-line-no">122</span><span id="line-122">     * @param count 
  the length of random string to create</span>
-<span class="source-line-no">123</span><span id="line-123">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
-<span class="source-line-no">124</span><span id="line-124">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
-<span class="source-line-no">125</span><span id="line-125">     * @return the 
random string</span>
-<span class="source-line-no">126</span><span id="line-126">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
-<span class="source-line-no">127</span><span id="line-127">     */</span>
-<span class="source-line-no">128</span><span id="line-128">    public static 
String random(final int count, final boolean letters, final boolean numbers) 
{</span>
-<span class="source-line-no">129</span><span id="line-129">        return 
secure().next(count, letters, numbers);</span>
-<span class="source-line-no">130</span><span id="line-130">    }</span>
-<span class="source-line-no">131</span><span id="line-131"></span>
-<span class="source-line-no">132</span><span id="line-132">    /**</span>
-<span class="source-line-no">133</span><span id="line-133">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">134</span><span id="line-134">     *</span>
-<span class="source-line-no">135</span><span id="line-135">     * 
&lt;p&gt;</span>
-<span class="source-line-no">136</span><span id="line-136">     * Characters 
will be chosen from the set of characters specified.</span>
-<span class="source-line-no">137</span><span id="line-137">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">138</span><span id="line-138">     *</span>
-<span class="source-line-no">139</span><span id="line-139">     * @param count 
the length of random string to create</span>
-<span class="source-line-no">140</span><span id="line-140">     * @param chars 
the character array containing the set of characters to use, may be null</span>
-<span class="source-line-no">141</span><span id="line-141">     * @return the 
random string</span>
-<span class="source-line-no">142</span><span id="line-142">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">083</span><span id="line-83">    private static 
final Supplier&lt;RandomUtils&gt; SECURE_SUPPLIER = RandomUtils::secure;</span>
+<span class="source-line-no">084</span><span id="line-84"></span>
+<span class="source-line-no">085</span><span id="line-85">    private static 
RandomStringUtils INSECURE = new 
RandomStringUtils(RandomUtils::insecure);</span>
+<span class="source-line-no">086</span><span id="line-86"></span>
+<span class="source-line-no">087</span><span id="line-87">    private static 
RandomStringUtils SECURE = new RandomStringUtils(SECURE_SUPPLIER);</span>
+<span class="source-line-no">088</span><span id="line-88"></span>
+<span class="source-line-no">089</span><span id="line-89">    private static 
RandomStringUtils SECURE_STRONG = new 
RandomStringUtils(RandomUtils::secureStrong);</span>
+<span class="source-line-no">090</span><span id="line-90"></span>
+<span class="source-line-no">091</span><span id="line-91">    private static 
final char[] ALPHANUMERICAL_CHARS = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
'i', 'j', 'k', 'l',</span>
+<span class="source-line-no">092</span><span id="line-92">            'm', 
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 
'D', 'E', 'F', 'G',</span>
+<span class="source-line-no">093</span><span id="line-93">            'H', 
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 
'Y', 'Z', '0', '1',</span>
+<span class="source-line-no">094</span><span id="line-94">            '2', 
'3', '4', '5', '6', '7', '8', '9' };</span>
+<span class="source-line-no">095</span><span id="line-95"></span>
+<span class="source-line-no">096</span><span id="line-96">    /**</span>
+<span class="source-line-no">097</span><span id="line-97">     * Gets the 
singleton instance based on {@link ThreadLocalRandom#current()}; &lt;b&gt;which 
is not cryptographically</span>
+<span class="source-line-no">098</span><span id="line-98">     * 
secure&lt;/b&gt;; use {@link #secure()} to use an algorithms/providers 
specified in the</span>
+<span class="source-line-no">099</span><span id="line-99">     * {@code 
securerandom.strongAlgorithms} {@link Security} property.</span>
+<span class="source-line-no">100</span><span id="line-100">     * 
&lt;p&gt;</span>
+<span class="source-line-no">101</span><span id="line-101">     * The method 
{@link ThreadLocalRandom#current()} is called on-demand.</span>
+<span class="source-line-no">102</span><span id="line-102">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">103</span><span id="line-103">     *</span>
+<span class="source-line-no">104</span><span id="line-104">     * @return the 
singleton instance based on {@link ThreadLocalRandom#current()}.</span>
+<span class="source-line-no">105</span><span id="line-105">     * @see 
ThreadLocalRandom#current()</span>
+<span class="source-line-no">106</span><span id="line-106">     * @see 
#secure()</span>
+<span class="source-line-no">107</span><span id="line-107">     * @since 
3.16.0</span>
+<span class="source-line-no">108</span><span id="line-108">     */</span>
+<span class="source-line-no">109</span><span id="line-109">    public static 
RandomStringUtils insecure() {</span>
+<span class="source-line-no">110</span><span id="line-110">        return 
INSECURE;</span>
+<span class="source-line-no">111</span><span id="line-111">    }</span>
+<span class="source-line-no">112</span><span id="line-112"></span>
+<span class="source-line-no">113</span><span id="line-113">    /**</span>
+<span class="source-line-no">114</span><span id="line-114">     * Creates a 
random string whose length is the number of characters specified.</span>
+<span class="source-line-no">115</span><span id="line-115">     *</span>
+<span class="source-line-no">116</span><span id="line-116">     * 
&lt;p&gt;</span>
+<span class="source-line-no">117</span><span id="line-117">     * Characters 
will be chosen from the set of all characters.</span>
+<span class="source-line-no">118</span><span id="line-118">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">119</span><span id="line-119">     *</span>
+<span class="source-line-no">120</span><span id="line-120">     * @param count 
the length of random string to create</span>
+<span class="source-line-no">121</span><span id="line-121">     * @return the 
random string</span>
+<span class="source-line-no">122</span><span id="line-122">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">123</span><span id="line-123">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
+<span class="source-line-no">124</span><span id="line-124">     */</span>
+<span class="source-line-no">125</span><span id="line-125">    
@Deprecated</span>
+<span class="source-line-no">126</span><span id="line-126">    public static 
String random(final int count) {</span>
+<span class="source-line-no">127</span><span id="line-127">        return 
secure().next(count);</span>
+<span class="source-line-no">128</span><span id="line-128">    }</span>
+<span class="source-line-no">129</span><span id="line-129"></span>
+<span class="source-line-no">130</span><span id="line-130">    /**</span>
+<span class="source-line-no">131</span><span id="line-131">     * Creates a 
random string whose length is the number of characters specified.</span>
+<span class="source-line-no">132</span><span id="line-132">     *</span>
+<span class="source-line-no">133</span><span id="line-133">     * 
&lt;p&gt;</span>
+<span class="source-line-no">134</span><span id="line-134">     * Characters 
will be chosen from the set of alpha-numeric characters as indicated by the 
arguments.</span>
+<span class="source-line-no">135</span><span id="line-135">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">136</span><span id="line-136">     *</span>
+<span class="source-line-no">137</span><span id="line-137">     * @param count 
  the length of random string to create</span>
+<span class="source-line-no">138</span><span id="line-138">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
+<span class="source-line-no">139</span><span id="line-139">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
+<span class="source-line-no">140</span><span id="line-140">     * @return the 
random string</span>
+<span class="source-line-no">141</span><span id="line-141">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">142</span><span id="line-142">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
 <span class="source-line-no">143</span><span id="line-143">     */</span>
-<span class="source-line-no">144</span><span id="line-144">    public static 
String random(final int count, final char... chars) {</span>
-<span class="source-line-no">145</span><span id="line-145">        return 
secure().next(count, chars);</span>
-<span class="source-line-no">146</span><span id="line-146">    }</span>
-<span class="source-line-no">147</span><span id="line-147"></span>
-<span class="source-line-no">148</span><span id="line-148">    /**</span>
-<span class="source-line-no">149</span><span id="line-149">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">150</span><span id="line-150">     *</span>
-<span class="source-line-no">151</span><span id="line-151">     * 
&lt;p&gt;</span>
-<span class="source-line-no">152</span><span id="line-152">     * Characters 
will be chosen from the set of alpha-numeric characters as indicated by the 
arguments.</span>
-<span class="source-line-no">153</span><span id="line-153">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">154</span><span id="line-154">     *</span>
-<span class="source-line-no">155</span><span id="line-155">     * @param count 
  the length of random string to create</span>
-<span class="source-line-no">156</span><span id="line-156">     * @param start 
  the position in set of chars to start at</span>
-<span class="source-line-no">157</span><span id="line-157">     * @param end   
  the position in set of chars to end before</span>
-<span class="source-line-no">158</span><span id="line-158">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
-<span class="source-line-no">159</span><span id="line-159">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
-<span class="source-line-no">160</span><span id="line-160">     * @return the 
random string</span>
-<span class="source-line-no">161</span><span id="line-161">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
-<span class="source-line-no">162</span><span id="line-162">     */</span>
-<span class="source-line-no">163</span><span id="line-163">    public static 
String random(final int count, final int start, final int end, final boolean 
letters,</span>
-<span class="source-line-no">164</span><span id="line-164">            final 
boolean numbers) {</span>
-<span class="source-line-no">165</span><span id="line-165">        return 
secure().next(count, start, end, letters, numbers);</span>
-<span class="source-line-no">166</span><span id="line-166">    }</span>
-<span class="source-line-no">167</span><span id="line-167"></span>
-<span class="source-line-no">168</span><span id="line-168">    /**</span>
-<span class="source-line-no">169</span><span id="line-169">     * Creates a 
random string based on a variety of options, using default source of 
randomness.</span>
-<span class="source-line-no">170</span><span id="line-170">     *</span>
-<span class="source-line-no">171</span><span id="line-171">     * 
&lt;p&gt;</span>
-<span class="source-line-no">172</span><span id="line-172">     * This method 
has exactly the same semantics as {@link 
#random(int,int,int,boolean,boolean,char[],Random)}, but</span>
-<span class="source-line-no">173</span><span id="line-173">     * instead of 
using an externally supplied source of randomness, it uses the internal static 
{@link Random}</span>
-<span class="source-line-no">174</span><span id="line-174">     * 
instance.</span>
-<span class="source-line-no">175</span><span id="line-175">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">176</span><span id="line-176">     *</span>
-<span class="source-line-no">177</span><span id="line-177">     * @param count 
  the length of random string to create</span>
-<span class="source-line-no">178</span><span id="line-178">     * @param start 
  the position in set of chars to start at</span>
-<span class="source-line-no">179</span><span id="line-179">     * @param end   
  the position in set of chars to end before</span>
-<span class="source-line-no">180</span><span id="line-180">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
-<span class="source-line-no">181</span><span id="line-181">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
-<span class="source-line-no">182</span><span id="line-182">     * @param chars 
  the set of chars to choose randoms from. If {@code null}, then it will use 
the set of all chars.</span>
-<span class="source-line-no">183</span><span id="line-183">     * @return the 
random string</span>
-<span class="source-line-no">184</span><span id="line-184">     * @throws 
ArrayIndexOutOfBoundsException if there are not {@code (end - start) + 1} 
characters in the set array.</span>
-<span class="source-line-no">185</span><span id="line-185">     * @throws 
IllegalArgumentException       if {@code count} &amp;lt; 0.</span>
-<span class="source-line-no">186</span><span id="line-186">     */</span>
-<span class="source-line-no">187</span><span id="line-187">    public static 
String random(final int count, final int start, final int end, final boolean 
letters,</span>
-<span class="source-line-no">188</span><span id="line-188">            final 
boolean numbers, final char... chars) {</span>
-<span class="source-line-no">189</span><span id="line-189">        return 
secure().next(count, start, end, letters, numbers, chars);</span>
-<span class="source-line-no">190</span><span id="line-190">    }</span>
-<span class="source-line-no">191</span><span id="line-191"></span>
-<span class="source-line-no">192</span><span id="line-192">    /**</span>
-<span class="source-line-no">193</span><span id="line-193">     * Creates a 
random string based on a variety of options, using supplied source of 
randomness.</span>
-<span class="source-line-no">194</span><span id="line-194">     *</span>
-<span class="source-line-no">195</span><span id="line-195">     * 
&lt;p&gt;</span>
-<span class="source-line-no">196</span><span id="line-196">     * If start and 
end are both {@code 0}, start and end are set to {@code ' '} and {@code 'z'}, 
the ASCII printable</span>
-<span class="source-line-no">197</span><span id="line-197">     * characters, 
will be used, unless letters and numbers are both {@code false}, in which case, 
start and end are set</span>
-<span class="source-line-no">198</span><span id="line-198">     * to {@code 0} 
and {@link Character#MAX_CODE_POINT}.</span>
-<span class="source-line-no">199</span><span id="line-199">     *</span>
-<span class="source-line-no">200</span><span id="line-200">     * 
&lt;p&gt;</span>
-<span class="source-line-no">201</span><span id="line-201">     * If set is 
not {@code null}, characters between start and end are chosen.</span>
-<span class="source-line-no">202</span><span id="line-202">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">203</span><span id="line-203">     *</span>
-<span class="source-line-no">204</span><span id="line-204">     * 
&lt;p&gt;</span>
-<span class="source-line-no">205</span><span id="line-205">     * This method 
accepts a user-supplied {@link Random} instance to use as a source of 
randomness. By seeding a single</span>
-<span class="source-line-no">206</span><span id="line-206">     * {@link 
Random} instance with a fixed seed and using it for each call, the same random 
sequence of strings can be</span>
-<span class="source-line-no">207</span><span id="line-207">     * generated 
repeatedly and predictably.</span>
-<span class="source-line-no">208</span><span id="line-208">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">209</span><span id="line-209">     *</span>
-<span class="source-line-no">210</span><span id="line-210">     * @param count 
  the length of random string to create</span>
-<span class="source-line-no">211</span><span id="line-211">     * @param start 
  the position in set of chars to start at (inclusive)</span>
-<span class="source-line-no">212</span><span id="line-212">     * @param end   
  the position in set of chars to end before (exclusive)</span>
-<span class="source-line-no">213</span><span id="line-213">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
-<span class="source-line-no">214</span><span id="line-214">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
-<span class="source-line-no">215</span><span id="line-215">     * @param chars 
  the set of chars to choose randoms from, must not be empty. If {@code null}, 
then it will use the</span>
-<span class="source-line-no">216</span><span id="line-216">     *              
  set of all chars.</span>
-<span class="source-line-no">217</span><span id="line-217">     * @param 
random  a source of randomness.</span>
-<span class="source-line-no">218</span><span id="line-218">     * @return the 
random string</span>
-<span class="source-line-no">219</span><span id="line-219">     * @throws 
ArrayIndexOutOfBoundsException if there are not {@code (end - start) + 1} 
characters in the set array.</span>
-<span class="source-line-no">220</span><span id="line-220">     * @throws 
IllegalArgumentException       if {@code count} &amp;lt; 0 or the provided 
chars array is empty.</span>
-<span class="source-line-no">221</span><span id="line-221">     * @since 
2.0</span>
-<span class="source-line-no">222</span><span id="line-222">     */</span>
-<span class="source-line-no">223</span><span id="line-223">    public static 
String random(int count, int start, int end, final boolean letters, final 
boolean numbers,</span>
-<span class="source-line-no">224</span><span id="line-224">            final 
char[] chars, final Random random) {</span>
-<span class="source-line-no">225</span><span id="line-225">        if (count 
== 0) {</span>
-<span class="source-line-no">226</span><span id="line-226">            return 
StringUtils.EMPTY;</span>
-<span class="source-line-no">227</span><span id="line-227">        }</span>
-<span class="source-line-no">228</span><span id="line-228">        if (count 
&lt; 0) {</span>
-<span class="source-line-no">229</span><span id="line-229">            throw 
new IllegalArgumentException("Requested random string length " + count + " is 
less than 0.");</span>
-<span class="source-line-no">230</span><span id="line-230">        }</span>
-<span class="source-line-no">231</span><span id="line-231">        if (chars 
!= null &amp;&amp; chars.length == 0) {</span>
-<span class="source-line-no">232</span><span id="line-232">            throw 
new IllegalArgumentException("The chars array must not be empty");</span>
-<span class="source-line-no">233</span><span id="line-233">        }</span>
-<span class="source-line-no">234</span><span id="line-234"></span>
-<span class="source-line-no">235</span><span id="line-235">        if (start 
== 0 &amp;&amp; end == 0) {</span>
-<span class="source-line-no">236</span><span id="line-236">            if 
(chars != null) {</span>
-<span class="source-line-no">237</span><span id="line-237">                end 
= chars.length;</span>
-<span class="source-line-no">238</span><span id="line-238">            } else 
if (!letters &amp;&amp; !numbers) {</span>
-<span class="source-line-no">239</span><span id="line-239">                end 
= Character.MAX_CODE_POINT;</span>
-<span class="source-line-no">240</span><span id="line-240">            } else 
{</span>
-<span class="source-line-no">241</span><span id="line-241">                end 
= 'z' + 1;</span>
-<span class="source-line-no">242</span><span id="line-242">                
start = ' ';</span>
-<span class="source-line-no">243</span><span id="line-243">            }</span>
-<span class="source-line-no">244</span><span id="line-244">        } else if 
(end &lt;= start) {</span>
-<span class="source-line-no">245</span><span id="line-245">            throw 
new IllegalArgumentException(</span>
-<span class="source-line-no">246</span><span id="line-246">                    
"Parameter end (" + end + ") must be greater than start (" + start + 
")");</span>
-<span class="source-line-no">247</span><span id="line-247">        } else if 
(start &lt; 0 || end &lt; 0) {</span>
-<span class="source-line-no">248</span><span id="line-248">            throw 
new IllegalArgumentException("Character positions MUST be &gt;= 0");</span>
-<span class="source-line-no">249</span><span id="line-249">        }</span>
-<span class="source-line-no">250</span><span id="line-250"></span>
-<span class="source-line-no">251</span><span id="line-251">        if (end 
&gt; Character.MAX_CODE_POINT) {</span>
-<span class="source-line-no">252</span><span id="line-252">            // 
Technically, it should be `Character.MAX_CODE_POINT+1` as `end` is 
excluded</span>
-<span class="source-line-no">253</span><span id="line-253">            // But 
the character `Character.MAX_CODE_POINT` is private use, so it would anyway be 
excluded</span>
-<span class="source-line-no">254</span><span id="line-254">            end = 
Character.MAX_CODE_POINT;</span>
-<span class="source-line-no">255</span><span id="line-255">        }</span>
-<span class="source-line-no">256</span><span id="line-256"></span>
-<span class="source-line-no">257</span><span id="line-257">        // Optimize 
generation of full alphanumerical characters</span>
-<span class="source-line-no">258</span><span id="line-258">        // 
Normally, we would need to pick a 7-bit integer, since gap = 'z' - '0' + 1 = 75 
&gt; 64</span>
-<span class="source-line-no">259</span><span id="line-259">        // In turn, 
this would make us reject the sampling with probability 1 - 62 / 2^7 &gt; 1 / 
2</span>
-<span class="source-line-no">260</span><span id="line-260">        // Instead 
we can pick directly from the right set of 62 characters, which requires</span>
-<span class="source-line-no">261</span><span id="line-261">        // picking 
a 6-bit integer and only rejecting with probability 2 / 64 = 1 / 32</span>
-<span class="source-line-no">262</span><span id="line-262">        if (chars 
== null &amp;&amp; letters &amp;&amp; numbers &amp;&amp; start &lt;= '0' 
&amp;&amp; end &gt;= 'z' + 1) {</span>
-<span class="source-line-no">263</span><span id="line-263">            return 
random(count, 0, 0, false, false, ALPHANUMERICAL_CHARS, random);</span>
-<span class="source-line-no">264</span><span id="line-264">        }</span>
-<span class="source-line-no">265</span><span id="line-265"></span>
-<span class="source-line-no">266</span><span id="line-266">        // Optimize 
start and end when filtering by letters and/or numbers:</span>
-<span class="source-line-no">267</span><span id="line-267">        // The 
range provided may be too large since we filter anyway afterward.</span>
-<span class="source-line-no">268</span><span id="line-268">        // Note the 
use of Math.min/max (as opposed to setting start to '0' for example),</span>
-<span class="source-line-no">269</span><span id="line-269">        // since it 
is possible the range start/end excludes some of the letters/numbers,</span>
-<span class="source-line-no">270</span><span id="line-270">        // e.g., it 
is possible that start already is '1' when numbers = true, and start</span>
-<span class="source-line-no">271</span><span id="line-271">        // needs to 
stay equal to '1' in that case.</span>
-<span class="source-line-no">272</span><span id="line-272">        if (chars 
== null) {</span>
-<span class="source-line-no">273</span><span id="line-273">            if 
(letters &amp;&amp; numbers) {</span>
-<span class="source-line-no">274</span><span id="line-274">                
start = Math.max('0', start);</span>
-<span class="source-line-no">275</span><span id="line-275">                end 
= Math.min('z' + 1, end);</span>
-<span class="source-line-no">276</span><span id="line-276">            } else 
if (numbers) {</span>
-<span class="source-line-no">277</span><span id="line-277">                // 
just numbers, no letters</span>
-<span class="source-line-no">278</span><span id="line-278">                
start = Math.max('0', start);</span>
-<span class="source-line-no">279</span><span id="line-279">                end 
= Math.min('9' + 1, end);</span>
-<span class="source-line-no">280</span><span id="line-280">            } else 
if (letters) {</span>
-<span class="source-line-no">281</span><span id="line-281">                // 
just letters, no numbers</span>
-<span class="source-line-no">282</span><span id="line-282">                
start = Math.max('A', start);</span>
-<span class="source-line-no">283</span><span id="line-283">                end 
= Math.min('z' + 1, end);</span>
-<span class="source-line-no">284</span><span id="line-284">            }</span>
-<span class="source-line-no">285</span><span id="line-285">        }</span>
-<span class="source-line-no">286</span><span id="line-286"></span>
-<span class="source-line-no">287</span><span id="line-287">        final int 
zeroDigitAscii = 48;</span>
-<span class="source-line-no">288</span><span id="line-288">        final int 
firstLetterAscii = 65;</span>
-<span class="source-line-no">289</span><span id="line-289"></span>
-<span class="source-line-no">290</span><span id="line-290">        if (chars 
== null &amp;&amp; (numbers &amp;&amp; end &lt;= zeroDigitAscii || letters 
&amp;&amp; end &lt;= firstLetterAscii)) {</span>
-<span class="source-line-no">291</span><span id="line-291">            throw 
new IllegalArgumentException(</span>
-<span class="source-line-no">292</span><span id="line-292">                    
"Parameter end (" + end + ") must be greater then (" + zeroDigitAscii + ") for 
generating digits "</span>
-<span class="source-line-no">293</span><span id="line-293">                    
        + "or greater then (" + firstLetterAscii + ") for generating 
letters.");</span>
-<span class="source-line-no">294</span><span id="line-294">        }</span>
-<span class="source-line-no">295</span><span id="line-295"></span>
-<span class="source-line-no">296</span><span id="line-296">        final 
StringBuilder builder = new StringBuilder(count);</span>
-<span class="source-line-no">297</span><span id="line-297">        final int 
gap = end - start;</span>
-<span class="source-line-no">298</span><span id="line-298">        final int 
gapBits = Integer.SIZE - Integer.numberOfLeadingZeros(gap);</span>
-<span class="source-line-no">299</span><span id="line-299">        // The size 
of the cache we use is an heuristic:</span>
-<span class="source-line-no">300</span><span id="line-300">        // about 
twice the number of bytes required if no rejection</span>
-<span class="source-line-no">301</span><span id="line-301">        // Ideally 
the cache size depends on multiple factor, including the cost of generating x 
bytes</span>
-<span class="source-line-no">302</span><span id="line-302">        // of 
randomness as well as the probability of rejection. It is however not easy to 
know</span>
-<span class="source-line-no">303</span><span id="line-303">        // those 
values programmatically for the general case.</span>
-<span class="source-line-no">304</span><span id="line-304">        final 
CachedRandomBits arb = new CachedRandomBits((count * gapBits + 3) / 5 + 10, 
random);</span>
-<span class="source-line-no">305</span><span id="line-305"></span>
-<span class="source-line-no">306</span><span id="line-306">        while 
(count-- != 0) {</span>
-<span class="source-line-no">307</span><span id="line-307">            // 
Generate a random value between start (included) and end (excluded)</span>
-<span class="source-line-no">308</span><span id="line-308">            final 
int randomValue = arb.nextBits(gapBits) + start;</span>
-<span class="source-line-no">309</span><span id="line-309">            // 
Rejection sampling if value too large</span>
-<span class="source-line-no">310</span><span id="line-310">            if 
(randomValue &gt;= end) {</span>
-<span class="source-line-no">311</span><span id="line-311">                
count++;</span>
-<span class="source-line-no">312</span><span id="line-312">                
continue;</span>
-<span class="source-line-no">313</span><span id="line-313">            }</span>
-<span class="source-line-no">314</span><span id="line-314"></span>
-<span class="source-line-no">315</span><span id="line-315">            final 
int codePoint;</span>
-<span class="source-line-no">316</span><span id="line-316">            if 
(chars == null) {</span>
-<span class="source-line-no">317</span><span id="line-317">                
codePoint = randomValue;</span>
+<span class="source-line-no">144</span><span id="line-144">    
@Deprecated</span>
+<span class="source-line-no">145</span><span id="line-145">    public static 
String random(final int count, final boolean letters, final boolean numbers) 
{</span>
+<span class="source-line-no">146</span><span id="line-146">        return 
secure().next(count, letters, numbers);</span>
+<span class="source-line-no">147</span><span id="line-147">    }</span>
+<span class="source-line-no">148</span><span id="line-148"></span>
+<span class="source-line-no">149</span><span id="line-149">    /**</span>
+<span class="source-line-no">150</span><span id="line-150">     * Creates a 
random string whose length is the number of characters specified.</span>
+<span class="source-line-no">151</span><span id="line-151">     *</span>
+<span class="source-line-no">152</span><span id="line-152">     * 
&lt;p&gt;</span>
+<span class="source-line-no">153</span><span id="line-153">     * Characters 
will be chosen from the set of characters specified.</span>
+<span class="source-line-no">154</span><span id="line-154">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">155</span><span id="line-155">     *</span>
+<span class="source-line-no">156</span><span id="line-156">     * @param count 
the length of random string to create</span>
+<span class="source-line-no">157</span><span id="line-157">     * @param chars 
the character array containing the set of characters to use, may be null</span>
+<span class="source-line-no">158</span><span id="line-158">     * @return the 
random string</span>
+<span class="source-line-no">159</span><span id="line-159">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">160</span><span id="line-160">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
+<span class="source-line-no">161</span><span id="line-161">     */</span>
+<span class="source-line-no">162</span><span id="line-162">    
@Deprecated</span>
+<span class="source-line-no">163</span><span id="line-163">    public static 
String random(final int count, final char... chars) {</span>
+<span class="source-line-no">164</span><span id="line-164">        return 
secure().next(count, chars);</span>
+<span class="source-line-no">165</span><span id="line-165">    }</span>
+<span class="source-line-no">166</span><span id="line-166"></span>
+<span class="source-line-no">167</span><span id="line-167">    /**</span>
+<span class="source-line-no">168</span><span id="line-168">     * Creates a 
random string whose length is the number of characters specified.</span>
+<span class="source-line-no">169</span><span id="line-169">     *</span>
+<span class="source-line-no">170</span><span id="line-170">     * 
&lt;p&gt;</span>
+<span class="source-line-no">171</span><span id="line-171">     * Characters 
will be chosen from the set of alpha-numeric characters as indicated by the 
arguments.</span>
+<span class="source-line-no">172</span><span id="line-172">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">173</span><span id="line-173">     *</span>
+<span class="source-line-no">174</span><span id="line-174">     * @param count 
  the length of random string to create</span>
+<span class="source-line-no">175</span><span id="line-175">     * @param start 
  the position in set of chars to start at</span>
+<span class="source-line-no">176</span><span id="line-176">     * @param end   
  the position in set of chars to end before</span>
+<span class="source-line-no">177</span><span id="line-177">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
+<span class="source-line-no">178</span><span id="line-178">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
+<span class="source-line-no">179</span><span id="line-179">     * @return the 
random string</span>
+<span class="source-line-no">180</span><span id="line-180">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">181</span><span id="line-181">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
+<span class="source-line-no">182</span><span id="line-182">     */</span>
+<span class="source-line-no">183</span><span id="line-183">    
@Deprecated</span>
+<span class="source-line-no">184</span><span id="line-184">    public static 
String random(final int count, final int start, final int end, final boolean 
letters,</span>
+<span class="source-line-no">185</span><span id="line-185">            final 
boolean numbers) {</span>
+<span class="source-line-no">186</span><span id="line-186">        return 
secure().next(count, start, end, letters, numbers);</span>
+<span class="source-line-no">187</span><span id="line-187">    }</span>
+<span class="source-line-no">188</span><span id="line-188"></span>
+<span class="source-line-no">189</span><span id="line-189">    /**</span>
+<span class="source-line-no">190</span><span id="line-190">     * Creates a 
random string based on a variety of options, using default source of 
randomness.</span>
+<span class="source-line-no">191</span><span id="line-191">     *</span>
+<span class="source-line-no">192</span><span id="line-192">     * 
&lt;p&gt;</span>
+<span class="source-line-no">193</span><span id="line-193">     * This method 
has exactly the same semantics as {@link 
#random(int,int,int,boolean,boolean,char[],Random)}, but</span>
+<span class="source-line-no">194</span><span id="line-194">     * instead of 
using an externally supplied source of randomness, it uses the internal static 
{@link Random}</span>
+<span class="source-line-no">195</span><span id="line-195">     * 
instance.</span>
+<span class="source-line-no">196</span><span id="line-196">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">197</span><span id="line-197">     *</span>
+<span class="source-line-no">198</span><span id="line-198">     * @param count 
  the length of random string to create</span>
+<span class="source-line-no">199</span><span id="line-199">     * @param start 
  the position in set of chars to start at</span>
+<span class="source-line-no">200</span><span id="line-200">     * @param end   
  the position in set of chars to end before</span>
+<span class="source-line-no">201</span><span id="line-201">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
+<span class="source-line-no">202</span><span id="line-202">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
+<span class="source-line-no">203</span><span id="line-203">     * @param chars 
  the set of chars to choose randoms from. If {@code null}, then it will use 
the set of all chars.</span>
+<span class="source-line-no">204</span><span id="line-204">     * @return the 
random string</span>
+<span class="source-line-no">205</span><span id="line-205">     * @throws 
ArrayIndexOutOfBoundsException if there are not {@code (end - start) + 1} 
characters in the set array.</span>
+<span class="source-line-no">206</span><span id="line-206">     * @throws 
IllegalArgumentException       if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">207</span><span id="line-207">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
+<span class="source-line-no">208</span><span id="line-208">     */</span>
+<span class="source-line-no">209</span><span id="line-209">    
@Deprecated</span>
+<span class="source-line-no">210</span><span id="line-210">    public static 
String random(final int count, final int start, final int end, final boolean 
letters,</span>
+<span class="source-line-no">211</span><span id="line-211">            final 
boolean numbers, final char... chars) {</span>
+<span class="source-line-no">212</span><span id="line-212">        return 
secure().next(count, start, end, letters, numbers, chars);</span>
+<span class="source-line-no">213</span><span id="line-213">    }</span>
+<span class="source-line-no">214</span><span id="line-214"></span>
+<span class="source-line-no">215</span><span id="line-215">    /**</span>
+<span class="source-line-no">216</span><span id="line-216">     * Creates a 
random string based on a variety of options, using supplied source of 
randomness.</span>
+<span class="source-line-no">217</span><span id="line-217">     *</span>
+<span class="source-line-no">218</span><span id="line-218">     * 
&lt;p&gt;</span>
+<span class="source-line-no">219</span><span id="line-219">     * If start and 
end are both {@code 0}, start and end are set to {@code ' '} and {@code 'z'}, 
the ASCII printable</span>
+<span class="source-line-no">220</span><span id="line-220">     * characters, 
will be used, unless letters and numbers are both {@code false}, in which case, 
start and end are set</span>
+<span class="source-line-no">221</span><span id="line-221">     * to {@code 0} 
and {@link Character#MAX_CODE_POINT}.</span>
+<span class="source-line-no">222</span><span id="line-222">     *</span>
+<span class="source-line-no">223</span><span id="line-223">     * 
&lt;p&gt;</span>
+<span class="source-line-no">224</span><span id="line-224">     * If set is 
not {@code null}, characters between start and end are chosen.</span>
+<span class="source-line-no">225</span><span id="line-225">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">226</span><span id="line-226">     *</span>
+<span class="source-line-no">227</span><span id="line-227">     * 
&lt;p&gt;</span>
+<span class="source-line-no">228</span><span id="line-228">     * This method 
accepts a user-supplied {@link Random} instance to use as a source of 
randomness. By seeding a single</span>
+<span class="source-line-no">229</span><span id="line-229">     * {@link 
Random} instance with a fixed seed and using it for each call, the same random 
sequence of strings can be</span>
+<span class="source-line-no">230</span><span id="line-230">     * generated 
repeatedly and predictably.</span>
+<span class="source-line-no">231</span><span id="line-231">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">232</span><span id="line-232">     *</span>
+<span class="source-line-no">233</span><span id="line-233">     * @param count 
  the length of random string to create</span>
+<span class="source-line-no">234</span><span id="line-234">     * @param start 
  the position in set of chars to start at (inclusive)</span>
+<span class="source-line-no">235</span><span id="line-235">     * @param end   
  the position in set of chars to end before (exclusive)</span>
+<span class="source-line-no">236</span><span id="line-236">     * @param 
letters if {@code true}, generated string may include alphabetic 
characters</span>
+<span class="source-line-no">237</span><span id="line-237">     * @param 
numbers if {@code true}, generated string may include numeric characters</span>
+<span class="source-line-no">238</span><span id="line-238">     * @param chars 
  the set of chars to choose randoms from, must not be empty. If {@code null}, 
then it will use the</span>
+<span class="source-line-no">239</span><span id="line-239">     *              
  set of all chars.</span>
+<span class="source-line-no">240</span><span id="line-240">     * @param 
random  a source of randomness.</span>
+<span class="source-line-no">241</span><span id="line-241">     * @return the 
random string</span>
+<span class="source-line-no">242</span><span id="line-242">     * @throws 
ArrayIndexOutOfBoundsException if there are not {@code (end - start) + 1} 
characters in the set array.</span>
+<span class="source-line-no">243</span><span id="line-243">     * @throws 
IllegalArgumentException       if {@code count} &amp;lt; 0 or the provided 
chars array is empty.</span>
+<span class="source-line-no">244</span><span id="line-244">     * @since 
2.0</span>
+<span class="source-line-no">245</span><span id="line-245">     */</span>
+<span class="source-line-no">246</span><span id="line-246">    public static 
String random(int count, int start, int end, final boolean letters, final 
boolean numbers,</span>
+<span class="source-line-no">247</span><span id="line-247">            final 
char[] chars, final Random random) {</span>
+<span class="source-line-no">248</span><span id="line-248">        if (count 
== 0) {</span>
+<span class="source-line-no">249</span><span id="line-249">            return 
StringUtils.EMPTY;</span>
+<span class="source-line-no">250</span><span id="line-250">        }</span>
+<span class="source-line-no">251</span><span id="line-251">        if (count 
&lt; 0) {</span>
+<span class="source-line-no">252</span><span id="line-252">            throw 
new IllegalArgumentException("Requested random string length " + count + " is 
less than 0.");</span>
+<span class="source-line-no">253</span><span id="line-253">        }</span>
+<span class="source-line-no">254</span><span id="line-254">        if (chars 
!= null &amp;&amp; chars.length == 0) {</span>
+<span class="source-line-no">255</span><span id="line-255">            throw 
new IllegalArgumentException("The chars array must not be empty");</span>
+<span class="source-line-no">256</span><span id="line-256">        }</span>
+<span class="source-line-no">257</span><span id="line-257"></span>
+<span class="source-line-no">258</span><span id="line-258">        if (start 
== 0 &amp;&amp; end == 0) {</span>
+<span class="source-line-no">259</span><span id="line-259">            if 
(chars != null) {</span>
+<span class="source-line-no">260</span><span id="line-260">                end 
= chars.length;</span>
+<span class="source-line-no">261</span><span id="line-261">            } else 
if (!letters &amp;&amp; !numbers) {</span>
+<span class="source-line-no">262</span><span id="line-262">                end 
= Character.MAX_CODE_POINT;</span>
+<span class="source-line-no">263</span><span id="line-263">            } else 
{</span>
+<span class="source-line-no">264</span><span id="line-264">                end 
= 'z' + 1;</span>
+<span class="source-line-no">265</span><span id="line-265">                
start = ' ';</span>
+<span class="source-line-no">266</span><span id="line-266">            }</span>
+<span class="source-line-no">267</span><span id="line-267">        } else if 
(end &lt;= start) {</span>
+<span class="source-line-no">268</span><span id="line-268">            throw 
new IllegalArgumentException(</span>
+<span class="source-line-no">269</span><span id="line-269">                    
"Parameter end (" + end + ") must be greater than start (" + start + 
")");</span>
+<span class="source-line-no">270</span><span id="line-270">        } else if 
(start &lt; 0 || end &lt; 0) {</span>
+<span class="source-line-no">271</span><span id="line-271">            throw 
new IllegalArgumentException("Character positions MUST be &gt;= 0");</span>
+<span class="source-line-no">272</span><span id="line-272">        }</span>
+<span class="source-line-no">273</span><span id="line-273"></span>
+<span class="source-line-no">274</span><span id="line-274">        if (end 
&gt; Character.MAX_CODE_POINT) {</span>
+<span class="source-line-no">275</span><span id="line-275">            // 
Technically, it should be `Character.MAX_CODE_POINT+1` as `end` is 
excluded</span>
+<span class="source-line-no">276</span><span id="line-276">            // But 
the character `Character.MAX_CODE_POINT` is private use, so it would anyway be 
excluded</span>
+<span class="source-line-no">277</span><span id="line-277">            end = 
Character.MAX_CODE_POINT;</span>
+<span class="source-line-no">278</span><span id="line-278">        }</span>
+<span class="source-line-no">279</span><span id="line-279"></span>
+<span class="source-line-no">280</span><span id="line-280">        // Optimize 
generation of full alphanumerical characters</span>
+<span class="source-line-no">281</span><span id="line-281">        // 
Normally, we would need to pick a 7-bit integer, since gap = 'z' - '0' + 1 = 75 
&gt; 64</span>
+<span class="source-line-no">282</span><span id="line-282">        // In turn, 
this would make us reject the sampling with probability 1 - 62 / 2^7 &gt; 1 / 
2</span>
+<span class="source-line-no">283</span><span id="line-283">        // Instead 
we can pick directly from the right set of 62 characters, which requires</span>
+<span class="source-line-no">284</span><span id="line-284">        // picking 
a 6-bit integer and only rejecting with probability 2 / 64 = 1 / 32</span>
+<span class="source-line-no">285</span><span id="line-285">        if (chars 
== null &amp;&amp; letters &amp;&amp; numbers &amp;&amp; start &lt;= '0' 
&amp;&amp; end &gt;= 'z' + 1) {</span>
+<span class="source-line-no">286</span><span id="line-286">            return 
random(count, 0, 0, false, false, ALPHANUMERICAL_CHARS, random);</span>
+<span class="source-line-no">287</span><span id="line-287">        }</span>
+<span class="source-line-no">288</span><span id="line-288"></span>
+<span class="source-line-no">289</span><span id="line-289">        // Optimize 
start and end when filtering by letters and/or numbers:</span>
+<span class="source-line-no">290</span><span id="line-290">        // The 
range provided may be too large since we filter anyway afterward.</span>
+<span class="source-line-no">291</span><span id="line-291">        // Note the 
use of Math.min/max (as opposed to setting start to '0' for example),</span>
+<span class="source-line-no">292</span><span id="line-292">        // since it 
is possible the range start/end excludes some of the letters/numbers,</span>
+<span class="source-line-no">293</span><span id="line-293">        // e.g., it 
is possible that start already is '1' when numbers = true, and start</span>
+<span class="source-line-no">294</span><span id="line-294">        // needs to 
stay equal to '1' in that case.</span>
+<span class="source-line-no">295</span><span id="line-295">        if (chars 
== null) {</span>
+<span class="source-line-no">296</span><span id="line-296">            if 
(letters &amp;&amp; numbers) {</span>
+<span class="source-line-no">297</span><span id="line-297">                
start = Math.max('0', start);</span>
+<span class="source-line-no">298</span><span id="line-298">                end 
= Math.min('z' + 1, end);</span>
+<span class="source-line-no">299</span><span id="line-299">            } else 
if (numbers) {</span>
+<span class="source-line-no">300</span><span id="line-300">                // 
just numbers, no letters</span>
+<span class="source-line-no">301</span><span id="line-301">                
start = Math.max('0', start);</span>
+<span class="source-line-no">302</span><span id="line-302">                end 
= Math.min('9' + 1, end);</span>
+<span class="source-line-no">303</span><span id="line-303">            } else 
if (letters) {</span>
+<span class="source-line-no">304</span><span id="line-304">                // 
just letters, no numbers</span>
+<span class="source-line-no">305</span><span id="line-305">                
start = Math.max('A', start);</span>
+<span class="source-line-no">306</span><span id="line-306">                end 
= Math.min('z' + 1, end);</span>
+<span class="source-line-no">307</span><span id="line-307">            }</span>
+<span class="source-line-no">308</span><span id="line-308">        }</span>
+<span class="source-line-no">309</span><span id="line-309"></span>
+<span class="source-line-no">310</span><span id="line-310">        final int 
zeroDigitAscii = 48;</span>
+<span class="source-line-no">311</span><span id="line-311">        final int 
firstLetterAscii = 65;</span>
+<span class="source-line-no">312</span><span id="line-312"></span>
+<span class="source-line-no">313</span><span id="line-313">        if (chars 
== null &amp;&amp; (numbers &amp;&amp; end &lt;= zeroDigitAscii || letters 
&amp;&amp; end &lt;= firstLetterAscii)) {</span>
+<span class="source-line-no">314</span><span id="line-314">            throw 
new IllegalArgumentException(</span>
+<span class="source-line-no">315</span><span id="line-315">                    
"Parameter end (" + end + ") must be greater then (" + zeroDigitAscii + ") for 
generating digits "</span>
+<span class="source-line-no">316</span><span id="line-316">                    
        + "or greater then (" + firstLetterAscii + ") for generating 
letters.");</span>
+<span class="source-line-no">317</span><span id="line-317">        }</span>
 <span class="source-line-no">318</span><span id="line-318"></span>
-<span class="source-line-no">319</span><span id="line-319">                
switch (Character.getType(codePoint)) {</span>
-<span class="source-line-no">320</span><span id="line-320">                
case Character.UNASSIGNED:</span>
-<span class="source-line-no">321</span><span id="line-321">                
case Character.PRIVATE_USE:</span>
-<span class="source-line-no">322</span><span id="line-322">                
case Character.SURROGATE:</span>
-<span class="source-line-no">323</span><span id="line-323">                    
count++;</span>
-<span class="source-line-no">324</span><span id="line-324">                    
continue;</span>
-<span class="source-line-no">325</span><span id="line-325">                
}</span>
-<span class="source-line-no">326</span><span id="line-326"></span>
-<span class="source-line-no">327</span><span id="line-327">            } else 
{</span>
-<span class="source-line-no">328</span><span id="line-328">                
codePoint = chars[randomValue];</span>
-<span class="source-line-no">329</span><span id="line-329">            }</span>
-<span class="source-line-no">330</span><span id="line-330"></span>
-<span class="source-line-no">331</span><span id="line-331">            final 
int numberOfChars = Character.charCount(codePoint);</span>
-<span class="source-line-no">332</span><span id="line-332">            if 
(count == 0 &amp;&amp; numberOfChars &gt; 1) {</span>
-<span class="source-line-no">333</span><span id="line-333">                
count++;</span>
-<span class="source-line-no">334</span><span id="line-334">                
continue;</span>
-<span class="source-line-no">335</span><span id="line-335">            }</span>
-<span class="source-line-no">336</span><span id="line-336"></span>
-<span class="source-line-no">337</span><span id="line-337">            if 
(letters &amp;&amp; Character.isLetter(codePoint) || numbers &amp;&amp; 
Character.isDigit(codePoint)</span>
-<span class="source-line-no">338</span><span id="line-338">                    
|| !letters &amp;&amp; !numbers) {</span>
-<span class="source-line-no">339</span><span id="line-339">                
builder.appendCodePoint(codePoint);</span>
-<span class="source-line-no">340</span><span id="line-340"></span>
-<span class="source-line-no">341</span><span id="line-341">                if 
(numberOfChars == 2) {</span>
-<span class="source-line-no">342</span><span id="line-342">                    
count--;</span>
-<span class="source-line-no">343</span><span id="line-343">                
}</span>
-<span class="source-line-no">344</span><span id="line-344"></span>
-<span class="source-line-no">345</span><span id="line-345">            } else 
{</span>
-<span class="source-line-no">346</span><span id="line-346">                
count++;</span>
-<span class="source-line-no">347</span><span id="line-347">            }</span>
-<span class="source-line-no">348</span><span id="line-348">        }</span>
-<span class="source-line-no">349</span><span id="line-349">        return 
builder.toString();</span>
-<span class="source-line-no">350</span><span id="line-350">    }</span>
-<span class="source-line-no">351</span><span id="line-351"></span>
-<span class="source-line-no">352</span><span id="line-352">    /**</span>
-<span class="source-line-no">353</span><span id="line-353">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">354</span><span id="line-354">     *</span>
-<span class="source-line-no">355</span><span id="line-355">     * 
&lt;p&gt;</span>
-<span class="source-line-no">356</span><span id="line-356">     * Characters 
will be chosen from the set of characters specified by the string, must not be 
empty. If null, the set</span>
-<span class="source-line-no">357</span><span id="line-357">     * of all 
characters is used.</span>
-<span class="source-line-no">358</span><span id="line-358">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">359</span><span id="line-359">     *</span>
-<span class="source-line-no">360</span><span id="line-360">     * @param count 
the length of random string to create</span>
-<span class="source-line-no">361</span><span id="line-361">     * @param chars 
the String containing the set of characters to use, may be null, but must not 
be empty</span>
-<span class="source-line-no">362</span><span id="line-362">     * @return the 
random string</span>
-<span class="source-line-no">363</span><span id="line-363">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0 or the string is 
empty.</span>
-<span class="source-line-no">364</span><span id="line-364">     */</span>
-<span class="source-line-no">365</span><span id="line-365">    public static 
String random(final int count, final String chars) {</span>
-<span class="source-line-no">366</span><span id="line-366">        return 
secure().next(count, chars);</span>
-<span class="source-line-no">367</span><span id="line-367">    }</span>
-<span class="source-line-no">368</span><span id="line-368"></span>
-<span class="source-line-no">369</span><span id="line-369">    /**</span>
-<span class="source-line-no">370</span><span id="line-370">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">371</span><span id="line-371">     *</span>
-<span class="source-line-no">372</span><span id="line-372">     * 
&lt;p&gt;</span>
-<span class="source-line-no">373</span><span id="line-373">     * Characters 
will be chosen from the set of Latin alphabetic characters (a-z, A-Z).</span>
-<span class="source-line-no">374</span><span id="line-374">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">375</span><span id="line-375">     *</span>
-<span class="source-line-no">376</span><span id="line-376">     * @param count 
the length of random string to create</span>
-<span class="source-line-no">377</span><span id="line-377">     * @return the 
random string</span>
-<span class="source-line-no">378</span><span id="line-378">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
-<span class="source-line-no">379</span><span id="line-379">     */</span>
-<span class="source-line-no">380</span><span id="line-380">    public static 
String randomAlphabetic(final int count) {</span>
-<span class="source-line-no">381</span><span id="line-381">        return 
secure().nextAlphabetic(count);</span>
-<span class="source-line-no">382</span><span id="line-382">    }</span>
-<span class="source-line-no">383</span><span id="line-383"></span>
-<span class="source-line-no">384</span><span id="line-384">    /**</span>
-<span class="source-line-no">385</span><span id="line-385">     * Creates a 
random string whose length is between the inclusive minimum and the exclusive 
maximum.</span>
-<span class="source-line-no">386</span><span id="line-386">     *</span>
-<span class="source-line-no">387</span><span id="line-387">     * 
&lt;p&gt;</span>
-<span class="source-line-no">388</span><span id="line-388">     * Characters 
will be chosen from the set of Latin alphabetic characters (a-z, A-Z).</span>
-<span class="source-line-no">389</span><span id="line-389">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">390</span><span id="line-390">     *</span>
-<span class="source-line-no">391</span><span id="line-391">     * @param 
minLengthInclusive the inclusive minimum length of the string to generate</span>
-<span class="source-line-no">392</span><span id="line-392">     * @param 
maxLengthExclusive the exclusive maximum length of the string to generate</span>
-<span class="source-line-no">393</span><span id="line-393">     * @return the 
random string</span>
-<span class="source-line-no">394</span><span id="line-394">     * @since 
3.5</span>
-<span class="source-line-no">395</span><span id="line-395">     */</span>
-<span class="source-line-no">396</span><span id="line-396">    public static 
String randomAlphabetic(final int minLengthInclusive, final int 
maxLengthExclusive) {</span>
-<span class="source-line-no">397</span><span id="line-397">        return 
secure().nextAlphabetic(minLengthInclusive, maxLengthExclusive);</span>
-<span class="source-line-no">398</span><span id="line-398">    }</span>
-<span class="source-line-no">399</span><span id="line-399"></span>
-<span class="source-line-no">400</span><span id="line-400">    /**</span>
-<span class="source-line-no">401</span><span id="line-401">     * Creates a 
random string whose length is the number of characters specified.</span>
-<span class="source-line-no">402</span><span id="line-402">     *</span>
-<span class="source-line-no">403</span><span id="line-403">     * 
&lt;p&gt;</span>
-<span class="source-line-no">404</span><span id="line-404">     * Characters 
will be chosen from the set of Latin alphabetic characters (a-z, A-Z) and the 
digits 0-9.</span>
-<span class="source-line-no">405</span><span id="line-405">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">406</span><span id="line-406">     *</span>
-<span class="source-line-no">407</span><span id="line-407">     * @param count 
the length of random string to create</span>
-<span class="source-line-no">408</span><span id="line-408">     * @return the 
random string</span>
-<span class="source-line-no">409</span><span id="line-409">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
-<span class="source-line-no">410</span><span id="line-410">     */</span>
-<span class="source-line-no">411</span><span id="line-411">    public static 
String randomAlphanumeric(final int count) {</span>
-<span class="source-line-no">412</span><span id="line-412">        return 
secure().nextAlphanumeric(count);</span>
-<span class="source-line-no">413</span><span id="line-413">    }</span>
-<span class="source-line-no">414</span><span id="line-414"></span>
-<span class="source-line-no">415</span><span id="line-415">    /**</span>
-<span class="source-line-no">416</span><span id="line-416">     * Creates a 
random string whose length is between the inclusive minimum and the exclusive 
maximum.</span>
+<span class="source-line-no">319</span><span id="line-319">        final 
StringBuilder builder = new StringBuilder(count);</span>
+<span class="source-line-no">320</span><span id="line-320">        final int 
gap = end - start;</span>
+<span class="source-line-no">321</span><span id="line-321">        final int 
gapBits = Integer.SIZE - Integer.numberOfLeadingZeros(gap);</span>
+<span class="source-line-no">322</span><span id="line-322">        // The size 
of the cache we use is an heuristic:</span>
+<span class="source-line-no">323</span><span id="line-323">        // about 
twice the number of bytes required if no rejection</span>
+<span class="source-line-no">324</span><span id="line-324">        // Ideally 
the cache size depends on multiple factor, including the cost of generating x 
bytes</span>
+<span class="source-line-no">325</span><span id="line-325">        // of 
randomness as well as the probability of rejection. It is however not easy to 
know</span>
+<span class="source-line-no">326</span><span id="line-326">        // those 
values programmatically for the general case.</span>
+<span class="source-line-no">327</span><span id="line-327">        final 
CachedRandomBits arb = new CachedRandomBits((count * gapBits + 3) / 5 + 10, 
random);</span>
+<span class="source-line-no">328</span><span id="line-328"></span>
+<span class="source-line-no">329</span><span id="line-329">        while 
(count-- != 0) {</span>
+<span class="source-line-no">330</span><span id="line-330">            // 
Generate a random value between start (included) and end (excluded)</span>
+<span class="source-line-no">331</span><span id="line-331">            final 
int randomValue = arb.nextBits(gapBits) + start;</span>
+<span class="source-line-no">332</span><span id="line-332">            // 
Rejection sampling if value too large</span>
+<span class="source-line-no">333</span><span id="line-333">            if 
(randomValue &gt;= end) {</span>
+<span class="source-line-no">334</span><span id="line-334">                
count++;</span>
+<span class="source-line-no">335</span><span id="line-335">                
continue;</span>
+<span class="source-line-no">336</span><span id="line-336">            }</span>
+<span class="source-line-no">337</span><span id="line-337"></span>
+<span class="source-line-no">338</span><span id="line-338">            final 
int codePoint;</span>
+<span class="source-line-no">339</span><span id="line-339">            if 
(chars == null) {</span>
+<span class="source-line-no">340</span><span id="line-340">                
codePoint = randomValue;</span>
+<span class="source-line-no">341</span><span id="line-341"></span>
+<span class="source-line-no">342</span><span id="line-342">                
switch (Character.getType(codePoint)) {</span>
+<span class="source-line-no">343</span><span id="line-343">                
case Character.UNASSIGNED:</span>
+<span class="source-line-no">344</span><span id="line-344">                
case Character.PRIVATE_USE:</span>
+<span class="source-line-no">345</span><span id="line-345">                
case Character.SURROGATE:</span>
+<span class="source-line-no">346</span><span id="line-346">                    
count++;</span>
+<span class="source-line-no">347</span><span id="line-347">                    
continue;</span>
+<span class="source-line-no">348</span><span id="line-348">                
}</span>
+<span class="source-line-no">349</span><span id="line-349"></span>
+<span class="source-line-no">350</span><span id="line-350">            } else 
{</span>
+<span class="source-line-no">351</span><span id="line-351">                
codePoint = chars[randomValue];</span>
+<span class="source-line-no">352</span><span id="line-352">            }</span>
+<span class="source-line-no">353</span><span id="line-353"></span>
+<span class="source-line-no">354</span><span id="line-354">            final 
int numberOfChars = Character.charCount(codePoint);</span>
+<span class="source-line-no">355</span><span id="line-355">            if 
(count == 0 &amp;&amp; numberOfChars &gt; 1) {</span>
+<span class="source-line-no">356</span><span id="line-356">                
count++;</span>
+<span class="source-line-no">357</span><span id="line-357">                
continue;</span>
+<span class="source-line-no">358</span><span id="line-358">            }</span>
+<span class="source-line-no">359</span><span id="line-359"></span>
+<span class="source-line-no">360</span><span id="line-360">            if 
(letters &amp;&amp; Character.isLetter(codePoint) || numbers &amp;&amp; 
Character.isDigit(codePoint)</span>
+<span class="source-line-no">361</span><span id="line-361">                    
|| !letters &amp;&amp; !numbers) {</span>
+<span class="source-line-no">362</span><span id="line-362">                
builder.appendCodePoint(codePoint);</span>
+<span class="source-line-no">363</span><span id="line-363"></span>
+<span class="source-line-no">364</span><span id="line-364">                if 
(numberOfChars == 2) {</span>
+<span class="source-line-no">365</span><span id="line-365">                    
count--;</span>
+<span class="source-line-no">366</span><span id="line-366">                
}</span>
+<span class="source-line-no">367</span><span id="line-367"></span>
+<span class="source-line-no">368</span><span id="line-368">            } else 
{</span>
+<span class="source-line-no">369</span><span id="line-369">                
count++;</span>
+<span class="source-line-no">370</span><span id="line-370">            }</span>
+<span class="source-line-no">371</span><span id="line-371">        }</span>
+<span class="source-line-no">372</span><span id="line-372">        return 
builder.toString();</span>
+<span class="source-line-no">373</span><span id="line-373">    }</span>
+<span class="source-line-no">374</span><span id="line-374"></span>
+<span class="source-line-no">375</span><span id="line-375">    /**</span>
+<span class="source-line-no">376</span><span id="line-376">     * Creates a 
random string whose length is the number of characters specified.</span>
+<span class="source-line-no">377</span><span id="line-377">     *</span>
+<span class="source-line-no">378</span><span id="line-378">     * 
&lt;p&gt;</span>
+<span class="source-line-no">379</span><span id="line-379">     * Characters 
will be chosen from the set of characters specified by the string, must not be 
empty. If null, the set</span>
+<span class="source-line-no">380</span><span id="line-380">     * of all 
characters is used.</span>
+<span class="source-line-no">381</span><span id="line-381">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">382</span><span id="line-382">     *</span>
+<span class="source-line-no">383</span><span id="line-383">     * @param count 
the length of random string to create</span>
+<span class="source-line-no">384</span><span id="line-384">     * @param chars 
the String containing the set of characters to use, may be null, but must not 
be empty</span>
+<span class="source-line-no">385</span><span id="line-385">     * @return the 
random string</span>
+<span class="source-line-no">386</span><span id="line-386">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0 or the string is 
empty.</span>
+<span class="source-line-no">387</span><span id="line-387">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
+<span class="source-line-no">388</span><span id="line-388">     */</span>
+<span class="source-line-no">389</span><span id="line-389">    
@Deprecated</span>
+<span class="source-line-no">390</span><span id="line-390">    public static 
String random(final int count, final String chars) {</span>
+<span class="source-line-no">391</span><span id="line-391">        return 
secure().next(count, chars);</span>
+<span class="source-line-no">392</span><span id="line-392">    }</span>
+<span class="source-line-no">393</span><span id="line-393"></span>
+<span class="source-line-no">394</span><span id="line-394">    /**</span>
+<span class="source-line-no">395</span><span id="line-395">     * Creates a 
random string whose length is the number of characters specified.</span>
+<span class="source-line-no">396</span><span id="line-396">     *</span>
+<span class="source-line-no">397</span><span id="line-397">     * 
&lt;p&gt;</span>
+<span class="source-line-no">398</span><span id="line-398">     * Characters 
will be chosen from the set of Latin alphabetic characters (a-z, A-Z).</span>
+<span class="source-line-no">399</span><span id="line-399">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">400</span><span id="line-400">     *</span>
+<span class="source-line-no">401</span><span id="line-401">     * @param count 
the length of random string to create</span>
+<span class="source-line-no">402</span><span id="line-402">     * @return the 
random string</span>
+<span class="source-line-no">403</span><span id="line-403">     * @throws 
IllegalArgumentException if {@code count} &amp;lt; 0.</span>
+<span class="source-line-no">404</span><span id="line-404">     * @deprecated 
Use {@link #secure()}, {@link #secureStrong()},or {@link #insecure()}.</span>
+<span class="source-line-no">405</span><span id="line-405">     */</span>
+<span class="source-line-no">406</span><span id="line-406">    
@Deprecated</span>
+<span class="source-line-no">407</span><span id="line-407">    public static 
String randomAlphabetic(final int count) {</span>
+<span class="source-line-no">408</span><span id="line-408">        return 
secure().nextAlphabetic(count);</span>
+<span class="source-line-no">409</span><span id="line-409">    }</span>
+<span class="source-line-no">410</span><span id="line-410"></span>
+<span class="source-line-no">411</span><span id="line-411">    /**</span>
+<span class="source-line-no">412</span><span id="line-412">     * Creates a 
random string whose length is between the inclusive minimum and the exclusive 
maximum.</span>
+<span class="source-line-no">413</span><span id="line-413">     *</span>
+<span class="source-line-no">414</span><span id="line-414">     * 
&lt;p&gt;</span>
+<span class="source-line-no">415</span><span id="line-415">     * Characters 
will be chosen from the set of Latin alphabetic characters (a-z, A-Z).</span>
+<span class="source-line-no">416</span><span id="line-416">     * 
&lt;/p&gt;</span>
 <span class="source-line-no">417</span><span id="line-417">     *</span>
-<span class="source-line-no">418</span><span id="line-418">     * 
&lt;p&gt;</span>
-<span class="source-line-no">419</span><span id="line-419">     * Characters 
will be chosen from the set of Latin alphabetic characters (a-z, A-Z) and the 
digits 0-9.</span>
-<span class="source-line-no">420</span><span id="line-420">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">421</span><span id="line-421">     *</span>
-<span class="source-line-no">422</span><span id="line-422">     * @param 
minLengthInclusive the inclusive minimum length of the string to generate</span>
-<span class="source-line-no">423</span><span id="line-423">     * @param 
maxLengthExclusive the exclusive maximum length of the string to generate</span>
-<span class="source-line-no">424</span><span id="line-424">     * @return the 
random string</span>
-<span class="source-line-no">425</span><span id="line-425">     * @since 
3.5</span>
-<span class="source-line-no">426</span><span id="line-426">     */</span>
-<span class="source-line-no">427</span><span id="line-427">    public static 
String randomAlphanumeric(final int minLengthInclusive, final int 
maxLengthExclusive) {</span>
-<span class="source-line-no">428</span><span id="line-428">        return 
secure().nextAlphanumeric(minLengthInclusive, maxLengthExclusive);</span>
-<span class="source-line-no">429</span><span id="line-429">    }</span>

[... 1033 lines stripped ...]

Reply via email to