Java工具类-素数类

引子

个人比较喜欢算法，在日常解题过程中，经常遇到各种跟素数有关的问题。为了方便未来使用，总结创建了素数工具类。

Prime类说明

Prime类用于处理素数相关问题，Prime类被设计为工具类，不允许创建实例，也不允许被继承，故以final修饰Prime类，并以private修饰默认构造器。

Prime类本身维护一个从2开始的素数列表(ArrayList)，类初始化时，根据sInitPrimeListLength的值，初始素数列表长度为1000，在进行各种处理时会用到这个数组，特称由Prime类维护的素数数组为类列表。利用类列表，已经计算过的素数不会再重复计算，提高效率。

类列表衍生两个变量，一个是列表长度，即类列表维护的从2开始的素数的个数，可由函数getPrimeListLength()获得。另一个是已知最大素数，即类列表的最后一个元素，可由函数getMaxCheckedPrime()获得。这两个值在素数类内部被广泛使用。

Prime类常用的方法有以下几个：
1. int[] getPrimeArrayByLength(int length)
2. int[] getPrimeArrayBelow(int num)
3. int[] getPrimeArrayBetween(int startNum, int endNum)

Prime类提供判断是否为素数的方法：
1. boolean isPrime(int)
2. boolean isProbablePrime(String num, int certainty)
3. boolean isQuickPrime(int num)

Prime类还提供求最小公倍数和最大公约数的函数，以及其它方法，具体可以查看下面的函数列表。

函数列表

• int[] getPrimeArray()
  将类列表中的素数转换为int数组返回
• int[] getPrimeArray(int start,int end)
  将类列表中索引start至end的元素转换为int数组返回
• int[] getPrimeArray(int length)
  将类列表中前length个素数转换为int数组返回
• int getPrimeListLength()
  返回类列表中元素的个数
• int getMaxCheckedPrime()
  返回类列表的最后一个元素
• boolean isPrime(int)
  判断一个int整数是否为素数
• boolean isProbablePrime(String num, int certainty)
  采用Miller-Rabin算法判断一个大整数是否为素数，可靠性为1-1/(2^certainty)
• boolean isQuickPrime(int num)
  利用类列表快速判断num是否为素数
• int[] getPrimeArrayByLength(int length)
  返回长度为length的素数数组
• int[] getPrimeArrayBelow(int num)
  返回小于等于num的素数数组
• int[] getPrimeArrayBetween(int startNum, int endNum)
  返回startNum与endNum之间的素数组成的数组
• int getPrimeIndex(int num)
  返回num在类列表中的索引，找不到返回-1
• int getPrimeIndex(int num, boolean isStrict)
  返回num在类列表中的索引，找不到时，如果isStrict为true，则返回小于num的第一个元素的索引
• int binarySearch(int[] arr, int key)
  在数组arr中查找key，如果找到则返回索引，找不到返回-1
• int binarySearch(int[] arr, int key, boolean isStrict)
  在数组arr中查找key，找不到时，如果isStrict为true，则返回小于num的第一个元素的索引
• int Gcd(int a, int b)
  返回a和b的最大公约数,如果a<=0或b<=0，则返回0
• int Gcd(int[] numArray)
  返回数组内所有整数的最大公约数
• int Lcm(int a, int b)
  返回a,b的最小公倍数
• int Lcm(int[] numArray)
  返回数组内所有整数的最小公倍数

git代码仓库地址

下面是java源代码。对这个素数类有什么建议的可以在评论区提，我也在努力完善它。
码云git地址：http://git.oschina.net/bedbed/Euler/

最新版的代码在git上面，可能不会在这里更新。

素数类源码

package stone.math;

import java.util.ArrayList;
import java.util.Iterator;
import java.lang.Math;
import java.math.BigInteger;

/*
 * Copyright (C) 2014-2016  Stone Chen
 * All rights reserved by  Stone Chen
 *
 *  Modification History:
 *  Date        Author      Version     Description
 *  -----------------------------------------------
 *  2016年9月13日     Stone Chen   1.0         [实现基本功能]
 *  2016年9月28日      Stone Chen 1.1         [添加判断大数是否为质数函数，调用BigInteger提供的方法]
 *  2016年10月27日   Stone Chen 1.2         [由维护数组改为维护集合]
 *
 */

/**
 * [功能说明]素数工具类，工具类具有私有构造器，不允许创建实例，提供各种静态方法
 */
public final class Prime {

    /** [初始化时生成的sPrimeArray长度] */
    private static final int sInitPrimeListLength = 1000;
    /** [从2开始的素数集合] */
    private static ArrayList<Integer> sPrimeList = new ArrayList<Integer>(sInitPrimeListLength);

    /**
     * 类初始化代码块
     */
    static {
        getPrimeArrayByLength(sInitPrimeListLength);
    }

    /**
     * 工具类的私有构造器
     */
    private Prime() {

    }

    /**
     * [功能说明] 将primeList转换为int数组
     * 
     * @return int数组
     */
    public static int[] getPrimeArray() {
        int[] primeArray = new int[getPrimeListLength()];
        for (int i = 0; i < primeArray.length; i++) {
            primeArray[i] = sPrimeList.get(i);
        }
        return primeArray;
    }

