Java中的程序素因子分解

素因子分解–让用户输入一个数字，找到所有素因子（如果有）并显示它们

我创建了一个方法来验证这些数字是否为素数，另一个方法来检查用户输入的数字是否可以除以素数

我不明白为什么程序不工作，for循环有什么问题（可以使用函数操作）。请帮帮我
我是初学者，如果你能给我一些建议来改进这段代码，我将不胜感激

import java.util.ArrayList;
import java.util.Scanner;


public class PrimeFactors {
    int count, input, num;
    Scanner sc = new Scanner(System.in);
    ArrayList<Integer> factors = new ArrayList();

    public static void main(String[] args) {
        PrimeFactors pfo = new PrimeFactors();
        pfo.primeFactor();


    }

    public void primeFactor(){
        input = sc.nextInt();
        for(num = input; num <= 1; num--){
            System.out.println(input);
            if(isPrime(num)){
                if (divide(num)) {
                    System.out.println("Adding a new int...");
                    factors.add(num);
                    num = input;
                }
            }
        }
        for(int element : factors){
            System.out.println(factors.get(element));
        }
    }

    public boolean isPrime(int number){
        for(int i = 2; i < number; i++){
            if(number % i == 0){
                count++;
            }
        }
        return (count == 0);
    }

    public boolean divide(int number){
        return (input % number == 0);
    } 

}

