Java 从int中提取偶数

这是我正在解决的问题

编写一个方法，该方法接受整数参数n 返回通过从n中删除奇数而形成的整数。这个 下表显示了几个调用及其预期返回值：

如果向方法传递了一个非0的偶数的负数，则结果也应该是负数，如上面传递-34512时所示

应忽略结果中的前导零，如果数字中没有除0以外的偶数，则该方法应返回0，如最后三个输出所示

到目前为止，我有这个-

public static int evenDigits(int n) {
    if (n != 0) { 
        int new_x = 0;
        int temp = 0;
        String subS = "";
    String x_str = Integer.toString(n);
        if (x_str.substring(0, 1).equals("-")) {
             temp = Integer.parseInt(x_str.substring(0, 2));
             subS = x_str.substring(2);
        } else {
             temp = Integer.parseInt(x_str.substring(0, 1));
             subS = x_str.substring(1);
        }

        if (subS.length() != 0) {
             new_x = Integer.parseInt(x_str.substring(1));
        }
        
        if (temp % 2 == 0) {
             return Integer.parseInt((Integer.toString(temp) + evenDigits(new_x)));
        } else {
            return evenDigits(new_x);
        }
    }
    return 0;
}

---

为什么人们总是想转换成字符串来处理数字？Java有非常好的算术原语来处理这个任务。例如：

public static int evenDigits(int n) {
    int rev = 0;
    int digitCount = 0;

    // handle negative arguments
    if (n < 0) return -evenDigits(-n);

    // Extract the even digits to variable rev
    while (n != 0) {
        if (n % 2 == 0) {
            rev = rev * 10 + n % 10;
            digitCount += 1;
        }
        n /= 10;
    }

    // The digits were extracted in reverse order; reverse them again
    while (digitCount > 0) {
        n = n * 10 + rev % 10;
        rev /= 10;
        digitCount -= 1;
    }

    // The result is in n
    return n;
}

公共静态整数位数（整数n）{
int rev=0；
int-digitCount=0；
//处理否定参数
if（n<0）返回-evendights（-n）；
//将偶数数字提取到变量rev
而（n！=0）{
如果（n%2==0）{
rev=rev*10+n%10；
数字计数+=1；
}
n/=10；
}
//按相反的顺序提取数字；再次将其反转
而（数字计数>0）{
n=n*10+rev%10；
rev/=10；
数字计数-=1；
}
//结果是n
返回n；
}

---

虽然像这样一个简单的学术练习并没有什么不同，但是仅仅通过算术来处理这项工作要比任何涉及转换到

String

的工作都要好。为什么人们总是想转换到

String

来处理数字？Java有非常好的算术原语来处理这个任务。例如：

public static int evenDigits(int n) {
    int rev = 0;
    int digitCount = 0;

    // handle negative arguments
    if (n < 0) return -evenDigits(-n);

    // Extract the even digits to variable rev
    while (n != 0) {
        if (n % 2 == 0) {
            rev = rev * 10 + n % 10;
            digitCount += 1;
        }
        n /= 10;
    }

    // The digits were extracted in reverse order; reverse them again
    while (digitCount > 0) {
        n = n * 10 + rev % 10;
        rev /= 10;
        digitCount -= 1;
    }

    // The result is in n
    return n;
}

public int evenDigits(int n) {
    int r = 0;
    boolean neg = false;
    String evenDigits = "";

    if (n < 0) { neg = true; n = abs(n); }

    // keep dividing n until n = 0
    while (n > 0) {
        r = n % 10;
        n = n / 10;         // int division
        if (r % 2 == 0) { evenDigits = Integer.toString(r) + evenDigits; }
    }

    int result = Integer.parseInt(evenDigits);
    if (neg) { result -= 2 * result; }

    return result;
}

公共静态整数位数（整数n）{
int rev=0；
int-digitCount=0；
//处理否定参数
if（n<0）返回-evendights（-n）；
//将偶数数字提取到变量rev
而（n！=0）{
如果（n%2==0）{
rev=rev*10+n%10；
数字计数+=1；
}
n/=10；
}
//按相反的顺序提取数字；再次将其反转
而（数字计数>0）{
n=n*10+rev%10；
rev/=10；
数字计数-=1；
}
//结果是n
返回n；
}

虽然像这样的一个简单的学术练习并没有什么不同，但是仅仅通过算术来处理这个任务，可以预期比任何涉及转换为

