反转长Java的最快方法

反转长值的最快方法是什么

例如，9876543210应返回0123456789

这就是我现在拥有的：

long n = 0, c = 987654321 * 10; // *10 is to get 9876543210 as long value;
while (c > 0) n = n * 10 + c % 10;
System.out.println(n);

---

您的程序遇到了一个无限循环，因为您从未更改c的值。在每次迭代结束时加上c/=10，它就会起作用，尽管前导零会因为是一个数字而被删除

long n = 0, c = 9876543210L; 
while (c > 0){
    n = n * 10 + c % 10;
    c /= 10;
}
System.out.println(n);

如果需要有前导零，则应该考虑使用字符串。

long c = 9876543210L;
final StringBuilder sb = new StringBuilder();
while (c > 0){
    sb.append(c % 10);
    c /= 10;
}
System.out.println(sb.toString());

---

您的程序遇到了一个无限循环，因为您从未更改c的值。在每次迭代结束时加上c/=10，它就会起作用，尽管前导零会因为是一个数字而被删除

long n = 0, c = 9876543210L; 
while (c > 0){
    n = n * 10 + c % 10;
    c /= 10;
}
System.out.println(n);

如果需要有前导零，则应该考虑使用字符串。

long c = 9876543210L;
final StringBuilder sb = new StringBuilder();
while (c > 0){
    sb.append(c % 10);
    c /= 10;
}
System.out.println(sb.toString());

---

我想这可能很快

long x = 1234567890L;
String reversed = new StringBuilder(Long.toString(x)).reverse().toString();

// reversed = "0987654321"

如果要再次将反向值转换为长值：

---

我想这可能很快

long x = 1234567890L;
String reversed = new StringBuilder(Long.toString(x)).reverse().toString();

// reversed = "0987654321"

如果要再次将反向值转换为长值：

---

您可以简单地转换为字符串，然后还原字符串，特别是如果您希望在最后输出字符串。这应该是非常直接的，它的前导值为0，也可能比计算每个位置的速度更快，但valueOf的转换成本可能会抵消这一优势：

    long c = 9876543210L;
    String cAsString = String.valueOf(c);
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < cAsString.length(); i++) {
        builder.append(cAsString.substring(cAsString.length() - (i + 1), cAsString.length() - i));
    }
    System.out.println(builder.toString());

我对当前答案的选项做了一点比较：

    public static void main(String[] args) {
    Instant start = Instant.now();
    for (long i = 0; i < 100_000_000; i++) {
        stringbuilderWithDirectCalcs(i);
    }
    Duration duration = Duration.between(start, Instant.now());
    System.out.println("Took " + duration);
}


protected static void stringbuilderWithDirectCalcs(long value) {
    final StringBuilder sb = new StringBuilder();
    while (value > 0) {
        sb.append(value % 10);
        value /= 10;
    }
    // System.out.println(sb.toString());
}


protected static void stringbuilderConvenient(long value) {
    String reverted = new StringBuilder(String.valueOf(value)).reverse().toString();
    //System.out.println(reverted);
}


protected static void stringbuilderHandCrafted(long value) {
    String cAsString = String.valueOf(value);
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < cAsString.length(); i++) {
        builder.append(cAsString.substring(cAsString.length() - (i + 1), cAsString.length() - i));
    }
    //System.out.println(builder.toString());
}

---

因此，用手扫描字符串并将StringBuilder一步一步地粘在一起似乎是不可能的。显然，Stephen C在他的评论中是正确的，当转换为字符串时，计算无论如何都会发生。但是基于Stringbuilder.reverse和手工计算每个位置的方法非常接近，任何差异都可能是由于运行时的微小波动造成的。因此，您可能会选择StringBuilder.reverse方法，而不是手动计算每个位置，以获得大致相同的可读性。

您可以简单地转换为字符串，然后还原字符串，特别是如果您希望最终输出字符串。这应该是非常直接的，它的前导值为0，也可能比计算每个位置的速度更快，但valueOf的转换成本可能会抵消这一优势：

    long c = 9876543210L;
    String cAsString = String.valueOf(c);
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < cAsString.length(); i++) {
        builder.append(cAsString.substring(cAsString.length() - (i + 1), cAsString.length() - i));
    }
    System.out.println(builder.toString());

我对当前答案的选项做了一点比较：

    public static void main(String[] args) {
    Instant start = Instant.now();
    for (long i = 0; i < 100_000_000; i++) {
        stringbuilderWithDirectCalcs(i);
    }
    Duration duration = Duration.between(start, Instant.now());
    System.out.println("Took " + duration);
}


protected static void stringbuilderWithDirectCalcs(long value) {
    final StringBuilder sb = new StringBuilder();
    while (value > 0) {
        sb.append(value % 10);
        value /= 10;
    }
    // System.out.println(sb.toString());
}


protected static void stringbuilderConvenient(long value) {
    String reverted = new StringBuilder(String.valueOf(value)).reverse().toString();
    //System.out.println(reverted);
}


protected static void stringbuilderHandCrafted(long value) {
    String cAsString = String.valueOf(value);
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < cAsString.length(); i++) {
        builder.append(cAsString.substring(cAsString.length() - (i + 1), cAsString.length() - i));
    }
    //System.out.println(builder.toString());
}

---

---

因此，用手扫描字符串并将StringBuilder一步一步地粘在一起似乎是不可能的。显然，Stephen C在他的评论中是正确的，当转换为字符串时，计算无论如何都会发生。但是基于Stringbuilder.reverse和手工计算每个位置的方法非常接近，任何差异都可能是由于运行时的微小波动造成的。因此，可以选择StringBuilder.reverse方法，而不是手动计算每个位置，以获得大致相同性能的可读性。

*10是将9876543210作为长值；-只需执行9876543210L。将长值转换为字符串，然后反转字符串。请注意，如果将前导零保持为长值，则每次前导零都将被剥离。*10表示将9876543210作为长值；-只需执行9876543210L。将长值转换为字符串，然后反转字符串。请注意，如果您将前导零保留很长时间，它每次都会被剥离。使用String.fromValue并将其还原不是更快吗？没有计算只涉及数组运算…@FrankHopkins你有什么建议？@FrankHopkins-我不确定它一定会是。长->字符串转换在引擎盖下重复除以10和模数10。你为什么不做个实验？该死，对不起。。。我编辑了你的答案而不是我的。。。将查找撤消按钮…@FrankHopkins不用担心。使用String.fromValue然后将其还原不是更快吗？没有计算只涉及数组运算…@FrankHopkins你有什么建议？@FrankHopkins-我不确定它一定会是。长->字符串转换在引擎盖下重复除以10和模数10。你为什么不做个实验？该死，对不起。。。我编辑了你的答案而不是我的。。。将查找撤消按钮…@FrankHopkins别担心。@georgezhang006请注意，从字符串返回long，例如by long.parseLongreversed可能会删除前导零，导致987654321。是的，当然。我不知道提问者想如何使用这个反向值，但如果作为一个数字，那么在开始和结束时修剪0是很重要的end@georgezhang006请注意，从字符串返回long，例如by long.parseLongreversed可能会删除前导零，从而导致987654321。是的，当然。我不知道提问者想如何使用这个反向的值，但是如果作为一个数字，那么在开始时修剪0是很重要的，在结束时修剪0是很重要的，除非它不能避免每个位置的计算。它们发生在内部。看看源代码…除了它不能避免每个位置的计算。它们发生在内部。看看源代码。。。