import java.util.ArrayList；
导入java.util.Scanner；
公共类因素{
int计数，输入，num；
扫描仪sc=新的扫描仪（System.in）；
ArrayList因子=新的ArrayList（）；
公共静态void main（字符串[]args）{
PrimeFactors pfo=新的PrimeFactors（）；
pfo.primeFactor（）；
}
公共空间系数（）{
输入=sc.nextInt（）；
例如（num=input；num你本应该使用实例变量的时候却在使用全局变量。还有一些其他的错误，如Johnny所指出的。我改变的最大一点是我让这个程序递归。尽量远离全局变量，这会让事情变得更加混乱（例如，primeFactor方法应该采用一个变量，而不是使用全局变量）

公共类元素{
整数计数；
静态int输入；
int-num；
静态扫描仪sc=新扫描仪（System.in）；
静态ArrayList因子=新ArrayList（）；
公共静态void main（字符串[]args）{
PrimeFactors pfo=新的PrimeFactors（）；
输入=sc.nextInt（）；
pfo.primeFactor（）；
for（int元素：因子）{
系统输出打印项次（元素）；
}
}
公共空间系数（）{
如果（输入>1）{
对于（int i=input；i>=1；i--）{
如果（i）{
如果（除以（i））{
System.out.println（“添加新的int…”）；
增加（i）；
输入=输入/i；
素数因子（）；
}
}
}
}
}
公共布尔iPrime（整数）{
整数计数=0；
for（int i=2；i

这是我对素数因子的解决方案。我省略了计算素数列表部分。流非常棒，我喜欢在解决project Euler问题时尝试使用它们

private static ArrayList<Integer> primeFactors(int number) {
        return primeFactors(new ArrayList<Integer>(), number);
    }

    private static ArrayList<Integer> primeFactors(ArrayList<Integer> primeFactors, int number) {
        if (number == 1) {
            return primeFactors;
        }

        int newPrime=primeDividor(number);
        primeFactors.add(newPrime);
        return primeFactors(primeFactors, number/newPrime);
    }

    private static int primeDividor(int input) {
        return primes.stream()
                     .filter(e -> input % e == 0)
                     .findFirst()
                     .orElse(input);
    }

private静态数组列表primeFactors（整数）{
返回primeFactors（新的ArrayList（），编号）；
}
专用静态ArrayList primeFactors（ArrayList primeFactors，整数）{
如果（数字==1）{
回报因素；
}
int newPrime=primeDividor（数字）；
primeFactors.add（newPrime）；
返回primeFactors（primeFactors，number/newPrime）；
}
专用静态int primeDividor（int输入）{
返回primes.stream（）
.filter（e->输入%e==0）
.findFirst（）
.orElse（输入）；
}
您的代码存在多个问题。首先，primeFactor中的循环永远不会对大于1的数字运行。您可以通过将for循环更改为
for来解决此问题（num=1；num我听取了你所有的建议，并使用Eratosthenes筛改进了我的程序，如果你能给我更多的建议，我将非常感激

    public class PrimeFactors {
    static int input;
    static Scanner sc = new Scanner(System.in);
    static ArrayList<Integer> factors = new ArrayList();

    public static void main(String[] args) {
        PrimeFactors pfo = new PrimeFactors();
        SieveOfEratosthenes sieveObj = new SieveOfEratosthenes();

        input = sc.nextInt();

        sieveObj.findAllPrimeFactors(input);
        pfo.divisiblePrimeFactors(sieveObj.allPrimeFactors);

        for(int element : factors){
            System.out.println(element);
        }
    }

    public void divisiblePrimeFactors(ArrayList<Integer> allPrimeFactors){    
        if(input > 1){

            for(int element : allPrimeFactors){
                if(isDivisible(element, input)){
                    factors.add(element);
                    input = input/element;
                    divisiblePrimeFactors(allPrimeFactors);
                }    
            }
        }    
    }

    public boolean isDivisible(int number, int divisor){
        return (divisor % number == 0);
    } 
}

public class SieveOfEratosthenes {

    ArrayList<Integer> allPrimeFactors= new ArrayList();

    public void findAllPrimeFactors(int limit){
        boolean[] isPrime = new boolean[limit];
        isPrime[0] = false;
        isPrime[1] = false;

        for(int i = 1; i < limit; i++){
            isPrime[i] = true;
        }

        for(int i = 2; i < limit; i++){
            if(isPrime[i]){
                allPrimeFactors.add(i);
            }
            for(int j = i*i; j < limit; j+=i){
                isPrime[j] = false;
            }
        }
    }
}

公共类元素{
静态int输入；
静态扫描仪sc=新扫描仪（System.in）；
静态ArrayList因子=新ArrayList（）；
公共静态void main（字符串[]args）{
PrimeFactors pfo=新的PrimeFactors（）；
SIVEOFERATOSTENS SIVEOBJ=新的SIVEOFERATOSTENS（）；
输入=sc.nextInt（）；
SIVEOBJ.FINDALLPRIMEFACTOR（输入）；
pfo.可分割的优先因子（SIVEOBJ.所有优先因子）；
for（int元素：因子）{
系统输出打印项次（元素）；
}
}
public void divisiblePrimeFactors（ArrayList allPrimeFactors）{
如果（输入>1）{
for（int元素：allPrimeFactors）{
if（可分（元素，输入））{
添加（元素）；
输入=输入/元素；
可分割的PrimeFactors（所有PrimeFactors）；
}    
}
}    
}
公共布尔可分（整数，整数除数）{
返回（除数%number==0）；
} 
}
公共级硅藻土{
ArrayList allPrimeFactors=新的ArrayList（）；
公共无效findAllPrimeFactors（整数限制）{
boolean[]isPrime=新的boolean[limit]；
isPrime[0]=假；
isPrime[1]=假；
对于（int i=1；i
公共类素数
{
int i；
公共素数（）
{
i=2；
}
公共布尔iPrime（整数测试）
{
int k；
如果（试验<2）
返回false；
否则如果（测试==2）
返回true；
否则如果（（测试>2）和（&（测试%2==0））
返回false；
其他的
{
对于（k=3；k<（测试/2）；k+=2）
{
如果（测试%k==0）
返回false；
}
}
返回true；
}
公共因子（整数因子化）
{
if（isPrime（factorize））
{
系统输出打印项次（因子分解）；
i=2；
}
其他的
{
如果(i),(
import java.util.ArrayList;
import java.util.Scanner;


public class PrimeFactors {
    int count, input, num;
Scanner sc = new Scanner(System.in);
ArrayList<Integer> factors = new ArrayList();

public static void main(String[] args) {
    PrimeFactors pfo = new PrimeFactors();
    pfo.primeFactor();
}

public void primeFactor(){
    input = sc.nextInt();
    for(num = 1; num <= input; num++){
        if(isPrime(num)){
            if (divide(num)) {
                System.out.println("Adding a new int...");
                factors.add(num);
            }
        }
    }
    for(int element : factors){
        System.out.println(element);
    }
}

public boolean isPrime(int number){
    int count = 0;

    for(int i = 2; i < number; i++){
        if(number % i == 0){
            count++;
        }
    }
    return (count == 0);
}

public boolean divide(int number){
    return (input % number == 0);
} 
}

    public class PrimeFactors {
    static int input;
    static Scanner sc = new Scanner(System.in);
    static ArrayList<Integer> factors = new ArrayList();

    public static void main(String[] args) {
        PrimeFactors pfo = new PrimeFactors();
        SieveOfEratosthenes sieveObj = new SieveOfEratosthenes();

        input = sc.nextInt();

        sieveObj.findAllPrimeFactors(input);
        pfo.divisiblePrimeFactors(sieveObj.allPrimeFactors);

        for(int element : factors){
            System.out.println(element);
        }
    }

    public void divisiblePrimeFactors(ArrayList<Integer> allPrimeFactors){    
        if(input > 1){

            for(int element : allPrimeFactors){
                if(isDivisible(element, input)){
                    factors.add(element);
                    input = input/element;
                    divisiblePrimeFactors(allPrimeFactors);
                }    
            }
        }    
    }

    public boolean isDivisible(int number, int divisor){
        return (divisor % number == 0);
    } 
}

public class SieveOfEratosthenes {

    ArrayList<Integer> allPrimeFactors= new ArrayList();

    public void findAllPrimeFactors(int limit){
        boolean[] isPrime = new boolean[limit];
        isPrime[0] = false;
        isPrime[1] = false;

        for(int i = 1; i < limit; i++){
            isPrime[i] = true;
        }

        for(int i = 2; i < limit; i++){
            if(isPrime[i]){
                allPrimeFactors.add(i);
            }
            for(int j = i*i; j < limit; j+=i){
                isPrime[j] = false;
            }
        }
    }
}

public class Prime
{
   int i;

   public Prime( )
   {
      i = 2;
   }

   public boolean isPrime( int test ) 
   {
      int k;

      if( test < 2 )
        return false;
    else if( test == 2 )  
        return true;
    else if( ( test > 2 ) && ( test % 2 == 0 ) )
        return false;
    else
    {
        for( k = 3; k < ( test/2 ); k += 2 )
        {
            if( test % k == 0 ) 
                return false;
        }

    }

      return true;

   }

   public void primeFactors( int factorize )
   {
      if( isPrime( factorize ) )
      {
         System.out.println( factorize );
         i = 2;
      }
      else
      {
         if( isPrime( i ) && ( factorize % i == 0 ) )
         {
            System.out.print( i+", " );
            primeFactors( factorize / i );
         }
         else
         {
            i++;
            primeFactors( factorize );
         }
     }

   }   

   public static void main( String[] args )
   {
      Prime p = new Prime( );

      p.primeFactors( 1001 );
      p.primeFactors( 649 );
      p.primeFactors( 144 );

   }

}//end Prime.java