String formattedPercentage = String.format("%.2f", percentage); 这里会对double 类型percentage 四舍五入吗

是的，`String.format("%.2f", percentage)` 会对 `double` 类型的 `percentage` 进行四舍五入。这里的 "%.2f" 是一个格式化字符串，表示将 `percentage` 格式化为带有两位小数的浮点数。四舍五入是默认的舍入方式，当小数部分大于等于 0.5 时会进位，小于 0.5 时会舍去。

相关问题

生成0-100之间的200个随机整数，并统计各个数出现的次数和频率(用XX.X%表示)。 0==〉10次==〉XX.X% 1==〉20次==〉XX.X% 。。。。。。 用HashMap实现。

### 回答1：
以下是使用 Java 语言实现的代码示例：

import java.util.HashMap;
import java.util.Random;

public class RandomNumberFrequency {
    public static void main(String[] args) {
        // 生成 200 个随机数
        int[] numbers = new int[200];
        Random random = new Random();
        for (int i = 0; i < 200; i++) {
            numbers[i] = random.nextInt(101); // 生成 0~100 之间的随机数
        }

        // 统计每个数出现的次数
        HashMap<Integer, Integer> frequencyMap = new HashMap<>();
        for (int number : numbers) {
            // 如果当前数字已经出现过，则在原有基础上加 1
            if (frequencyMap.containsKey(number)) {
                frequencyMap.put(number, frequencyMap.get(number) + 1);
            } else {
                // 否则将这个数字的出现次数设置为 1
                frequencyMap.put(number, 1);
            }
        }

        // 输出每个数字的出现次数和频率
        for (int i = 0; i <= 100; i++) {
            if (frequencyMap.containsKey(i)) {
                int frequency = frequencyMap.get(i);
                double percentage = (double) frequency / 200 * 100; // 计算频率
                System.out.printf("%d ==> %d 次 ==> %.1f%%\n", i, frequency, percentage);
            }
        }
    }
}

在这段代码中，我们使用了 `java.util.Random` 类来生成随机数，使用了 `java.util.HashMap` 类来统计每个数字出现的次数。

使用这段代码的输出结果可能如下所示：

0 ==> 4 次 ==> 2.0%
1 ==> 4 次 ==> 2.0%
2 ==> 4 次 ==> 2.0%
3 ==> 6 次 ==> 3.0%
4 ==> 4 次 ==> 2.0%
5 ==> 4 次 ==> 2.0%
6 ==> 3 次 ==> 1.5%
7 ==> 5 次 ==> 2.  

### 回答2：
为了实现该功能，首先需要使用Java.util包中的Random类生成0到100之间的200个随机整数。然后，我们可以使用HashMap来存储每个数出现的次数。

具体实现过程如下：

1. 导入Java.util包中的Random和HashMap类。
2. 创建一个Random对象，用于生成随机数。
3. 创建一个HashMap对象，用于存储每个数出现的次数。
4. 使用循环生成200个随机数，将每个数存入HashMap中。
5. 在循环的过程中，如果HashMap中已存在该数，则将其出现次数加1，否则将该数加入HashMap并将出现次数设为1。
6. 最后，遍历HashMap，计算每个数的出现频率，并将结果以XX.X%的形式输出。

以下是代码示例：

import java.util.HashMap;
import java.util.Random;

public class RandomNumberFrequency {
public static void main(String[] args) {
Random random = new Random();
HashMap<Integer, Integer> numberCount = new HashMap<>();

// 生成200个随机数，并统计各个数出现的次数
for (int i = 0; i < 200; i++) {
int randomNumber = random.nextInt(101); // 生成0到100之间的随机数
numberCount.put(randomNumber, numberCount.getOrDefault(randomNumber, 0) + 1);
}

// 计算每个数的出现频率并输出
for (int number : numberCount.keySet()) {
int count = numberCount.get(number);
double frequency = (double) count / 200 * 100;
System.out.println(number + " => " + count + "次 => " + String.format("%.1f%%", frequency));
}
}
}

上述代码将会输出类似以下格式的内容：

0 => 3次 => 1.5%
1 => 5次 => 2.5%
2 => 7次 => 3.5%
3 => 12次 => 6.0%
...

每行表示一个数的出现次数及其频率。  

### 回答3：
首先，我们可以使用Java的Random类来生成0到100之间的200个随机整数。然后，我们可以使用HashMap来存储每个数出现的次数。以下是实现的代码：

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class RandomNumberFrequency {
public static void main(String[] args) {
// 创建一个HashMap来存储每个数出现的次数
Map<Integer, Integer> frequencyMap = new HashMap<>();

// 生成200个随机整数
Random random = new Random();
for (int i = 0; i < 200; i++) {
int randomNumber = random.nextInt(101); // 生成0到100之间的随机整数
frequencyMap.put(randomNumber, frequencyMap.getOrDefault(randomNumber, 0) + 1);
}

// 遍历HashMap，统计每个数出现的次数和频率
for (int number = 0; number <= 100; number++) {
int frequency = frequencyMap.getOrDefault(number, 0);
double percentage = (double) frequency / 200 * 100;
System.out.println(number + "==>" + frequency + "次==> " + String.format("%.1f%%", percentage));
}
}
}

运行上述代码，就会生成一个包含200个0到100之间随机整数的HashMap，并输出每个数出现的次数和频率。

注意，上述代码中`getOrDefault`方法可以用来获取一个数在HashMap中的出现次数，若该数还未在HashMap中记录过，则默认其出现次数为0。`String.format("%.1f%%", percentage)`用来保留小数点后一位并以百分比形式输出频率。

null_ratio_percentage = null_courts_df.applymap(lambda x: "{:.2f}%".format(x * 100))，这段代码将Dataframe中的null值也变成了百分数

是的，`applymap` 方法会对Dataframe中的每个元素应用指定的函数，并返回一个新的Dataframe。在你提供的代码中，应用的函数是 `lambda x: "{:.2f}%".format(x * 100)`，它的作用是将传入的数值乘以100并保留两位小数，然后加上百分号并转化为字符串类型。因此，无论Dataframe中的元素是不是缺失值，最终都会被转化为百分数的形式。

如果你只想将Dataframe中的非缺失值转化为百分数，可以先使用 `fillna` 方法将缺失值填充为0，然后再应用 `applymap` 方法。示例代码如下：

import pandas as pd
import numpy as np

# 创建一个包含缺失值的示例Dataframe
df = pd.DataFrame({'A': [1, 2, None, 4],
                   'B': [None, 1.5, 2.5, None],
                   'C': [3, 4, 5, 6]})

# 将缺失值填充为0
df_filled = df.fillna(0)

# 将非缺失值转化为百分数
df_percentage = df_filled.applymap(lambda x: "{:.2f}%".format(x * 100) if x != 0 else np.nan)

print(df_percentage)

输出结果：

        A       B        C
0  100.00%     nan  300.00%
1  200.00%  150.00%  400.00%
2      nan  250.00%  500.00%
3  400.00%     nan  600.00%

在上述示例中，`fillna(0)` 将缺失值填充为0，然后 `applymap` 方法中的 `lambda x: "{:.2f}%".format(x * 100) if x != 0 else np.nan` 表示只将非缺失值转化为百分数，缺失值仍保留为缺失值。注意，这里使用了numpy库中的 `np.nan` 表示缺失值，而不是Python内置的 `None`。