指针和if语句错误，在Java中转换时在C代码中

我正在尝试将一个C代码转换成java，它是Newton Raphson算法的实现。一切进展顺利，但C代码中使用的指针存在问题，我已经在java中删除了它们。C代码部分是：

 x = newton(x_0, error, max_iters, &iters, &converged); //Call to a function (newton)

   if (converged) {

printf("Newton algorithm converged after %d steps.\n", iters);

    printf("The approximate solution is %19.16e\n", x);
    printf("f(%19.16e) = %19.16e\n", x, f(x));
   } else 
{

printf("Newton algorithm didn't converge after %d steps.\n", 
          iters);

    printf("The final estimate was %19.16e\n", x);
    printf("f(%19.16e) = %19.16e\n", x, f(x));
  }

函数定义如下：

double newton(double x_0, double error, int max_iters, 
          int* iters_p, int* converged_p)

现在的问题是，两个指针变量的值每次都是零。此外，if（聚合）显示一条不可兼容类型的错误消息。必需的布尔值，find int。下面是java代码，请帮助解决此问题。

 //Member Functions///////
 public
            double function( double x) 
            { 
                return x*x - 2;
            }

            double F_Deriv( double x ) 
            {
                return 2.0*x; 
            }


            double newton(double x_0, double error, int max_iters,int iters, int converged) 
            {
   double x = x_0;
   double x_prev;
   int    iter = 0;

   do {
      iter++;
      x_prev = x;
      x = x_prev - function(x_prev)/F_Deriv(x_prev);
   } 
   while (Math.abs(x - x_prev) > error && iter < max_iters);

   if (Math.abs(x - x_prev) <= error)
      converged = 1;
   else
      converged = 0;
   iters = iter;

   return x;
} 


/////Main Function///////
    public static void main(String[] args) {

        Newton_Raphson obj=new Newton_Raphson();

        Scanner input=new Scanner(System.in);


        double x_0;       /* Initial guess                */
        double x;         /* Approximate solution         */
        double error;       /* Maximum error                */
        int    max_iters; /* Maximum number of iterations */
        int    iters;     /* Actual number of iterations  */
        int    converged; /* Whether iteration converged  */

        System.out.println( "Enter Initial Solution: " );
        x_0=input.nextDouble();

        System.out.println( "Enter Error: " );
        error=input.nextDouble();


        System.out.println( "Enter Maximum Iterations: " );
        max_iters=input.nextInt();

        x = obj.newton(x_0, error, max_iters, iters, converged);

        if(converged) 
        {
            System.out.println("Newton algorithm converged after "+ iters +" steps.");
            System.out.println("The approximate solution is "+ x);

        } 

        else 
        {
            System.out.println("Newton algorithm didn't converge after " + iters + " steps.");
            System.out.println("The final estimate was " + x);

        }

    }

