如何在 Java 中将 1200 格式化为 1.2k

Question

我想用 java 将以下数字格式化为它们旁边的数字：

 1000 to 1k
5821 to 5.8k
10500 to 10k
101800 to 101k
2000000 to 2m
7800000 to 7.8m
92150000 to 92m
123200000 to 123m

右边的数字将是长整数或整数，左边的数字将是字符串。我应该如何处理这个问题。我已经为此做了很少的算法，但我认为可能已经发明了一些可以做得更好的东西，如果我开始处理数十亿和数万亿，则不需要额外的测试:)

其他要求：

• 格式最多应包含 4 个字符
• 以上表示 1.1k 可以，11.2k 不行。同样 7.8m 可以，19.1m 不行。只允许小数点前一位有小数点。小数点前两位表示小数点后没有数字。
• 不需要四舍五入。 （显示的带有 k 和 m 的数字更多的是表示近似值的模拟量表，而不是精确的逻辑文章。因此，四舍五入是无关紧要的，主要是由于变量的性质，即使您正在查看缓存的结果，也可以增加或减少几位数字。）

原文由 MatBanik 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

这是 一个适用于任何长值的解决方案， 我发现它非常可读（核心逻辑在 format 方法的底部三行中完成）。

它利用 TreeMap 找到合适的后缀。它比我以前使用数组编写的解决方案效率更高，而且更难阅读。

 private static final NavigableMap<Long, String> suffixes = new TreeMap<> ();
static {
  suffixes.put(1_000L, "k");
  suffixes.put(1_000_000L, "M");
  suffixes.put(1_000_000_000L, "G");
  suffixes.put(1_000_000_000_000L, "T");
  suffixes.put(1_000_000_000_000_000L, "P");
  suffixes.put(1_000_000_000_000_000_000L, "E");
}

public static String format(long value) {
  //Long.MIN_VALUE == -Long.MIN_VALUE so we need an adjustment here
  if (value == Long.MIN_VALUE) return format(Long.MIN_VALUE + 1);
  if (value < 0) return "-" + format(-value);
  if (value < 1000) return Long.toString(value); //deal with easy case

  Entry<Long, String> e = suffixes.floorEntry(value);
  Long divideBy = e.getKey();
  String suffix = e.getValue();

  long truncated = value / (divideBy / 10); //the number part of the output times 10
  boolean hasDecimal = truncated < 100 && (truncated / 10d) != (truncated / 10);
  return hasDecimal ? (truncated / 10d) + suffix : (truncated / 10) + suffix;
}

---

测试代码

public static void main(String args[]) {
  long[] numbers = {0, 5, 999, 1_000, -5_821, 10_500, -101_800, 2_000_000, -7_800_000, 92_150_000, 123_200_000, 9_999_999, 999_999_999_999_999_999L, 1_230_000_000_000_000L, Long.MIN_VALUE, Long.MAX_VALUE};
  String[] expected = {"0", "5", "999", "1k", "-5.8k", "10k", "-101k", "2M", "-7.8M", "92M", "123M", "9.9M", "999P", "1.2P", "-9.2E", "9.2E"};
  for (int i = 0; i < numbers.length; i++) {
    long n = numbers[i];
    String formatted = format(n);
    System.out.println(n + " => " + formatted);
    if (!formatted.equals(expected[i])) throw new AssertionError("Expected: " + expected[i] + " but found: " + formatted);
  }
}

原文由 assylias 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

我知道，这看起来更像是一个 C 程序，但它超级轻量级！

 public static void main(String args[]) {
    long[] numbers = new long[]{1000, 5821, 10500, 101800, 2000000, 7800000, 92150000, 123200000, 9999999};
    for(long n : numbers) {
        System.out.println(n + " => " + coolFormat(n, 0));
    }
}

private static char[] c = new char[]{'k', 'm', 'b', 't'};

/**
 * Recursive implementation, invokes itself for each factor of a thousand, increasing the class on each invokation.
 * @param n the number to format
 * @param iteration in fact this is the class from the array c
 * @return a String representing the number n formatted in a cool looking way.
 */
private static String coolFormat(double n, int iteration) {
    double d = ((long) n / 100) / 10.0;
    boolean isRound = (d * 10) %10 == 0;//true if the decimal part is equal to 0 (then it's trimmed anyway)
    return (d < 1000? //this determines the class, i.e. 'k', 'm' etc
        ((d > 99.9 || isRound || (!isRound && d > 9.99)? //this decides whether to trim the decimals
         (int) d * 10 / 10 : d + "" // (int) d * 10 / 10 drops the decimal
         ) + "" + c[iteration])
        : coolFormat(d, iteration+1));

}

它输出：

 1000 => 1k
5821 => 5.8k
10500 => 10k
101800 => 101k
2000000 => 2m
7800000 => 7.8m
92150000 => 92m
123200000 => 123m
9999999 => 9.9m

原文由 Ilya Saunkin 发布，翻译遵循 CC BY-SA 2.5 许可协议