    /**
     * [功能说明] 将primeList的索引start至end的元素转换为int数组返回
     * 
     * @param start
     *            如果start < 0，那么start会被置为0
     * @param end
     *            如果end < start，那么end会被置为start
     * @return 素数数组
     */
    public static int[] getPrimeArray(int start, int end) {
        if (start < 0) {
            start = 0;
        }
        if (end < start) {
            end = start;
        }
        int length = end - start + 1;
        int[] primeArray = new int[length];
        for (int i = 0; i < length; i++, start++) {
            primeArray[i] = sPrimeList.get(start);
        }
        return primeArray;
    }

    /**
     * [功能说明] 返回从2开始的长度为length的素数数组
     * 
     * @param length
     * @return
     */
    public static int[] getPrimeArray(int length) {
        if (length < 1) {
            length = 1;
        }
        return getPrimeArray(0, length - 1);
    }

    /**
     * [功能说明] 返回维护的素数集合的长度
     * 
     * @return
     */
    public static int getPrimeListLength() {
        return sPrimeList.size();
    }

    /**
     * [功能说明] 返回素数集合的最后一个元素
     * 
     * @return
     */
    public static int getMaxCheckedPrime() {
        int listLength = getPrimeListLength();
        if (listLength > 0) {
            return sPrimeList.get(getPrimeListLength() - 1);
        }
        return 1;
    }