//成员函数///////
公众的
双功能（双x）
{ 
返回x*x-2；
}
双F_Deriv（双x）
{
返回2.0*x；
}
双牛顿（双x_0，双误差，int max_iters，int iters，int收敛）
{
双x=x_0；
双x_-prev；
int-iter=0；
做{
iter++；
x_prev=x；
x=x_prev-函数（x_prev）/F_Deriv（x_prev）；
} 
while（Math.abs（x-x_prev）>error&iter如果（Math.abs（x-x_prev）一个问题是这个语句：

if (Math.abs(x - x_prev) <= error)
   converged = 1;
else
   converged = 0;

将NewtonResult定义为：

public class NewtonResult {
    int x;
    int iters;
    boolean converged;
    NewtonResult (int x, int iters, boolean converged) {
        this.x = x;
        this.iters = iters;
        this.converged = converged;
    }
}

代码中的另一个问题是，当传递int时，Java
if
需要一个布尔值，因此需要将条件更改为：

if (converged != 0) {
    //
}

或者更好地将converged设置为布尔值。
一个问题是以下语句：

if (Math.abs(x - x_prev) <= error)
   converged = 1;
else
   converged = 0;

将NewtonResult定义为：

public class NewtonResult {
    int x;
    int iters;
    boolean converged;
    NewtonResult (int x, int iters, boolean converged) {
        this.x = x;
        this.iters = iters;
        this.converged = converged;
    }
}

代码中的另一个问题是，当传递int时，Java
if
需要一个布尔值，因此需要将条件更改为：

if (converged != 0) {
    //
}

或者最好将converged设置为布尔值。
Java按值传递参数，因此

if (Math.abs(x - x_prev) <= error)
    converged = 1;
else
    converged = 0;
iters = iter;

并设置（和查询）
iters[0]
resp.
converged[0]
Java按值传递参数，因此

if (Math.abs(x - x_prev) <= error)
    converged = 1;
else
    converged = 0;
iters = iter;

并设置（和查询）
iters[0]
resp.
converged[0]
类声明丢失（公共类Newton\u Raphson…）

如上所述，Java不支持通过引用传递参数，只支持通过值传递参数，因此您需要将所有这些参数封装在一个“Result”类中

并将方法的返回类型更改为该结果类

public class Result {
     public int x;
     public int iters;
     public int converged; // better replace this with a boolean in Java
}

不能将int作为布尔值进行测试。您应该测试它与0不同（因为在C中，所有不同的0都被认为是真的）。或者考虑直接使用布尔值，这要容易得多。
 < P>类声明丢失（公共类NeNtHeN-RAPHSON…）。< /P>
如上所述，Java不支持通过引用传递参数，只支持通过值传递参数，因此您需要将所有这些参数封装在一个“Result”类中

并将方法的返回类型更改为该结果类

public class Result {
     public int x;
     public int iters;
     public int converged; // better replace this with a boolean in Java
}

不能将int作为布尔值进行测试。应该测试它是否与0不同（因为在C中，与0不同的所有内容都被视为true）或者直接考虑使用布尔值，这是非常容易的。
 < P> >问题是：收敛的和 ITS/<代码>是从原来的C代码返回的。使用这些参数的指针是可以模拟<代码> Out[语义]的。因为java只支持传递值，所以不能返回该信息。以同样的方式使用普通方法参数

另一个问题是旧版本的C没有布尔类型，因此使用了
int
。在Java中，表示收敛的标志应该是
boolean

因此，您的代码需要返回三条信息：结果（一个浮点值）、
聚合的
（一个布尔值）和
iters
（一个整数）。您应该将它们包装成一个对象，并以这种方式返回它们

您需要的类如下所示：

public class NewtonResult {
     public boolean converged;
     public double value;
     public int iters;
}

您应该将
newton
方法签名更改为：

NewtonResult newton(double x_0, double error, int max_iters) 

最后，我认为对于该参数而言，
tolerance
比
error
更好。
问题是
聚合的
和
iter
是从原始C代码返回的。对这些参数使用指针是为了使参数能够模仿
出的
语义ly支持传递值，但不能使用普通方法参数以相同的方式返回该信息

另一个问题是旧版本的C没有布尔类型，因此使用了
int
。在Java中，表示收敛的标志应该是
boolean

因此，您的代码需要返回三条信息：结果（一个浮点值）、
聚合的
（一个布尔值）和
iters
（一个整数）。您应该将它们包装成一个对象，并以这种方式返回它们

您需要的类如下所示：

public class NewtonResult {
     public boolean converged;
     public double value;
     public int iters;
}

您应该将
newton
方法签名更改为：

NewtonResult newton(double x_0, double error, int max_iters) 

最后，我认为对于该参数，
公差
将是比
错误
好得多的名称。
当将java中的
int
，
布尔
-等前置类型作为方法参数传递并更改它们时，实际上它们不会更改。

传递的参数是真实参数的副本（它们实际上是通过值传递的）。

从变量表中初始化对象，然后将其传递给方法，如下所示：

Integer[] a = new Integer[1];  // For int a
Boolean[] b = new Boolean[1];  // For boolean b
a[0] = 1;
b[0] = true;

通过这种方式，将传递所传递对象的引用副本，并且当您更改其某个元素的值时，如
[0]
在上面，它也将在实变量中更改。
当将java中的前置类型（如
int
，
boolean
）作为方法参数传递并更改它们时，实际上它们不会更改。

传递的参数是真实参数的副本（它们实际上是通过值传递的）。

从变量中初始化对象，然后将它们传递给metho