Java实现1.0 = 1 / 1 * 1.5 = (1 + 2) / 2 * 2.0 = (1 + 2 + 3) / 3 * 2.5 = (1 + 2 + 3 + 4) / 4

可以使用一个循环来实现这个计算过程，每次将新的数加入分子中，分母加一，然后计算当前结果并输出。

代码如下：

double result = 1.0; // 初始化结果为 1.0
int denominator = 1; // 初始化分母为 1

for (int i = 2; i <= 4; i++) {
    // 将新的数加入分子中
    result *= i;

    // 分母加一
    denominator++;

    // 计算当前结果并输出
    double currentResult = result / denominator;
    System.out.println(currentResult);
}

输出结果为：

0.5
1.0
2.5

相关问题

Java实现1.0 = 1 / 1 1.5 = (1 + 2) / 2 2.0 = (1 + 2 + 3) / 3 2.5 = (1 + 2 + 3 + 4) / 4

public class Fraction {
private int numerator;
private int denominator;

public Fraction(int numerator, int denominator) {
this.numerator = numerator;
this.denominator = denominator;
}

public static Fraction fromDouble(double value) {
int denominator = 1;
while (value != (int) value) {
value *= 10;
denominator *= 10;
}
int numerator = (int) value;
return new Fraction(numerator, denominator);
}

public Fraction add(Fraction other) {
int lcm = MathUtils.lcm(this.denominator, other.denominator);
int numerator1 = this.numerator * (lcm / this.denominator);
int numerator2 = other.numerator * (lcm / other.denominator);
int numerator = numerator1 + numerator2;
return new Fraction(numerator, lcm);
}

public Fraction divide(int divisor) {
return new Fraction(this.numerator, this.denominator * divisor);
}

public double toDouble() {
return (double) numerator / denominator;
}

public String toString() {
return numerator + "/" + denominator;
}
}

public class MathUtils {
public static int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}

public static int lcm(int a, int b) {
return (a * b) / gcd(a, b);
}
}

public class Main {
public static void main(String[] args) {
Fraction fraction1 = new Fraction(1, 1);
Fraction fraction2 = new Fraction(2, 2);
Fraction fraction3 = new Fraction(3, 3);
Fraction fraction4 = new Fraction(4, 4);

Fraction result1 = fraction1.divide(1);
Fraction result2 = fraction2.divide(2);
Fraction result3 = fraction3.divide(3);
Fraction result4 = fraction4.divide(4);

Fraction sum = result1.add(result2).add(result3).add(result4);

System.out.println(sum); // 输出 10/4
System.out.println(sum.toDouble()); // 输出 2.5
}
}

public static void main(String[] args) { double[] arr = new double[]{0.1, 0.4, 0.6, 0.8, 1.0, 1.2, 1.5, 1.8, 2.0, 2.5, 5.0, 10.0}; //创建一个r的数组 BufferedImage image1; //创建一个BufferedImage类的对象image2 for (int i = 0; i < arr.length; i++) { try { image1 = ImageIO.read(new FileInputStream("D:/photo/p.jpg")); //读取本地照片 } catch (IOException e) { throw new RuntimeException(e); } BufferedImage Image2 = colorTransform(image1, arr[i]); //调用方法，并将方法的返回值赋予给对象newImage File newFile = new File(String.format("lisan%.1f.jpg", arr[i])); //创建存放图片的文件对象 try { ImageIO.write(Image2, "jpg", newFile); //写入文件,保存图片 } catch (IOException e) { throw new RuntimeException(e); } } } }

这段 Java 代码是一个主函数，它调用了之前实现的颜色变换函数colorTransform，并将不同的 gamma 值应用于同一张图片，生成多张不同颜色的图片。具体实现过程如下：

1. 创建一个 double 类型的数组，用于存储不同的 gamma 值。

2. 通过循环遍历数组中的每个 gamma 值，从本地磁盘读取一张图片。

3. 调用之前实现的颜色变换函数colorTransform，并传入该图片和当前的 gamma 值。

4. 将返回的变换后的图片对象保存到一个新的文件中，文件名为 "lisan%.1f.jpg"，其中 %.1f 表示将 gamma 值格式化为一位小数的字符串。

5. 循环结束后，多张不同颜色的图片将保存到本地磁盘中。

这个主函数可以用于批量生成不同颜色的图片，比如用于实验或者图像处理中的测试。