    /**
     * [功能说明]判断一个数是否为素数
     * 
     * @param num
     *            待判断的整数
     * @return num是素数返回true,否则返回false
     */
    public static boolean isPrime(int num) {
        boolean flag = true;
        if (num < 2) {
            return false;
        }
        for (int i = 2; i * i <= num; i++) {
            if (num % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    /**
     * [功能说明]采用Miller-Rabin算法判断一个大整数是否为素数，可靠性为1-1/(2^certainty)
     * 
     * @param num
     *            待判断的整数
     * @return 是素数返回true
     */
    public static boolean isProbablePrime(String num, int certainty) {
        BigInteger bigNum = new BigInteger(num);
        return bigNum.isProbablePrime(certainty);
    }

    /**
     * [功能说明]利用sPrimeList快速判断是否为素数
     * 
     * @param num
     *            待判断的整数
     * @return 是否为素数
     */
    public static boolean isQuickPrime(int num) {
        if (num > getMaxCheckedPrime()) {
            boolean flag = true;
            int i = 0;
            for (; i < getPrimeListLength() && sPrimeList.get(i) <= Math.sqrt(num); i++) {
                if (num % sPrimeList.get(i) == 0) {
                    flag = false;
                    break;
                }
            }
            if (i == getPrimeListLength()) {
                for (int n = getMaxCheckedPrime(); n <= Math.sqrt(num); n++) {
                    if (num % n == 0) {
                        flag = false;
                        break;
                    }
                }
            }
            return flag;
        }

        if (getPrimeIndex(num) == -1) {
            return false;
        }

        return true;
    }

    /**
     * [功能说明]返回长度为length的素数数组
     * 
     * @param length
     *            返回的数组长度
     * @return int素数数组
     */
    public static int[] getPrimeArrayByLength(int length) {
        // length<1则返回空数组
        if (length < 1) {
            return new int[] {};
        }
        // 如果length小于等于素数集合的长度，则将素数集合前length个元素转换为int数组返回
        if (length <= getPrimeListLength()) {
            return getPrimeArray(length);
        }
        // length大于素数集合长度情况的处理
        int count = getPrimeListLength();
        for (int num = getMaxCheckedPrime() + 1; count < length; num++) {
            if (isPrime(num)) {
                sPrimeList.add(num);
                count++;
            }
        }
        return getPrimeArray(length);
    }

    /**
     * [功能说明]返回num以下的素数数组,不包括num
     * 
     * @param num
     *            请求的素数数组上限
     * @return 素数数组
     */
    public static int[] getPrimeArrayBelow(int num) {
        if (num < 2) {
            return new int[] {};
        }

        // 如果num <= MaxCheckedPrime，则返回sPrimeList的子集的数组
        if (num <= getMaxCheckedPrime()) {
            int index = getPrimeIndex(num, true);
            return getPrimeArray(index + 1);
        }
        // 将大于MaxCheckedPrime小于num的素数加入list
        for (int n = getMaxCheckedPrime() + 1; n < num; n++) {
            if (isPrime(n)) {
                sPrimeList.add(n);
            }
        }
        return getPrimeArray(getPrimeListLength());
    }

    /**
     * [功能说明]返回startNum与endNum之间的素数数组，包括边界
     * 
     * @param startNum
     *            起点
     * @param endNum
     *            终点
     * @return 素数数组
     */
    public static int[] getPrimeArrayBetween(int startNum, int endNum) {
        // startNum>=endNum，如果startNum是素数，则返回单元素数组，否则返回空数组
        if (startNum >= endNum) {
            if (isPrime(startNum)) {
                return new int[] { startNum };
            } else {
                return new int[] {};
            }
        }
        // startNum<endNum,startNum <= sPrimeList的最后一个元素
        if (startNum <= getMaxCheckedPrime()) {
            int start = getPrimeIndex(startNum, true);
            if (start == -1 || sPrimeList.get(start) != startNum) {
                start++;
            }
            if (endNum <= getMaxCheckedPrime()) {
                int end = getPrimeIndex(endNum, true);
                return getPrimeArray(start, end);
            } else {
                for (int num = getMaxCheckedPrime() + 1; num <= endNum; num++) {
                    if (isPrime(num)) {
                        sPrimeList.add(num);
                    }
                }
                return getPrimeArray(start, getPrimeListLength() - 1);
            }
        }
        // startNum<endNum,startNum > sPrimeList的最后一个元素
        ArrayList<Integer> al = new ArrayList<>();
        for (int num = startNum; num <= endNum; num++) {
            if (isPrime(num)) {
                al.add(num);
            }
        }
        int[] primeArray = new int[al.size()];
        Iterator<Integer> it = al.iterator();
        int i = 0;
        while (it.hasNext()) {
            primeArray[i++] = it.next();
        }
        return primeArray;
    }

    /**
     * [功能说明]返回num在sPrimeList的索引，如果不存在则返回-1,用二分法查找
     * 
     * @param num
     *            待查找的整数
     * @return index 索引
     */
    public static int getPrimeIndex(int num) {
        return getPrimeIndex(num, false);
    }

    /**
     * [功能说明]返回num在sPrimeList的索引，如果不存在则返回-1,用二分法查找
     * 
     * @param num
     * @param isStrict
     *            是否在找不到时返回小于num的第一个元素的索引
     * @return 索引
     */
    public static int getPrimeIndex(int num, boolean isStrict) {
        int start = 0;
        int end = getPrimeListLength() - 1;
        while (start <= end) {
            int middle = (start + end) / 2;
            if (num < sPrimeList.get(middle)) {
                end = middle - 1;
            } else if (num > sPrimeList.get(middle)) {
                start = middle + 1;
            } else {
                return middle;
            }
        }
        // 若集合中找不到，是否返回小于key的最大数的索引
        if (isStrict) {
            int result = start > end ? end : -1;
            return result;
        }
        return -1;
    }

    /**
     * [功能说明]用二分法在数组arr中查找key，找到返回索引，返回-1
     * 
     * @param arr
     *            待搜索的数组
     * @param key
     *            关键字
     * @return 索引值
     */
    public static int binarySearch(int[] arr, int key) {
        return binarySearch(arr, key, false);
    }

    /**
     * [功能说明]用二分法在数组arr中查找key，找到返回索引，否则根据isStrict标志返回
     * 
     * @param arr
     *            待搜索的数组
     * @param key
     *            关键字
     * @param isStrict
     *            是否要求在找不到key时返回小于key的最大值的索引
     * @return 索引值
     */
    public static int binarySearch(int[] arr, int key, boolean isStrict) {
        int start = 0;
        int end = arr.length - 1;
        while (start <= end) {
            int middle = (start + end) / 2;
            if (key < arr[middle]) {
                end = middle - 1;
            } else if (key > arr[middle]) {
                start = middle + 1;
            } else {
                return middle;
            }
        }
        // 若数组中找不到，是否返回小于key的最大数的索引
        if (isStrict) {
            int result = start > end ? end : -1;
            return result;
        }
        return -1;
    }

    /**
     * [功能说明] 返回a和b的最大公约数,如果a<=0或b<=0，则返回0
     * 
     * @param a
     *            正整数a
     * @param b
     *            正整数b
     * @return 最大公约数
     */
    public static int Gcd(int a, int b) {
        if (a <= 0 || b <= 0) {
            return 0;
        }
        int remainder = 0;
        while ((remainder = a % b) != 0) {
            a = b;
            b = remainder;
        }
        return b;
    }

    /**
     * [功能说明] 求数组内所有整数的最大公约数
     * 
     * @param numArray
     *            正整数数组
     * @return 最大公约数
     */
    public static int Gcd(int[] numArray) {
        int gcd = numArray[0];
        for (int i = 1; i < numArray.length; i++) {
            gcd = Gcd(gcd, numArray[i]);
        }
        return gcd;
    }

    /**
     * [功能说明] 求a,b的最小公倍数
     * 
     * @param a
     *            正整数a
     * @param b
     *            正整数b
     * @return 最小公倍数
     */
    public static int Lcm(int a, int b) {
        if (a <= 0 || b <= 0) {
            return 0;
        }
        int gcd = Gcd(a, b);
        return a / gcd * b;
    }

    /**
     * [功能说明] 求数组内所有整数的最小公倍数
     * 
     * @param numArray
     *            正整数数组
     * @return 最小公倍数
     */
    public static int Lcm(int[] numArray) {
        int lcm = numArray[0];
        for (int i = 1; i < numArray.length; i++) {
            lcm = Lcm(lcm, numArray[i]);
        }
        return lcm;
    }
}