字符串的操作都要更好{
public int evenDigits(int n) {
    int r = 0;
    boolean neg = false;
    String evenDigits = "";

    if (n < 0) { neg = true; n = abs(n); }

    // keep dividing n until n = 0
    while (n > 0) {
        r = n % 10;
        n = n / 10;         // int division
        if (r % 2 == 0) { evenDigits = Integer.toString(r) + evenDigits; }
    }

    int result = Integer.parseInt(evenDigits);
    if (neg) { result -= 2 * result; }

    return result;
}

int r=0；
布尔负=假；
字符串“=”；
如果（n<0）{neg=true；n=abs（n）；}
//继续除以n，直到n=0
而（n>0）{
r=n%10；
n=n/10；//整数除法
如果（r%2==0）{evendights=Integer.toString（r）+evendights；}
}
int result=Integer.parseInt（偶数位数）；
如果（neg）{result-=2*result；}
返回结果；
}

这或多或少是一个伪代码，但我想你明白我的意思了。我以前也用过这个方法解决同样的问题。

public int-evendights（int-n）{
int r=0；
布尔负=假；
字符串“=”；
如果（n<0）{neg=true；n=abs（n）；}
//继续除以n，直到n=0
而（n>0）{
r=n%10；
n=n/10；//整数除法
如果（r%2==0）{evendights=Integer.toString（r）+evendights；}
}
int result=Integer.parseInt（偶数位数）；
如果（neg）{result-=2*result；}
返回结果；
}

---

这或多或少是一个伪代码，但我想你明白我的意思了。我以前也用过这种方法解决同样的问题。

通常从递归解决方案开始，然后再回到迭代解决方案（如果必须）：

公共静态整数位数（整数n）{
if（n<0）{
返回-偶数位数（-n）；
}else如果（n==0）{
返回0；
}否则如果（n%2==1）{
返回偶数位数（n/10）；
}否则{
返回10*个偶数位数（n/10）+（n%10）；
}
}

从递归解决方案开始，然后回到迭代解决方案通常更容易（如果必须）：

公共静态整数位数（整数n）{
if（n<0）{
返回-偶数位数（-n）；
}else如果（n==0）{
返回0；
}否则如果（n%2==1）{
返回偶数位数（n/10）；
}否则{
返回10*个偶数位数（n/10）+（n%10）；
}
}
基于
字符串的外行解决方案
s:

public static int evenDigits(int n) {

    StringBuilder evenDigitsBuffer = new StringBuilder();

    for (char digitChar : String.valueOf(n).toCharArray()) {
        int digit = Character.getNumericValue(digitChar);
        if (digit % 2 == 0) {
            evenDigitsBuffer.append(digit);
        }
    }

    return evenDigitsBuffer.length() > 0 
            ? Integer.signum(n) * Integer.parseInt(evenDigitsBuffer.toString())
            : 0;
}

基于
String
s的外行解决方案：

public static int evenDigits(int n) {

    StringBuilder evenDigitsBuffer = new StringBuilder();

    for (char digitChar : String.valueOf(n).toCharArray()) {
        int digit = Character.getNumericValue(digitChar);
        if (digit % 2 == 0) {
            evenDigitsBuffer.append(digit);
        }
    }

    return evenDigitsBuffer.length() > 0 
            ? Integer.signum(n) * Integer.parseInt(evenDigitsBuffer.toString())
            : 0;
}

Integer.parseInt（Integer.toString（n）.chars（）.filter（x->x%2==0）.mapToObj（x->（char）x）…collect（collector.joining（））
或类似的东西。应该注意，
int
不是十进制数。计算机中表示的
int
的“数字”是二进制位。因此，返回所有“偶数”数字很简单，就是返回零。@HotLicks您将数字本身和它的各种表示方式混为一谈。问题陈述清楚地提到了数字的十进制表示形式中的数字。@Misha-问题中没有提到“十进制”，或者说应该假设某个特定的表示形式。根本没有提到代表性。（我不是那个把“数字”和“表示”混为一谈的人。）@hotricks，是的，问题描述有点不精确，但你要求该方法始终返回零的解释与附带的示例不一致。根据这些示例，最合理的解释是打算使用基于基数10的解决方案，或者至少可以接受。
Integer.parseInt（Integer.toString（n）.chars（）.filter（x->x%2==0）.mapToObj（x->（char）x）…collect（collector.joining（））
或类似的东西。应该注意，
int