All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.commons.lang3.RandomUtils Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.lang3;

import java.util.Random;

/**
 * 

Utility library that supplements the standard {@link Random} class.

* * @since 3.3 */ public class RandomUtils { /** * Random object used by random method. This has to be not local to the * random method so as to not return the same value in the same millisecond. */ private static final Random RANDOM = new Random(); /** *

* {@code RandomUtils} instances should NOT be constructed in standard * programming. Instead, the class should be used as * {@code RandomUtils.nextBytes(5);}. *

* *

* This constructor is public to permit tools that require a JavaBean * instance to operate. *

*/ public RandomUtils() { super(); } /** *

* Returns a random boolean value *

* * @return the random boolean * @since 3.5 */ public static boolean nextBoolean() { return RANDOM.nextBoolean(); } /** *

* Creates an array of random bytes. *

* * @param count * the size of the returned array * @return the random byte array * @throws IllegalArgumentException if {@code count} is negative */ public static byte[] nextBytes(final int count) { Validate.isTrue(count >= 0, "Count cannot be negative."); final byte[] result = new byte[count]; RANDOM.nextBytes(result); return result; } /** *

* Returns a random integer within the specified range. *

* * @param startInclusive * the smallest value that can be returned, must be non-negative * @param endExclusive * the upper bound (not included) * @throws IllegalArgumentException * if {@code startInclusive > endExclusive} or if * {@code startInclusive} is negative * @return the random integer */ public static int nextInt(final int startInclusive, final int endExclusive) { Validate.isTrue(endExclusive >= startInclusive, "Start value must be smaller or equal to end value."); Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative."); if (startInclusive == endExclusive) { return startInclusive; } return startInclusive + RANDOM.nextInt(endExclusive - startInclusive); } /** *

Returns a random int within 0 - Integer.MAX_VALUE

* * @return the random integer * @see #nextInt(int, int) * @since 3.5 */ public static int nextInt() { return nextInt(0, Integer.MAX_VALUE); } /** *

* Returns a random long within the specified range. *

* * @param startInclusive * the smallest value that can be returned, must be non-negative * @param endExclusive * the upper bound (not included) * @throws IllegalArgumentException * if {@code startInclusive > endExclusive} or if * {@code startInclusive} is negative * @return the random long */ public static long nextLong(final long startInclusive, final long endExclusive) { Validate.isTrue(endExclusive >= startInclusive, "Start value must be smaller or equal to end value."); Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative."); if (startInclusive == endExclusive) { return startInclusive; } return (long) nextDouble(startInclusive, endExclusive); } /** *

Returns a random long within 0 - Long.MAX_VALUE

* * @return the random long * @see #nextLong(long, long) * @since 3.5 */ public static long nextLong() { return nextLong(0, Long.MAX_VALUE); } /** *

* Returns a random double within the specified range. *

* * @param startInclusive * the smallest value that can be returned, must be non-negative * @param endInclusive * the upper bound (included) * @throws IllegalArgumentException * if {@code startInclusive > endInclusive} or if * {@code startInclusive} is negative * @return the random double */ public static double nextDouble(final double startInclusive, final double endInclusive) { Validate.isTrue(endInclusive >= startInclusive, "Start value must be smaller or equal to end value."); Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative."); if (startInclusive == endInclusive) { return startInclusive; } return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextDouble()); } /** *

Returns a random double within 0 - Double.MAX_VALUE

* * @return the random double * @see #nextDouble(double, double) * @since 3.5 */ public static double nextDouble() { return nextDouble(0, Double.MAX_VALUE); } /** *

* Returns a random float within the specified range. *

* * @param startInclusive * the smallest value that can be returned, must be non-negative * @param endInclusive * the upper bound (included) * @throws IllegalArgumentException * if {@code startInclusive > endInclusive} or if * {@code startInclusive} is negative * @return the random float */ public static float nextFloat(final float startInclusive, final float endInclusive) { Validate.isTrue(endInclusive >= startInclusive, "Start value must be smaller or equal to end value."); Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative."); if (startInclusive == endInclusive) { return startInclusive; } return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextFloat()); } /** *

Returns a random float within 0 - Float.MAX_VALUE

* * @return the random float * @see #nextFloat() * @since 3.5 */ public static float nextFloat() { return nextFloat(0, Float.MAX_VALUE); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy