编程真难啊

最新推荐文章于 2024-03-21 11:01:30 发布

ktty445655619

最新推荐文章于 2024-03-21 11:01:30 发布

阅读量322

点赞数 1

CC 4.0 BY-SA版权

文章标签：编程 integer string class java interface

本文链接：https://blog.youkuaiyun.com/ktty445655619/article/details/6474476

原文：http://coolshell.cn/?p=1391 （酷壳:

CoolShell.cn

）

上周，在Sun的Java论坛上出现了一个这样的帖子，这个贴子的链接如下：
http://forums.sun.com/thread.jspa?threadID=5404590&start=0&tstart=0

LZ的贴子翻译如下：

大家好，我是一个Java的新手，我有一个简单的问题：请问我怎么才能反转一个整数的符号啊。比如把-12转成+12。是的，毫无疑问这是个简单的问题，但我弄了一整天我也找不到什么好的方法。非常感谢如果你能告诉我Java有什么方法可以做到这个事，或者告诉我一个正确的方向——比如使用一些数学库或是二进制方法什么的。谢谢！

这个贴子的沙发给出了答案：

n = -n;

LZ在四楼回复到：

我知道是个很简单的事，可我没有想到居然这么简单，我觉得你可能是对的。谢谢你。

过了一会，又回复到：

不开玩笑地说，我试了，真的没有问题耶！

看到这样的贴子，就能想到国内论坛上很多这样的“问弱智问题的贴子”，结果可能都会是比较惨！是的，国外的互联网文化和国内差不多，都是恶搞的人多于热心的人，呵呵。不过，国外的网民们有一点是好的，再恶搞也是就事搞事，不会有侮辱人的语言，这点真是值国内的人学习。

这本是一个平淡无奇的贴子，不过回复中那些恶搞的“解决方案”太强大了，在这里例举一下吧。

贴子的板凳给出了这样的答案（这是恶搞的开始）

    
    01.
    int x = numberToInvertSign; 
   
    02.
    boolean pos = x > 0; 
   
    03.
    for(int i = 0; i < 2*Math.abs(x); i++){ 
   
    04.
        if(pos){ 
   
    05.
            numberToInvertSign--; 
   
    06.
        } 
   
    07.
        else{ 
   
    08.
            numberToInvertSign++; 
   
    09.
        } 
   
    10.
    }

然后，有人说，n = -n 可以是可以，但不够晦涩，于是一个晦涩的解决方案出现了：

    
    1.
    int n = ....; 
   
    2.
     n = (0xffffffff ^ n) + 1;

然后，又出现了一些看似简单，其实是比较晦涩的方案

继续，有才的人从来就不少：

n = ~n + 1;

或

n = ~--n;

呵呵，开始越来越强大了，我以前也向大家介绍过《

如何加密/弄乱C源代码

》的文章，和这些恶搞的人可能有点相似吧。上面这个例子一出，大家都在讨论上面例子中的for循环语句，呵呵，很费解啊。

    
    1.
    n^= 0xffffffff; 
   
    2.
    int m; 
   
    3.
    for (m= 1; m != 0 && ((n&m) != 0); m<<= 1); 
   
    4.
    n|= m; 
   
    5.
    if (m == 0) n= m; 
   
    6.
    else for (m >>= 1; m != 0; n^= m, m>>=1);

然后，后面几个就开始乱来了：

    
    1.
    public int invert(int i) { 
   
    2.
      return i - (i + i); 
   
    3.
    }

  或
  
   1.
   switch (i) 
  
    2.
    { 
   
    3.
      case 1: return -1; 
   
    4.
      case 2: return -2; 
   
    5.
      case 3: return -3; 
   
    6.
      // ... etc, you get the proper pattern 
   
    7.
    }

