编程真难啊

2

3

4

5

6

7

8

9

10

int x = numberToInvertSign;

boolean pos = x > 0;

for(int i = 0; i < 2*Math.abs(x); i++){

    if(pos){

        numberToInvertSign--;

    }

    else{

        numberToInvertSign++;

    }

}

2

int n = ....;

 n = (0xffffffff ^ n) + 1;

<code>n = ~n + 1; </code>

<code><code>n = ~--n; </code></code>

2

3

4

5

6

7

<code><code>n^= 0xffffffff;

int m;

for (m= 1; m != 0 && ((n&m) != 0); m<<= 1);

n|= m;

if (m == 0) n= m;

else for (m >>= 1; m != 0; n^= m, m>>=1);

</code></code>

2

3

public int invert(int i) {

  return i - (i + i);

}

2

3

4

5

6

7

switch (i)

{

  case 1: return -1;

  case 2: return -2;

  case 3: return -3;

  // ... etc, you get the proper pattern

}

2

3

4

5

6

7

8

9

10

11

12

13

14

int absoluteValue(int num)

{

 int max = 0;

 for(int i = 0; true; ++i)

 {

  max = i > max ? i : max;

  if(i == num)

  {

   if(i >= max)

    return i;

   return -i;

  }

 }

}

2

3

4

5

6

7

8

9

10

11

public int invert(int n) {

    String nStr = String.valueOf(n);

    if (nStr.startsWith("-")) {

        nStr = nStr.replace("-", "");

    } else {

        nStr = "-" + nStr;

    }

    return Integer.parseInt(nStr);

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

public interface Negatable<T extends Number> {

  T value();

  T negate();

}

public abstract class NegatableInteger implements Negatable<Integer> {

  private final int value;

  protected NegatableInteger(int value) {

    this.value = value;

  }

  public static NegatableInteger createNegatableInteger(int value) {

    if (value > 0) {

      return new NegatablePositiveInteger(value);

    }

    else if (value == Integer.MIN_VALUE) {

      throw new IllegalArgumentException("cannot negate " + value);

    }

    else if (value < 0) {

      return new NegatableNegativeInteger(value);

    }

    else {

      return new NegatableZeroInteger(value);

    }

  }

  public Integer value() {

    return value;

  }

  public Integer negate() {

    String negatedString = negateValueAsString ();

    Integer negatedInteger = Integer.parseInt(negatedString);

    return negatedInteger;

  }

  protected abstract String negateValueAsString ();

}

public class NegatablePositiveInteger extends NegatableInteger {

  public NegatablePositiveInteger(int value) {

    super(value);

  }

  protected String negateValueAsString () {

    String valueAsString = String.valueOf (value());

    return "-" + valueAsString;

  }

}

public class NegatableNegativeInteger extends NegatableInteger {

  public NegatableNegativeInteger (int value) {

    super(value);

  }

  protected String negateValueAsString () {

    String valueAsString = String.valueOf (value());

    return valueAsString.substring(1);

  }

}

public class NegatableZeroInteger extends NegatableInteger {

  public NegatableZeroInteger (int value) {

    super(value);

  }

  protected String negateValueAsString () {

    return String.valueOf (value());

  }

}