java基础(二) 自增自减与贪心规则

引言

JDK中提供了自增运算符++，自减运算符--。这两个操作符各有两种使用方式：前缀式（++ a,--a），后缀式（a++，a--）。可能说到这里，说不得有读者就会吐槽说，前后缀式都挺简单的，前缀式不就是先进行+1（或-1），然后再使用该值参与运算嘛，后缀式则相反。有必要长篇大论吗？

前后缀式的区别确实是这样，最起码表面上理解起来是这样，但是更深入的理解就不是这么简单了，甚至严重影响到你的程序的正确性。不信，接下去看吧！

1. 前缀式与后缀式的真正区别

在Java中，运算是从左往右计算的，并且按照运算符的优先级，逐一计算出表达式的值，并用这个值参与下一个表达式的运算，如：1+2+3，其实是先计算出1+2表达式的值为3，再参与下一个表达式的运算(1+2)+3，即3+3。再如判断if(a+2==3)。如此类推。

a++是一个表达式 ，那么a++就会有一个表达式的计算结果，这个计算结果就是a的旧值（加1前的值）。相对的，++a表达式的计算结果a加1后的值。所以，自增的前缀形式与后缀形式的本质区别是：表达式的值（运算结果）是加1前的变量的值还是加1后的变量的值（自减也是如此）。并不是先加1 与后加1的区别，或者说，前后缀形式都是先加1（减1）的，才得到表达式的值，再参与下一步运算。因为这是一个表达式，必须先计算完表达式的运算，最后才会得到表达式的值

我们来看一个面试经常遇到的问题：

int a = 5;

a = a++;

//此时a的值是多少？

有猜到a的值吗？我们用上面所学到的分析一下：a=a++可以理解成以下几个步骤：

1> 计算a自加1，即 a=a+1

2> 计算表达式的值，因为这是后缀形式，所以a++表达式的值就是加1前a的值(值为5)；

3> 将表达式的值赋值给a，即a=5。

所以最后a的值是5。

同理，如果改成a = ++a;，则a的值是6。这是因为++a表达式的值是加1后的a，即为6。

2. 自增自减是包含两个两个操作，不是线程安全的

自增、自减运算符本质上不是一个计算操作，而是两个计算操作。以a++为例，这个运算将会编译器解析成：a=a+1，即包含两个单目运算符（+、=）,一个单目运算符的计算操作可以看作是一个原子性操作。a++的步骤可以描述成：1> 先取a加1，将结果存储在临时空间；2>将结果赋给a。所以，自增自减运算符包含两个操作：一个加1（减1）的操作和一个赋值的操作

这个原理好像对我的编程没有用吧？不是的，在单线程的环境下，你可以不管这个细节。但在多线程的情况下，你就得时刻牢记这个细节了。要知道，自增自减不是原子性操作，也就是说不是线程安全的运算。因此，在多线程下，如果你要对共享变量实现自增自减操作，就要加锁，或者使用JDK提供的原子操作类（如AtomincInteger，AtomicLong等）提供的原子性自增自减方。

来看个例子，验证一下。下面的例子提供三个静态变量（一个是原子操作类），创建了10个线程，每个线程都对这三个变量以不同的方式进行加1操作,并循环1000次。

public class MyTest {

	static int a = 0;

	static int b = 0;

	//原子性操作类

	static AtomicInteger atomicInt = new AtomicInteger(0);

	public static void main(String[] args) throws InterruptedException {

		for (int i = 0; i < 10; i++) {//创建10个线程

			Thread t = new Thread() {

				@Override

				public void run() {

					for (int j = 0; j < 1000; j++) {//计算1000次

						a = a + 1;

						b++;

						atomicInt.incrementAndGet();//自增的原子性方法

					}

				}

			};

			t.start();

		}

		// 判断当前的活动线程是不是只有main线程，以确保10个计算线程执行完成。

		while (Thread.activeCount() > 1) {

			Thread.sleep(1000);

		}

		System.out.println("a=a+1在多线程下的结果是：" + a);

		System.out.println("b++在多线程下的结果是：" + b);

		System.out.println("原子操作类AtomicInteger在多线程下的结果是：" + atomicInt.get());

	}

}

运行结果：

a=a+1在多线程下的结果是：8883

b++在多线程下的结果是：8974

原子操作类AtomicInteger在多线程下的结果是：10000

从运行的结果可以看出，a=a+1、b++不是线程安全的，没有计算出正确的结果10000。也就是说这两个表达式都不是原子性操作。事实上，它们都包含了两个计算操作。

3. 由 a+++b 表达式引起的思考

看到这个表达式，真的很让人疑惑：编译器是怎么解析的，是解析成

a++ + b

还是

a+ ++b

真纠结，干脆直接在编译器上跑一趟，看看结果吧！

	int a = 5;

	int b = 5;

	int c=a+++b;

	System.out.println("a的值是: "+a);

	System.out.println("b的值是: "+b);

运行结果：

a的值是: 6

b的值是: 5

从结果可以确认，a+++b 其实是解析成了 a++ +b，为什么要这样结合呢？其实有两点原因：

Java中的运算是从左往右进行的；
java编译器有一种规则——贪心规则。也就是说，编译器会尽可能多地结合有效的符号。

那么，a+++b这样的结合方式就可以解释了

但是这种结合是：尽可能多的结合，而不管这样的结合是否合法。如：

a--b

会被编译器解析成

a-- b

尽管这是不合法，但编译器还是这样处理了，这就导致编译不通过，产生编译错误。

编译器为什么要采用贪心规则呢？

从上面的分析来看，贪心规则在编程中也不好利用。那么，贪心规则的主要目的是为了什么？

贪心规则的主要目的就是为了分析String字符串，看看下面的例子就会明白：

	String s = "\17";

	System.out.println("\\17 转义字符的值是："+s+"  长度是："+s.length());

	s = "\171";

	System.out.println("\\171 转义字符的值是："+s+"  长度是："+s.length());

	s = "\1717";

	System.out.println("\\1717 转义字符的值是："+s+"  长度是："+s.length());

	s = "\17178";

	System.out.println("\\17178 转义字符的值是："+s+"  长度是："+s.length());

运行结果：

\17 转义字符的值是：长度是：1

\171 转义字符的值是：y 长度是：1

\1717 转义字符的值是：y7 长度是：2

\17178 转义字符的值是：y78 长度是：3

“\17” 经转义得到一个特殊字符 “” 。而“\171” 转义后也得到一个字符 “y”。但 “\1717”、“\17178” 得到的字符串大于1，不再是一个字符，分别是 “y7”、“y78”。

也就是说,“\1717” 字符串只转义了“\171” 部分，再链接 “7” 部分。“\17178” 字符串只转义了 “\171” 部分,再连接 “78”。

那为什么 “\171” 为什么不转义 ”\17“ 部分，再链接 ”1“ 呢，而是作为一个整体进行转义的字符串呢？

这就是 ”贪心规则“ 所决定的。八进制的转义字符的取值范围是 \0~\377。所以解析 ”\171“ 字符串时，编译器尽可能多地结合字符成一个转移字符，”\171“ 还在取值范围内，所以就是一个字符。但 ”\1718” 字符串，最多结合前4个字符成一个有效的转义字符 “\171”，而“\1717” 已经超出取值范围，不是有效字符，所以最后解析成 “\171” + "7" 的结果。“17178” 也是如此。

总结：

编译器在分析字符时，会尽可能多地结合成有效字符，但有可能会出现语法错误。
贪心规则是有用的，特别编译器是对转义字符的处理。