Java 元素转到列表的末尾

所以，伙计们。我对Java（以及其他编程语言）非常陌生，在处理列表时遇到了一些问题。我写这段代码是为了集成一个函数，考虑到优缺点和速度。尽管如此，我注意到对于与1不同的配速，列表（list_x）会变得混乱，并且一个值会一直到它的末尾。 下面是完整的代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Integrate {
    static List<Double> fillx(double ini,double end, double pace) { //Fills the x column
        List<Double> list_x = new ArrayList<Double>();
        for(double i = ini; i <= (end+0.1*pace); i += pace) {
           int i2 = (int) ((i-ini)/pace);
           list_x.add(i2, i);
        }
        System.out.println(list_x);
        return list_x;
    }
    static List<List<Double>> filly(List<Double> listx){ //Fills the y column
        List<List<Double>> listxy= new ArrayList<List<Double>>();
        for(int i = 0; i < listx.size();i++) {
            List<Double> pair = new ArrayList<Double>();
            pair.add(0,listx.get(i));
            pair.add(1,function(listx.get(i)));
            listxy.add(i,pair);
            System.out.println(pair);
        }
        return listxy;
    }
    static double function(double x) { //Defines the function to be integrated
    return x;
    }
    static double integrate(List<List<Double>> listxy) { //Integrates following trapezoidal forms
        double area = 0;
        for(int i=0; (i+1) < listxy.size();i++) {
           area += 0.5*(listxy.get(i+1).get(0)-listxy.get(i).get(0))*      (listxy.get(i+1).get(1)+listxy.get(i).get(1));
           System.out.println(listxy.get(i+1).get(0)+" "+listxy.get(i).get(0)+" "+listxy.get(i+1).get(1)+" "+listxy.get(i).get(1));
        }
        return area;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double ini = scan.nextDouble(); //Reads the inferior limit
        double end = scan.nextDouble(); //Reads the superior limit
        double pace = scan.nextDouble(); //Reads the pace (partial to be summed).
        if (((end-ini) % pace) < pace) {
        System.out.println(integrate(filly(fillx(ini,end,pace))));}
        else
            System.out.println("Must review pace");
   }
}

---

如果你还有其他意见，我将非常高兴。由于我在自学，欢迎提供所有帮助。

当您构建列表时，会发生以下情况：

adding 0.0 at index 0    [0.0]
...
adding 0.5 at index 5    [0,0, 0.1,... 0.5]
adding 0.6 at index 5     Bang: [0,0, 0.1,... 0.6, 0.5]
adding 0.7 at index 6    [0,0, 0.1,... 0.6, 0.7, 0.5]

您可以看到这是如何将0.5推向终点的

你正在做所谓的“过度工程”：害怕做得不够，你就做得太多了

// The List is perfectly capable of appending at the end, which is exactly what you want:
for(double i = ini; i <= (end+0.1*pace); i += pace) {
    list_x.add(i);
}

这样的计算是有风险的。除法可能会产生一个等于或略高于整数的值，然后转换为int将截断并生成您所期望的值。然而，它可能会返回一个略低于0.x99999999999的双精度值，然后截断结果会比您预期的少一个

int i2 = (int)Math.round((i-ini)/pace);

脚注2计算一系列双倍

直接计算，而不是将一个double重复添加到另一个double。（我还添加了ini，以获得正确的横坐标值。）

---

您正在添加许多具有特定索引的内容。我希望您知道，这将使索引较大的元素向右移动一个“位置”。我很确定这是真的：

if（（（end ini）%pace）

@Bohemian:Let

end=-3，ini=0，pace=-2

。然后

（（结束ini）%pace）==-1

，大于-2。不确定这是否与这个问题有关，这是一个可疑的表达式，但最好记住，

%

不是数学模。

int i2 = (int) ((i-ini)/pace);

int i2 = (int)Math.round((i-ini)/pace);

int n = (int)Math.round((end - ini)/pace) + 1;
    for(int i = 0; i < n; ++i) {
    list_x.add(ini + i*pace);
}

public class Point {
    private double x;
    private double y;
    Point( double x, double y ){
        this.x = x;
        this.y = y;
    }
    public double getX(){
        return x;
    }
    public double getY(){
        return y;
    }
    public String toString(){
        return "<" + x + "," + y + ">";
    }
}

static List<Point> fillp(List<Double> listx){
    List<Point> listp = new ArrayList<>();
    for(int i = 0; i < listx.size(); i++) {
    Point p = new Point( listx.get(i), function(listx.get(i)) );
        listp.add( p );
    }
    return listp;
}

public class Trapez {
    static double function(double x) { //Defines the function to be integrated
        return x;
    }

    static double trapezoidalRule( double a, double b, double h ){
        int n = (int)Math.round((b - a)/h) + 1;
        double area = 0;
        double y = function( a );
        for( int i = 1; i < n; i++ ){
            double y1 = function( a + h*i );
            area += 0.5*h*(y + y1);
            y = y1;
        }
        return area;
    }

    public static void main(String[] args) {
        System.out.println( trapezoidalRule( 0, 1, 0.1 ) );
    }
}

import java.util.function.Function;
public class Trapez {
    static double trapezoidalRule( Function<Double,Double> f, double a, double b, double h ){
        int n = (int)Math.round((b - a)/h) + 1;
        double area = 0;
        double y = f.apply( a );
        for( int i = 1; i < n; i++ ){
            double y1 = f.apply( a + h*i );
            area += 0.5*h*(y + y1);
            y = y1;
        }
        return area;
    }
    public static void main(String[] args) {
        System.out.println( trapezoidalRule( x -> 2*x, 0, 1, 0.1 ) );
    }
}