用java写一段计算圆周率的代码

以下是使用蒙特卡罗方法计算圆周率的Java代码：

import java.util.Random;

public class PiCalculator {
    public static void main(String[] args) {
        int totalPoints = 1000000;
        int insideCircle = 0;

        Random rand = new Random();
        for (int i = 0; i < totalPoints; i++) {
            double x = rand.nextDouble();
            double y = rand.nextDouble();
            if (x * x + y * y <= 1) {
                insideCircle++;
            }
        }

        double pi = 4.0 * insideCircle / totalPoints;
        System.out.println("Approximation of pi: " + pi);
    }
}

该代码生成了100万个随机点，计算在单位圆内的点数，然后使用公式π ≈ 4 * (在圆内的点数) / (总点数)估算圆周率。

相关问题

用Java写求圆的面积的视图代码

### 回答1：
以下是用Java写的求圆的面积的视图代码示例：

import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class CircleView extends JFrame {
    private static final long serialVersionUID = 1L;
    private JLabel radiusLabel;
    private JTextField radiusField;
    private JLabel areaLabel;
    private JTextField areaField;

    public CircleView() {
        setTitle("Circle Area Calculator");
        setLayout(new FlowLayout());
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        radiusLabel = new JLabel("Radius:");
        radiusField = new JTextField(10);
        areaLabel = new JLabel("Area:");
        areaField = new JTextField(10);
        areaField.setEditable(false);

        add(radiusLabel);
        add(radiusField);
        add(areaLabel);
        add(areaField);

        pack();
        setLocationRelativeTo(null);
        setVisible(true);
    }

    public double getRadius() {
        return Double.parseDouble(radiusField.getText());
    }

    public void setArea(double area) {
        areaField.setText(String.format("%.2f", area));
    }
}

这个视图包含一个输入半径的文本框和一个显示面积的文本框。用户可以在半径文本框中输入半径的值，然后单击计算按钮。在控制器中，我们将获取文本框中的半径值，通过半径值计算圆的面积，并将结果设置到结果文本框中。

### 回答2：
以下是一个使用Java编写的求解圆的面积的视图代码：

import java.util.Scanner;

public class CircleArea {
    public static void main(String[] args) {
        double radius, area;
        final double PI = 3.14159;

        Scanner input = new Scanner(System.in);

        // 获取用户输入的半径值
        System.out.print("请输入圆的半径：");
        radius = input.nextDouble();

        // 计算圆的面积
        area = PI * radius * radius;

        // 显示计算结果
        System.out.println("圆的面积为：" + area);
    }
}

这段代码首先导入了`java.util.Scanner`用于读取用户输入。然后定义了一个常量`PI`来存储圆周率的值。接下来创建了一个`Scanner`对象，用于从控制台读取用户输入。

获取用户输入的半径后，通过圆的面积公式`area = PI * radius * radius`计算出圆的面积。

最后，使用`System.out.println`将计算得到的面积输出到控制台。

请注意，这只是一个视图代码，只负责获取用户输入和显示结果。在实际应用中，可能还需要考虑输入的合法性检查和其他逻辑。

### 回答3：
下面是用Java编写的求圆的面积的视图代码：

import java.util.Scanner;

public class CircleAreaView {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入圆的半径：");
        double radius = scanner.nextDouble();
        
        double area = Math.PI * Math.pow(radius, 2);
        
        System.out.println("圆的面积为：" + area);
    }
}

在这个代码中，首先导入了`java.util.Scanner`类，以便能够读取用户的输入。然后使用`Scanner`类来提示用户输入圆的半径。接着使用`nextDouble()`方法读取用户输入的半径值，并将其保存到`radius`变量中。

接下来，使用面积公式`Math.PI * Math.pow(radius, 2)`计算圆的面积，并将结果保存到`area`变量中。其中，`Math.PI`表示圆周率π，`Math.pow()`方法用于计算半径的平方。

最后，使用`System.out.println()`方法打印出圆的面积。

请给出hadoop自带计算圆周率的代码及注释

下面是 Hadoop 自带的计算圆周率的示例代码及注释：

package org.apache.hadoop.examples;

import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Iterator;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;

public class PiEstimator {

  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    JobConf job = new JobConf(conf, PiEstimator.class);
    job.setJobName("pi");

    job.setOutputKeyClass(NullWritable.class);
    job.setOutputValueClass(NullWritable.class);

    job.setMapperClass(Map.class);
    job.setReducerClass(Reduce.class);

    job.setInputFormat(TextInputFormat.class);
    job.setOutputFormat(TextOutputFormat.class);

    FileInputFormat.setInputPaths(job, new Path(args[0]));
    FileOutputFormat.setOutputPath(job, new Path(args[1]));

    JobClient.runJob(job);
  }

  public static class Map extends MapReduceBase
      implements Mapper<Object, Text, NullWritable, NullWritable> {

    private long numRecords = 0;

    public void map(Object key, Text value,
        OutputCollector<NullWritable, NullWritable> output, Reporter reporter)
        throws IOException {

      String line = value.toString();
      int numInside = 0;
      int numOutside = 0;

      // 对于输入数据中的每一行，将其解析为两个 double 值，代表一个点的 x 和 y 坐标
      // 然后计算该点是否在圆内，并将计数器加 1
      // 最后输出两个计数器的值，供 Reduce 函数聚合
      for (String token : line.split("\\p{Space}+")) {
        double x = Double.parseDouble(token);
        double y = Double.parseDouble(token);
        if (x * x + y * y <= 1) {
          numInside++;
        } else {
          numOutside++;
        }
        numRecords++;
      }

      // 输出计数器的值，供 Reduce 函数聚合
      output.collect(NullWritable.get(), NullWritable.get());
    }

    @Override
    public void close() throws IOException {
      // 输出计数器的值，供 Reduce 函数聚合
      FileSystem fileSys = FileSystem.get(getConf());
      fileSys.create(new Path("mypath/num_records"), true).writeLong(numRecords);
    }
  }

  public static class Reduce extends MapReduceBase
      implements Reducer<NullWritable, NullWritable, NullWritable, DoubleWritable> {

    public void reduce(NullWritable key, Iterator<NullWritable> values,
        OutputCollector<NullWritable, DoubleWritable> output, Reporter reporter)
        throws IOException {
      Configuration conf = new Configuration();
      FileSystem fileSys = FileSystem.get(conf);
      long numRecords = fileSys.open(new Path("mypath/num_records")).readLong();

      // 计算圆周率的估计值
      double pi = 4.0 * numRecords / PiEstimator.NUM_MAP_TASKS / PiEstimator.NUM_SAMPLES_PER_MAP_TASK;

      // 输出圆周率的估计值
      DecimalFormat df = new DecimalFormat("#.##########");
      output.collect(NullWritable.get(), new DoubleWritable(Double.parseDouble(df.format(pi))));
    }
  }
  
  private static final int NUM_MAP_TASKS = 20;
  private static final int NUM_SAMPLES_PER_MAP_TASK = 100000;
}

这个示例代码包括一个 Mapper 和一个 Reducer。Mapper 阶段会对输入数据中的每个点进行判断，看该点是否在圆内，然后输出计数器的值，供 Reducer 函数聚合。Reducer 阶段会读取 Mapper 输出的计数器值，计算圆周率的估计值，并输出。该示例代码使用了 Hadoop 的 MapReduce 框架和 HDFS 分布式文件系统，可以通过输入参数指定输入和输出路径。