一个重构的简单例子

import java.util.*;
//重构前:根据所给出的数字n,返回1-n之间的所有质数.
class GeneratorPrimes 
{
	public static void main(String[] args) 
	{
		long start = System.currentTimeMillis();
		int[] a = PrimeGenerator.generate(10000000);
		long end = System.currentTimeMillis();
		//System.out.println(Arrays.toString(a));
		System.out.println(end - start);
	}
	public static int[] generate(int maxValue) {
	    if (maxValue >= 2)
	    {
			int s = maxValue + 1;
			boolean[] f = new boolean[s];
			int i;
			for (i =0; i < s; i++)
			{
				f[i] = true;
			}
			f[0] = false; 
			f[1] = false;
			int j;
			for (i = 2; i < Math.sqrt(s) + 1; i++)
			{
				//此处对标识为true的元素不再进行标记.
				if (f[i])
				{
				   for (j = 2 * i; j < s; j += i)
				   {
					   f[j] = false;
				   }
				}
				
			}
			int count = 0;
			for (i = 0; i < s; i++)
			{
				if (f[i])
				{
					count++;
				}
			}
			int[] primes = new int[count];
			for (i = 0, j = 0; i < s; i++)
			{
				if (f[i])
				{
					primes[j++] = i;
				}
			}

            return primes;
	    } else {
		   return new int[0];
		}
	}
}


/*
*重构后:根据所给出的数字n,返回1-n之间的所有质数.
*
*步骤:通过一个长度为这个数的boolean数组标识出这个数字之间的所有数字.
*     1-n之间的数字进行过滤,凡是能够分解质因数n*(2..n)都标记为true,表示已被过滤掉.
*     重复执行此步骤,至到上限值.
*/
class PrimeGenerator
{
	
	private static boolean[] isCrossed;
	private static int[] result;
	public static int[] generate(int maxValue) {
	   if (maxValue < 2)
	   {
		   return new int[0];
	   } else {
	      initializeSieve(maxValue);
		  sieve();
		  loadPrimes();
		  return result;
	   }
	}
	private static void sieve() {
		
		
		int limit = determineIterationLimit();
		for (int i = 2; i <= limit; i++)
		{
			//如果已标识为过滤掉的数字则不再进行标记.
			//因为对于n*(2..n),如果有n=x*y,则n*(2..n)=x*y*(2..n),已被完整标记过,n序列是x序列的一个子集.
			if (notCrossed(i))
			{
				crossOutMultiplesOf(i);
			}
		}
	}
	//过滤掉的所有数字,标记为true. 
	private static void crossOutMultiplesOf(int i) {
	   for (int multiple = 2 * i; multiple < isCrossed.length; multiple += i)
	   {
           isCrossed[multiple] = true;
	   }
	}
	//判断当前位置(i)数字是否被过滤掉.
	//已过滤掉返回true
	//未过滤掉返回false
    private static boolean notCrossed(int i) {
	    return isCrossed[i] == false;
	}
	//上限值.上限值是小于或等于一个数的开方根的最大素数，e.x : 100  上限值为 7.
	private static int determineIterationLimit() {
	   double iterationLimit = Math.sqrt(isCrossed.length);
	  
	   return (int)iterationLimit;
	}
	//根据boolean数组中的标记,填充结果质数数组.
	private static void loadPrimes() {
		 result = new int[numberOfUncrossedIntegers()];
		 for (int j = 0, i = 2; i < isCrossed.length; i++)
		 {
			 if (notCrossed(i))
			 {
				 result[j++] = i;
			 }
		 }
	}
	//返回所有质数的个数
	private static int numberOfUncrossedIntegers() {
	   int count = 0;
	   for (int i = 2; i < isCrossed.length; i++)
	   {
		   if (notCrossed(i))
		   {
			   count++;
		   }
	   }
	   return count;
	}
	private static void initializeSieve(int maxValue) {
	    //初始化boolean数组,默认值为false,表数字没有被过滤掉.
		//0,1不会被访问到.
		isCrossed = new boolean[maxValue + 1];
	  	for (int i = 2; i < isCrossed.length; i++)
		{
			isCrossed[i] = false;
		}
		
	}
	
}