自增(++) 与 自减(--)

你还记得自增(++)和 自减(--)吗?

在程序员生涯中,我们在编写代码时,时常会用到 ++ 和 --, 对于这些特殊的运算符的含义和用法,你是否真明白这些运算符的含义?

在编码过程中,我们经常会使用 i=i+1(或则 i=i-1 )。

i=i+1; // 表示 变量 i+1的值重新赋值给变量 i(也就是 i 自动增加 1 );

i=i-1; // 表示 变量 i-1的值重新赋值给变量 i(也就是 i 自动减 1 );

在编程语言中存在着一种特殊的运算符

自增运算符(++) 和 自减运算符(--),这种特殊的运算符则用来表示 变量的 自增 1 或则 自减 1。

例如:

i++ 则表示 i=i+1 (也可以把i++ 看做为 i=i+1的简写方式)

i-- 则表示 i=i-1 (也可以把i– 看做为 i=i-1的简写方式)

自增(++): 将变量的值加1,它分为 前缀式( 如 ++i )后缀式( 如 i++ )
自减(--): 将变量的值减1,它分为 前缀式( 如 --i )后缀式( 如 i-- )

运算符采用 前缀式和后缀式 对本身的影响都是一样的,都是加1或者减1。
(也就是说: ++i 和 i++ 都表示 i=i+1)

但是 当把他们作为其他表达式的一部分,两者就有区别了

如:

前缀式: j = ++i 表示先运算,再赋值。
后缀式: j = i++ 表示先赋值,再运算。

先看一段代码(前缀式)

1
2
3
4
5
6
7
8
9
public class Test {
public static void main(String[] args) {
int i=10;
int j=0;
j=++i; // 前缀式:表示先运算 则:i=i+1 => i=10+1 => i=11,
//再赋值:则:j=i => j=11
System.out.println("j="+j+", i="+i); // 最后结果为 j=11, i=11;
}
}

再看一段代码(后缀式)

1
2
3
4
5
6
7
8
9
public class Test {
public static void main(String[] args){
int i=10;
int j=0;
j=i++; // 后缀式:表示先赋值 则: j=i => i=10 => j=10,
//再运算:则 i=i+1 => i=10+1 => i=11
System.out.println("j="+j+", i="+i); // 最后结果为 j=10, i=11;
}
}

自减(--)作为 其他表达式的一部分与 自增(++) 一样,这里我就不重复举例了。

再看看下面这段代码

1
2
3
4
5
6
7
8
public class Test {
public static void main(String[] args) {
int i=10;
int j=(i++)+(++i);
int k=(--i)+(i--);
System.out.println("i="+i+", j="+j+",k="+k);
}
}

这段代码运算后 i=?, j=?, k=?

答案为: i=10, j=22, k=22

如果你回答正确了,那说明你对 自增(++)和 自减(--) 运算符 已经算是掌握了。

分析一下上面的代码

  1. i=10;
  2. i++ 后缀写法,表示先赋值再运算,也就是 参与运算的值为 10; 然后 i=i+1 此时 i 的值变成为 11
  3. ++i 前缀写法, 表示先运算再赋值,也就是先 i=i+1 此时 i=11+1 侧 i=12 然后在赋值,也就是参与运算的值为 12
  4. j = 10 + 12; 最后 j=22,i=12
  5. --i 前缀写法,表示先运算再赋值 此时先 i=i-1 ,则 i=12-1 =>i=11 此时参与运算的值为 11
  6. i-- 后缀写法,表示先赋值在运算 此时先赋值,则参与运算的值为 11, 再运算 i=i-1=>i=11-1=10
  7. k=11+11 =22;

最后得出答案为:i=10, j=22,k=22;

再问一个问题?

下面这段代码能编译通过吗?

1
2
3
4
5
6
7
8
9
10
11
public class Test {
public static void main(String[] args) {
float f = 1.1f;
f++;
double d = 2.1d;
d++;
char c='a';
c++;
System.out.println(f+" "+d+" "+c);
}
}

如果你回答可以,那么你已经掌握了 自增(++) 和 自减(--)运算符了。

答案为: f=2.1 d=3.1 c=b

自增与自减运算符还遵循以下规律 :

  1. 可以用于整数数据类型byte、short、int、long,浮点类型float、double,以及字符类型 char。
  2. 在Java5.0及以上版本中,它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。
  3. 它们的运算结果的类型与被运算的变量的类型相同。

关于面试题

来看看面试题的代码:

1
2
3
4
5
6
7
8
9
public class Test {
public static void main(String[] args) {
int j=0;
for (int i = 0; i < 100; i++){
j = j++;
}
System.out.println(j);
}
}

也许你的第一反应和我一样, j=100;

结果答案: j=0 ;

原来这是因为Java编译器使用了中间缓存变量的机制

java的编译器在遇到i++和i–的时候会重新为变量运算分配一块内存空间,以存放原始的值,而在完成了赋值运算之后,将这块内存释放掉。

首先看一下如果是 j = i++ 的情况:

所以上图的操作等于如下操作

1
2
3
temp = i;
i=i+1;
j=temp;

我们再看看 j = j++ 的情况

所以 最后一次循环后的 j 还是等于 0;

因此对于自增(++)、自减(--)运算符的变量进行赋值时都需要特别注意。

如果在程序中只输入i++就不会出现这个方面的问题,所以大家在以后的程序中如果使用到i=i++的时候要格外小心,一般只需要用 i++ 就不会有问题了。