不过事情还没有结束，看看下面这个吧，OMG。

    
    01.
    int absoluteValue(int num) 
   
    02.
    { 
   
    03.
     int max = 0; 
   
    04.
     for(int i = 0; true; ++i) 
   
    05.
     { 
   
    06.
      max = i > max ? i : max; 
   
    07.
      if(i == num) 
   
    08.
      { 
   
    09.
       if(i >= max) 
   
    10.
        return i; 
   
    11.
       return -i; 
   
    12.
      } 
   
    13.
     } 
   
    14.
    }

还有用字符串的解决方案：

    
    01.
    public int invert(int n) { 
   
    02.
        String nStr = String.valueOf(n); 
   
    03.
       
    04.
        if (nStr.startsWith("-")) { 
   
    05.
            nStr = nStr.replace("-", ""); 
   
    06.
        } else { 
   
    07.
            nStr = "-" + nStr; 
   
    08.
        } 
   
    09.
       
    10.
        return Integer.parseInt(nStr); 
   
    11.
    }

别忘了面象对象，有最新Java支持的模板库：

    
    01.
    public interface Negatable<T extends Number> { 
   
    02.
      T value(); 
   
    03.
      T negate(); 
   
    04.
    } 
   
    05.
       
    06.
       
    07.
       
    08.
    public abstract class NegatableInteger implements Negatable<Integer> { 
   
    09.
      private final int value; 
   
    10.
       
    11.
      protected NegatableInteger(int value) { 
   
    12.
        this.value = value; 
   
    13.
      } 
   
    14.
       
    15.
      public static NegatableInteger createNegatableInteger(int value) { 
   
    16.
        if (value > 0) { 
   
    17.
          return new NegatablePositiveInteger(value); 
   
    18.
        } 
   
    19.
        else if (value == Integer.MIN_VALUE) { 
   
    20.
          throw new IllegalArgumentException("cannot negate " + value); 
   
    21.
        } 
   
    22.
        else if (value < 0) { 
   
    23.
          return new NegatableNegativeInteger(value); 
   
    24.
        } 
   
    25.
        else { 
   
    26.
          return new NegatableZeroInteger(value); 
   
    27.
        } 
   
    28.
      } 
   
    29.
       
    30.
      public Integer value() { 
   
    31.
        return value; 
   
    32.
      } 
   
    33.
       
    34.
      public Integer negate() { 
   
    35.
        String negatedString = negateValueAsString (); 
   
    36.
        Integer negatedInteger = Integer.parseInt(negatedString); 
   
    37.
        return negatedInteger; 
   
    38.
      } 
   
    39.
       
    40.
      protected abstract String negateValueAsString (); 
   
    41.
    } 
   
    42.
       
    43.
       
    44.
       
    45.
    public class NegatablePositiveInteger extends NegatableInteger { 
   
    46.
      public NegatablePositiveInteger(int value) { 
   
    47.
        super(value); 
   
    48.
      } 
   
    49.
       
    50.
      protected String negateValueAsString () { 
   
    51.
        String valueAsString = String.valueOf (value()); 
   
    52.
        return "-" + valueAsString; 
   
    53.
      } 
   
    54.
    } 
   
    55.
       
    56.
       
    57.
       
    58.
    public class NegatableNegativeInteger extends NegatableInteger { 
   
    59.
      public NegatableNegativeInteger (int value) { 
   
    60.
        super(value); 
   
    61.
      } 
   
    62.
       
    63.
      protected String negateValueAsString () { 
   
    64.
        String valueAsString = String.valueOf (value()); 
   
    65.
        return valueAsString.substring(1); 
   
    66.
      } 
   
    67.
    } 
   
    68.
       
    69.
       
    70.
       
    71.
    public class NegatableZeroInteger extends NegatableInteger { 
   
    72.
      public NegatableZeroInteger (int value) { 
   
    73.
        super(value); 
   
    74.
      } 
   
    75.
       
    76.
      protected String negateValueAsString () { 
   
    77.
        return String.valueOf (value()); 
   
    78.
      } 
   
    79.
    }