content: /**
   * Copyright 2014 Zhenguo Jin
   * <p/>
   * Licensed 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
   * <p/>
   * http://www.apache.org/licenses/LICENSE-2.0
   * <p/>
   * 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 com.rsen.github.androidutils;
  
  import android.text.TextUtils;
  
  import java.util.Random;
  
  /**
   * Random Utils
   * <ul>
   * Shuffling algorithm
   * <li>{@link #shuffle(Object[])} Shuffling algorithm, Randomly permutes the specified array using a default source of
   * randomness</li>
   * <li>{@link #shuffle(Object[], int)} Shuffling algorithm, Randomly permutes the specified array</li>
   * <li>{@link #shuffle(int[])} Shuffling algorithm, Randomly permutes the specified int array using a default source of
   * randomness</li>
   * <li>{@link #shuffle(int[], int)} Shuffling algorithm, Randomly permutes the specified int array</li>
   * </ul>
   * <ul>
   * get random int
   * <li>{@link #getRandom(int)} get random int between 0 and max</li>
   * <li>{@link #getRandom(int, int)} get random int between min and max</li>
   * </ul>
   * <ul>
   * get random numbers or letters
   * <li>{@link #getRandomCapitalLetters(int)} get a fixed-length random string, its a mixture of uppercase letters</li>
   * <li>{@link #getRandomLetters(int)} get a fixed-length random string, its a mixture of uppercase and lowercase letters
   * </li>
   * <li>{@link #getRandomLowerCaseLetters(int)} get a fixed-length random string, its a mixture of lowercase letters</li>
   * <li>{@link #getRandomNumbers(int)} get a fixed-length random string, its a mixture of numbers</li>
   * <li>{@link #getRandomNumbersAndLetters(int)} get a fixed-length random string, its a mixture of uppercase, lowercase
   * letters and numbers</li>
   * <li>{@link #getRandom(String, int)} get a fixed-length random string, its a mixture of chars in source</li>
   * <li>{@link #getRandom(char[], int)} get a fixed-length random string, its a mixture of chars in sourceChar</li>
   * </ul>
   *
   * @author jingle1267@163.com
   */
  public final class RandomUtils {
  
      public static final String NUMBERS_AND_LETTERS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
      public static final String NUMBERS = "0123456789";
      public static final String LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
      public static final String CAPITAL_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      public static final String LOWER_CASE_LETTERS = "abcdefghijklmnopqrstuvwxyz";
  
      /**
       * Don't let anyone instantiate this class.
       */
      private RandomUtils() {
          throw new Error("Do not need instantiate!");
      }
  
      /**
       * get a fixed-length random string, its a mixture of uppercase, lowercase letters and numbers
       *
       * @param length 长度
       * @return 随机字符串
       * @see RandomUtils#getRandom(String source, int length)
       */
      public static String getRandomNumbersAndLetters(int length) {
          return getRandom(NUMBERS_AND_LETTERS, length);
      }
  
      /**
       * get a fixed-length random string, its a mixture of numbers
       *
       * @param length 长度
       * @return 随机数字符串
       * @see RandomUtils#getRandom(String source, int length)
       */
      public static String getRandomNumbers(int length) {
          return getRandom(NUMBERS, length);
      }
  
      /**
       * get a fixed-length random string, its a mixture of uppercase and lowercase letters
       *
       * @param length 长度
       * @return 随机字母字符串
       * @see RandomUtils#getRandom(String source, int length)
       */
      public static String getRandomLetters(int length) {
          return getRandom(LETTERS, length);
      }
  
      /**
       * get a fixed-length random string, its a mixture of uppercase letters
       *
       * @param length 长度
       * @return 随机字符串 包括大写字母
       * @see RandomUtils#getRandom(String source, int length)
       */
      public static String getRandomCapitalLetters(int length) {
          return getRandom(CAPITAL_LETTERS, length);
      }
  
      /**
       * get a fixed-length random string, its a mixture of lowercase letters
       *
       * @param length 长度
       * @return 随机字符串 包括小写字母
       * @see RandomUtils#getRandom(String source, int length)
       */
      public static String getRandomLowerCaseLetters(int length) {
          return getRandom(LOWER_CASE_LETTERS, length);
      }
  
      /**
       * get a fixed-length random string, its a mixture of chars in source
       *
       * @param source 源字符串
       * @param length 长度
       * @return <ul>
       * <li>if source is null or empty, return null</li>
       * <li>else see {@link RandomUtils#getRandom(char[] sourceChar, int length)}</li>
       * </ul>
       */
      public static String getRandom(String source, int length) {
          return TextUtils.isEmpty(source) ? null : getRandom(source.toCharArray(), length);
      }
  
      /**
       * get a fixed-length random string, its a mixture of chars in sourceChar
       *
       * @param sourceChar 源
       * @param length     长度
       * @return <ul>
       * <li>if sourceChar is null or empty, return null</li>
       * <li>if length less than 0, return null</li>
       * </ul>
       */
      public static String getRandom(char[] sourceChar, int length) {
          if (sourceChar == null || sourceChar.length == 0 || length < 0) {
              return null;
          }
  
          StringBuilder str = new StringBuilder(length);
          Random random = new Random();
          for (int i = 0; i < length; i++) {
              str.append(sourceChar[random.nextInt(sourceChar.length)]);
          }
          return str.toString();
      }
  
      /**
       * get random int between 0 and max
       *
       * @param max 最大随机数
       * @return <ul>
       * <li>if max <= 0, return 0</li>
       * <li>else return random int between 0 and max</li>
       * </ul>
       */
      public static int getRandom(int max) {
          return getRandom(0, max);
      }
  
      /**
       * get random int between min and max
       *
       * @param min 最小随机数
       * @param max 最大随机数
       * @return <ul>
       * <li>if min > max, return 0</li>
       * <li>if min == max, return min</li>
       * <li>else return random int between min and max</li>
       * </ul>
       */
      public static int getRandom(int min, int max) {
          if (min > max) {
              return 0;
          }
          if (min == max) {
              return min;
          }
          return min + new Random().nextInt(max - min);
      }
  
      /**
       * Shuffling algorithm, Randomly permutes the specified array using a default source of randomness
       *
       * @param objArray
       * @return
       */
      public static boolean shuffle(Object[] objArray) {
          if (objArray == null) {
              return false;
          }
  
          return shuffle(objArray, getRandom(objArray.length));
      }
  
      /**
       * Shuffling algorithm, Randomly permutes the specified array
       *
       * @param objArray
       * @param shuffleCount
       * @return
       */
      public static boolean shuffle(Object[] objArray, int shuffleCount) {
          int length;
          if (objArray == null || shuffleCount < 0 || (length = objArray.length) < shuffleCount) {
              return false;
          }
  
          for (int i = 1; i <= shuffleCount; i++) {
              int random = getRandom(length - i);
              Object temp = objArray[length - i];
              objArray[length - i] = objArray[random];
              objArray[random] = temp;
          }
          return true;
      }
  
      /**
       * Shuffling algorithm, Randomly permutes the specified int array using a default source of randomness
       *
       * @param intArray
       * @return
       */
      public static int[] shuffle(int[] intArray) {
          if (intArray == null) {
              return null;
          }
  
          return shuffle(intArray, getRandom(intArray.length));
      }
  
      /**
       * Shuffling algorithm, Randomly permutes the specified int array
       *
       * @param intArray
       * @param shuffleCount
       * @return
       */
      public static int[] shuffle(int[] intArray, int shuffleCount) {
          int length;
          if (intArray == null || shuffleCount < 0 || (length = intArray.length) < shuffleCount) {
              return null;
          }
  
          int[] out = new int[shuffleCount];
          for (int i = 1; i <= shuffleCount; i++) {
              int random = getRandom(length - i);
              out[i - 1] = intArray[random];
              int temp = intArray[length - i];
              intArray[length - i] = intArray[random];
              intArray[random] = temp;
          }
          return out;
      }
  }
  