Java 找不到范围内的不同素数因子的数目

顽皮数是指其不同素数因子的数量等于其十进制表示中的位数的数数字1被认为是一个顽皮的数字。下面是查找淘气号码的代码。问题是方法的主要因素，它进入了一个无休止的循环

import java.util.ArrayList;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.Iterator; 

public class NaughtyNumber {
    ArrayList < Integer > aldecrep = new ArrayList < > (); // use for decimal representation
    TreeSet < Integer > tsprimefact = new TreeSet < > (); // use for store of prime factors       
    ArrayList < Integer > alsize1 = new ArrayList < > (); // use for storing  number of prime factors
    public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            int query, ul, dl;
            System.out.println("Enter the nuber of queries");
            query = in .nextInt();
            System.out.println("Enter upperlimit and down limit");
            while (query != 0) {
                dl = in .nextInt();
                ul = in .nextInt();
                NaughtyNumber n1 = new NaughtyNumber();
                //NaughtyNumber n2=new NaughtyNumber();
                //NaughtyNumber n3=new NaughtyNumber();
                n1.decal(dl, ul);
                n1.primefactor(dl, ul);
                n1.compare(dl);
                query--;
            }
        }
        //count number of digits        
    void decal(int dl, int ul) {
            for (int i = dl; i <= ul; i++) {
                int length = (int)(Math.log10(i) + 1); //calculation of length of a     number
                aldecrep.add(length);
            }
        }
        //count number of digits ends
        //prime factorization starts
    void primefactor(int dl, int ul) {
            for (int i = dl; i <= ul; i++) {
                for (int j = 2; j <= i; j++) {
                    if (i % j == 0) {
                        i = i / j;
                        tsprimefact.add(j); // add distinct prime factors
                        j--;
                    }

                    alsize1.add(tsprimefact.size()); //add treesize to set size1
                    tsprimefact.clear(); //empty ts

                }
            }
            Iterator < Integer > itr1 = alsize1.iterator();
            while (itr1.hasNext()) {
                Integer n1 = itr1.next();
                System.out.println(n1);
            }
        }
        //prime factorization ends      
        // compare to find naughty number
    void compare(int dl) {
        Iterator < Integer > itr = aldecrep.iterator();
        Iterator < Integer > itr1 = alsize1.iterator();
        int count = 0;
        if (dl == 1) {
            count = count + 1;
        }
        while (itr.hasNext() && itr1.hasNext()) {
            Integer n1 = itr.next();
            Integer n2 = itr1.next();
            if (n1 == n2) {
                count++;
            }
        }
        System.out.println(count);
    }
}

import java.util.ArrayList；
导入java.util.Scanner；
导入java.util.TreeSet；
导入java.util.Iterator；
公共类顽皮数{
ArrayListaldecrep=new ArrayList<>（）；//用于十进制表示
TreeSettsprimefact=newtreeset<>（）；//用于存储素数因子
ArrayListalsize1=new ArrayList<>（）；//用于存储素数因子的数量
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int查询，ul，dl；
System.out.println（“输入查询数量”）；
query=in.nextInt（）；
System.out.println（“输入上限和下限”）；
while（查询！=0）{
dl=in.nextInt（）；
ul=in.nextInt（）；
NOTTYNUMBER n1=新的NOTTYNUMBER（）；
//NOTTYNUMBER n2=新的NOTTYNUMBER（）；
//NOTTYNUMBER n3=新的NOTTYNUMBER（）；
n1.贴花（dl、ul）；
n1.基本因子（dl，ul）；
n1.比较（dl）；
查询--；
}
}
//计数位数
空心贴花（内部dl、内部ul）{
for（int i=dl；i itr1=alsize1.iterator（）；
整数计数=0；
如果（dl==1）{
计数=计数+1；
}
while（itr.hasNext（）&&itr1.hasNext（））{
整数n1=itr.next（）；
整数n2=itr1.next（）；
如果（n1==n2）{
计数++；
}
}
系统输出打印项次（计数）；
}
}

使用如下分解：

public static Set<Integer> primeFactors(int numbers) {
    int n = numbers;
    Set<Integer> factors = new HashSet<Integer>();
    for (int i = 2; i <= n / i; i++) {
      while (n % i == 0) {
        factors.add(i);
        n /= i;
      }
    }
    if (n > 1) {
      factors.add(n);
    }
    return factors;
  }

公共静态集素数因子（整数）{
int n=数字；
Set factors=新的HashSet（）；
对于（int i=2；i 1）{
因子。添加（n）；
}
回报因素；
}

我修改了源代码

---

Set以类似于的方式减少元素。

你能解决这个问题吗？如果我想找到一个素数阶乘，它就可以工作。但当我试图将它放入范围时，它就进入infinte循环。所以我修改了代码where而不是passing（dl，ul）我开始将单个值传递给primefactor方法，虽然我想知道为什么在传递（dl，ul）参数时它会进入无限循环。