表达式编译优化
A. 正则表达式优化
^\[(?:(?:\d,)*\d)*\]$
这样不会有捕获组
B. 如何优化你的C代码
一、程序结构的优化
1、程序的书写结构
虽然书写格式并不会影响生成的代码质量，但是在实际编写程序时还是应该尊循一定的书写规则，一个书写清晰、明了的程序，有利于以后的维护。在书写程序时，特别是对于While、for、do…while、if…elst、switch…case等语句或这些语句嵌套组合时，应采用“缩格”的书写形式，
2、标识符
程序中使用的用户标识符除要遵循标识符的命名规则以外，一般不要用代数符号(如a、b、x1、y1)作为变量名，应选取具有相关含义的英文单词(或缩写)或汉语拼音作为标识符，以增加程序的可读性，如：count、number1、red、work等。
3、程序结构
c语言是一种高级程序设计语言，提供了十分完备的规范化流程控制结构。因此在采用C语言设计单片机应用系统程序时，首先要注意尽可能采用结构化的程序设计方法，这样可使整个应用系统程序结构清晰，便于调试和维护。于一个较大的应用程序，通常将整个程序按功能分成若干个模块，不同模块完成不同的功能。各个模块可以分别编写，甚至还可以由不同的程序员编写，一般单个模块完成的功能较为简单，设计和调试也相对容易一些。在C语言中，一个函数就可以认为是一个模块。所谓程序模块化，不仅是要将整个程序划分成若干个功能模块，更重要的是，还应该注意保持各个模块之间变量的相对独立性，即保持模块的独立性，尽量少使用全局变量等。对于一些常用的功能模块，还可以封装为一个应用程序库，以便需要时可以直接调用。但是在使用模块化时，如果将模块分成太细太小，又会导致程序的执行效率变低(进入和退出一个函数时保护和恢复寄存器占用了一些时间)。
4、定义常数
在程序化设计过程中，对于经常使用的一些常数，如果将它直接写到程序中去，一旦常数的数值发生变化，就必须逐个找出程序中所有的常数，并逐一进行修改，这样必然会降低程序的可维护性。因此，应尽量当采用预处理命令方式来定义常数，而且还可以避免输入错误。
5、减少判断语句
能够使用条件编译(ifdef)的地方就使用条件编译而不使用if语句，有利于减少编译生成的代码的长度，能够不用判断语句则少用判断用语句。
6、表达式
对于一个表达式中各种运算执行的优先顺序不太明确或容易混淆的地方，应当采用圆括号明确指定它们的优先顺序。一个表达式通常不能写得太复杂，如果表达式太复杂，时间久了以后，自己也不容易看得懂，不利于以后的维护。
7、函数
对于程序中的函数，在使用之前，应对函数的类型进行说明，对函数类型的说明必须保证它与原来定义的函数类型一致，对于没有参数和没有返回值类型的函数应加上“void”说明。如果果需要缩短代码的长度，可以将程序中一些公共的程序段定义为函数，在Keil中的高级别优化就是这样的。如果需要缩短程序的执行时间，在程序调试结束后，将部分函数用宏定义来代替。注意，应该在程序调试结束后再定义宏，因为大多数编译系统在宏展开之后才会报错，这样会增加排错的难度。
8、尽量少用全局变量，多用局部变量。
因为全局变量是放在数据存储器中，定义一个全局变量，MCU就少一个可以利用的数据存储器空间，如果定义了太多的全局变量，会导致编译器无足够的内存可以分配。而局部变量大多定位于MCU内部的寄存器中，在绝大多数MCU中，使用寄存器操作速度比数据存储器快，指令也更多更灵活，有利于生成质量更高的代码，而且局部变量所的占用的寄存器和数据存储器在不同的模块中可以重复利用。
9、设定合适的编译程序选项
许多编译程序有几种不同的优化选项，在使用前应理解各优化选项的含义，然后选用最合适的一种优化方式。通常情况下一旦选用最高级优化，编译程序会近乎病态地追求代码优化，可能会影响程序的正确性，导致程序运行出错。因此应熟悉所使用的编译器，应知道哪些参数在优化时会受到影响，哪些参数不会受到影响。
在ICCAVR中，有“Default”和“Enable Code Compression”两个优化选项。
在CodeVisionAVR中，“Tiny”和“small”两种内存模式。
在IAR中，共有7种不同的内存模式选项。
在GCCAVR中优化选项更多，一不小心更容易选到不恰当的选项。
二、代码的优化
1、选择合适的算法和数据结构
应该熟悉算法语言，知道各种算法的优缺点，具体资料请参见相应的参考资料，有很多计算机书籍上都有介绍。将比较慢的顺序查找法用较快的二分查找或乱序查找法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大提高程序执行的效率。.选择一种合适的数据结构也很重要，比如你在一堆随机存放的数中使用了大量的插入和删除指令，那使用链表要快得多。
数组与指针语句具有十分密码的关系，一般来说，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。但是在Keil中则相反，使用数组比使用的指针生成的代码更短。。
3、使用尽量小的数据类型
能够使用字符型(char)定义的变量，就不要使用整型(int)变量来定义；能够使用整型变量定义的变量就不要用长整型(long int)，能不使用浮点型(float)变量就不要使用浮点型变量。当然，在定义变量后不要超过变量的作用范围，如果超过变量的范围赋值，C编译器并不报错，但程序运行结果却错了，而且这样的错误很难发现。
在ICCAVR中，可以在Options中设定使用printf参数，尽量使用基本型参数(%c、%d、%x、%X、%u和%s格式说明符)，少用长整型参数(%ld、%lu、%lx和%lX格式说明符)，至于浮点型的参数(%f)则尽量不要使用，其它C编译器也一样。在其它条件不变的情况下，使用%f参数，会使生成的代码的数量增加很多，执行速度降低。
4、使用自加、自减指令
通常使用自加、自减指令和复合赋值表达式(如a-=1及a+=1等)都能够生成高质量的程序代码，编译器通常都能够生成inc和dec之类的指令，而使用a=a+1或a=a-1之类的指令，有很多C编译器都会生成二到三个字节的指令。在AVR单片适用的ICCAVR、GCCAVR、IAR等C编译器以上几种书写方式生成的代码是一样的，也能够生成高质量的inc和dec之类的的代码。
5、减少运算的强度
可以使用运算量小但功能相同的表达式替换原来复杂的的表达式。如下：
(1)、求余运算。
a=a%8;
可以改为：
a=a&7;
说明：位操作只需一个指令周期即可完成，而大部分的C编译器的“%”运算均是调用子程序来完成，代码长、执行速度慢。通常，只要求是求2n方的余数，均可使用位操作的方法来代替。
(2)、平方运算
a=pow(a,2.0);
可以改为：
a=a*a;
说明：在有内置硬件乘法器的单片机中(如51系列)，乘法运算比求平方运算快得多，因为浮点数的求平方是通过调用子程序来实现的，在自带硬件乘法器的AVR单片机中，如ATMega163中，乘法运算只需2个时钟周期就可以完成。既使是在没有内置硬件乘法器的AVR单片机中，乘法运算的子程序比平方运算的子程序代码短，执行速度快。
如果是求3次方，如：
a=pow(a,3.0);
更改为：
a=a*a*a；
则效率的改善更明显。
(3)、用移位实现乘除法运算
a=a*4;
b=b/4;
可以改为：
a=a<<2;
b=b>>2;
说明：通常如果需要乘以或除以2n，都可以用移位的方法代替。在ICCAVR中，如果乘以2n，都可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法子程序。用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，均可以用移位的方法得到结果，如：
a=a*9
可以改为：
a=(a<<3)+a
6、循环
(1)、循环语
对于一些不需要循环变量参加运算的任务可以把它们放到循环外面，这里的任务包括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行多次的操作全部集合在一起，放到一个init的初始化程序中进行。
(2)、延时函数：
通常使用的延时函数均采用自加的形式：
void delay (void)
{
unsigned int i;
for (i=0;i<1000;i++)
;
}
将其改为自减延时函数：
void delay (void)
{
unsigned int i;
for (i=1000;i>0;i--)
;
}
两个函数的延时效果相似，但几乎所有的C编译对后一种函数生成的代码均比前一种代码少1~3个字节，因为几乎所有的MCU均有为0转移的指令，采用后一种方式能够生成这类指令。
在使用while循环时也一样，使用自减指令控制循环会比使用自加指令控制循环生成的代码更少1~3个字母。
但是在循环中有通过循环变量“i”读写数组的指令时，使用预减循环时有可能使数组超界，要引起注意。
(3)while循环和do…while循环
用while循环时有以下两种循环形式：
unsigned int i;
i=0;
while (i<1000)
{
i++;
//用户程序
}
或：
unsigned int i;
i=1000;
do
i--;
//用户程序
while (i>0);
在这两种循环中，使用do…while循环编译后生成的代码的长度短于while循环。
7、查表
在程序中一般不进行非常复杂的运算，如浮点数的乘除及开方等，以及一些复杂的数学模型的插补运算，对这些即消耗时间又消费资源的运算，应尽量使用查表的方式，并且将数据表置于程序存储区。如果直接生成所需的表比较困难，也尽量在启动时先计算，然后在数据存储器中生成所需的表，后以在程序运行直接查表就可以了，减少了程序执行过程中重复计算的工作量。
C. 关系代数表达式的优化策略中，首先要做的是
关系代数表达式的优化策略中，首先要做的是：尽早执行选择运算。
关系代数是关系数据库系统查宏稿让询语言的理论基础。
一、关系代数的9种操作：
关系代数中包括了：并、交、差、乘、选择、投影、联接、除、自然敬裤联接等操作。
五个基本操作：
并(∪)、差(-)、笛卡尔积(×)、投影(σ)、选择(π)
四个组合操作：
交(∩)、联接(等值联接)、自然联接(RS)、除法(÷)
注意：等值连接表示先做笛卡尔积(×)之后，对相应列蔽局进行选择或等值关联后的结果(仅筛选行、不筛选列)
注2：自然连接表示两个关系中若有相同名称的属性，则自动作为关联条件，且仅列出一列
二、关系代数表达式：
由关系代数运算经有限次复合而成的式子称为关系代数表达式。这种表达式的运算结果仍然是一个关系。可以用关系代数表达式表示对数据库的查询和更新操作。
三、关系代数表达式的优化：
目的：为了系统在执行时既省时间又能提高效率。
基本策略：先做选择，运用投影去除多余属性等等。
优化算法：语法树(尽量提前做选择操作；在每个操作后，应做个投影操作，去掉不用的属性值)。
例如：
π SNO,SNAME(σGRADE>60(SSC)) 进行优化后转换为：
π SNO,SNAME(πSNO,SNAME(S)πSNO(σGRADE>60(SC)))
--即提前做选择操作；在每个操作后，应做个投影操作，去掉不用的属性值。
关键词：正则表达式 | 缓存 | 性能优亩滑尺化
Python 3 的 re 库中，对正则表达式的编译函数 re.compile() 调用了私有函数 re._compile() ，但更根本上编译的计算是由 sre_compile.compile() 完成的，而 re._compile() 中对编译好的表达式进行了缓存，使用 _MAXCACHE 将缓存迅高大小硬编码为512。以下是 re._compile() 的源码，摘自： https://github.com/python/cpython/blob/3.5/Lib/re.py (3.6，3.7里也没有变化)
在某些 大规模应用场景 下，512的缓存显然太小了一些，为了摆脱这个瓶颈但不去碰cpython的源码，我们可以自己改写 re._compile() ，从而实现自定义缓存大小（ max_regex_cache ），轻松排个10000出来。原函数里很多语句都不知道干嘛用的，但照葫芦画瓢总没错。
调用方法：
进一步优化是将这让虚个类变成Singleton（之后我应该会专门写一篇），以及 多模块共享 。
E. 为什么要对关系代数表达式进行优化
关系代数表达式由关系代数操作组合而成。操作中，以笛卡尔积和联接操作最费时，御册并生成大量的中间结果。如果直接按表达式书写的顺序执行，必将花费很多时间，并生成游拆亩大量的中间结果，效率较低。在执行前，由DBMS的查询子系统先对关系代数表达式进行优化，尽可能先执神森行选择和投影操作，以便减少中间结果，并节省时间。
望采纳 谢谢
F. 如何优化单片机C语言代码 转
优化代码和优化速度实际上是一个予盾的统一，一般是优化了代码的尺寸，就会带来执行时间的增加，如果优化了程序的执行速度，通常会带来代码增加的副作用，很难鱼与熊掌兼得，只能在设计时掌握一个平衡点。 一、程序结构的优化 1、程序的书写结构虽然书写格式并不会影响生成的代码质量，但是在实际编写程序时还是应该尊循一定的书写规则，一个书写清晰、明了的程序，有利于以后的维护。在书写程序时，特别是对于While、for、do…while、if… elst、switch…case 等语句或这些语句嵌套组合时，应采用"缩格"的书写形式， 2、标识符程序中使用的用户标识链搏符除要遵循标识符的命名规则以外，一般不要用代数符号(如a、b、x1、y1)作为变量名，应选取具有相关含义的英文单词(或缩写)或汉语拼音作为标识符，以增加程序的可读性，如：count、 number1、red、work 等。 3、程序结构C 语言是一种高级程序设计语言，提供了十分完备的规范化流程控制结构。因此在采用C 语言设计单片机应用系统程序时，首先要注意尽可能采用结构化的程序设计方法，这样可使整个应用系统程序结构清晰，便于调试和维护。于一个较大的应用程序，通常将整个程序按功能分成若干个模块，不同模块完成不同的功能。各个模块可以分别编写，甚至还可以由不同的程序员编写，一般单个模块完成的功能较为简单，设计和调试也相对容易一些。在模唤迅 C 语言中，一个函数就可以认为是一个模块。所谓程序模块化，不仅是要将整个程序划分成若干个功能模块，更重要的是，还应该注意保持各个模块之间变量的相对独立性，即保持模块的独立性，尽量少使用全局变量等。对于一些常用的功能模块，还可以封装为一个应用程序库，以便需要时可以直接调用。但是在使用模块化时，如果将模块分成太细太小，又会导致程序的执行效率变低 (进入和退出一个函数时保护和恢复寄存器占用了一些时间)。 4、定义常数在程序化设计过程中，对于经常使用的一些常数，如果将它直接写到程序中去，一旦常数的数值发生变化，就必须逐个找出程序中所有的常数，并逐一进行修改，这样必然会降低程序的可维护性。因此，应尽量当采用预处理命令方式来定义常数，而且还可以避免输入错误。 5、减少判断语句能够使用条件编译(ifdef)的地方就使用条件编译而不使用if 语句，有利于减少编译生成的代码的长度。 6、表达式对于一个表达式中各种运算执行的优先顺序不太明确或容易混淆的地方，应当采用圆括号明确指定它们的优先顺序。一个表达式通常不能写得太复杂，如果表达式太复杂，时间久了以后，自己也不容易看得懂，不利于以后的维护。 7、函数对于程序中的函数，在使用之前，应对函数的类型进行说明，对函数类型的说明必须保证它与原来定义的函数类型一致，对于没有参数和没有返回值类型的函数应加上"void"说明。如果果需要缩短代码的长度，可以将程序中一些公共的程序段定义为函数，在Keil 中的高级别优化就是这样的。如果需要缩短程序的执行时间，在程序调试结束后，将部分函数用宏定义来代替。注意，应该在程序调试结束后再定义宏，因为大多数编译系统在宏展开之后才会报错，这样会增加排错的难度。 8、尽量少用全局变量，多用局部变量。因为全局变量是放在数据存储器中，定义一个全局变量，MCU 就少一个可以利用的数据存储器空间，如果定义了太多的全局变量，会导致编译器无足够的内存可以分配。而局部变量大多定位于 MCU 内部的寄存器中，在绝大多数MCU 中，使用寄存器操作速度比数据存储器快，指令也更多更灵活，有利于生成质量更高的代码，而且局部变量所的占用的寄存器和数据存储器在不同的模块中可以重复利用。 9、设定合适的编译程序选项许多编译程序有几种不同的优化选项，在使用前应理解各优化选项的含义，然后选用最合适的一种优化方式。通常情况下一旦旦此选用最高级优化，编译程序会近乎病态地追求代码优化，可能会影响程序的正确性，导致程序运行出错。因此应熟悉所使用的编译器，应知道哪些参数在优化时会受到影响，哪些参数不会受到影响。在ICCAVR 中，有"Default"和 "Enable Code Compression"两个优化选项。在CodeVisionAVR 中，"Tiny"和 "small"两种内存模式。在IAR==有7 种不同的内存模式选项。在GCCAVR 中优化选项更多，一不小心更容易选到不恰当的选项。 二、代码的优化1、选择合适的算法和数据结构应该熟悉算法语言，知道各种算法的优缺点，具体资料请参见相应的参考资料，有很多计算机书籍上都有介绍。将比较慢的顺序查找法用较快的二分查找或乱序查找法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大提高程序执行的效率。.选择一种合适的数据结构也很重要，比如你在一堆随机存放的数中使用了大量的插入和删除指令，那使用链表要快得多。数组与指针具有十分密码的关系，一般来说，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。但是在Keil 中则相反，使用数组比使用的指针生成的代码更短。 2、使用尽量小的数据类型能够使用字符型(char)定义的变量，就不要使用整型(int)变量来定义；能够使用整型变量定义的变量就不要用长整型(long int)，能不使用浮点型(float)变量就不要使用浮点型变量。当然，在定义变量后不要超过变量的作用范围，如果超过变量的范围赋值，C 编译器并不报错，但程序运行结果却错了，而且这样的错误很难发现。在ICCAVR 中，可以在 Options 中设定使用printf 参数，尽量使用基本型参数(%c、%d、%x、%X、%u 和%s 格式说明符)，少用长整型参数(%ld、%lu、%lx 和%lX 格式说明符)，至于浮点型的参数(%f)则尽量不要使用，其它C 编译器也一样。在其它条件不变的情况下，使用%f 参数，会使生成的代码的数量增加很多，执行速度降低。 3、使用自加、自减指令通常使用自加、自减指令和复合赋值表达式(如a- =1 及a+=1 等)都能够生成高质量的程序代码，编译器通常都能够生成inc 和 dec 之类的指令，而使用a=a+1 或a=a-1 之类的指令，有很多C 编译器都会生成二到三个字节的指令。在AVR 单片适用的ICCAVR、GCCAVR、IAR 等C 编译器以上几种书写方式生成的代码是一样的，也能够生成高质量的inc 和dec 之类的的代码。 4、减少运算的强度可以使用运算量小但功能相同的表达式替换原来复杂的的表达式。如下：(1)、求余运算。a=a%8；可以改为：a=a&7；说明：位操作只需一个指令周期即可完成，而大部分的C 编译器的"%"运算均是调用子程序来完成，代码长、执行速度慢。通常，只要求是求2n 方的余数，均可使用位操作的方法来代替。(2)、平方运算a=pow(a,2.0)；可以改为：a=a*a；说明：在有内置硬件乘法器的单片机中(如51 系列)，乘法运算比求平方运算快得多，因为浮点数的求平方是通过调用子程序来实现的，在自带硬件乘法器的 AVR 单片机中，如ATMega163 中，乘法运算只需2 个时钟周期就可以完成。既使是在没有内置硬件乘法器的AVR 单片机中，乘法运算的子程序比平方运算的子程序代码短，执行速度快。如果是求3 次方，如：a=pow(a,3.0)；更改为：a=a*a*a；则效率的改善更明显。(3)、用移位实现乘除法运算 a=a*4；b=b/4；可以改为：a=a 2； b=b 2；说明：通常如果需要乘以或除以2n，都可以用移位的方法代替。在 ICCAVR 中，如果乘以2n，都可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法子程序。用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，均可以用移位的方法得到结果，如：a=a*9 可以改为：a=(a 3)+a 5、循环(1)、循环语对于一些不需要循环变量参加运算的任务可以把它们放到循环外面，这里的任务包括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行多次的操作全部集合在一起，放到一个init 的初始化程序中进行。(2)、延时函数：通常使用的延时函数均采用自加的形式：void delay(void){unsigned int i；for(i=0；i 1000；i++)；}将其改为自减延时函数：void delay(void){unsigned int i； for(i=1000；i 0；i--)；}两个函数的延时效果相似，但几乎所有的C 编译对后一种函数生成的代码均比前一种代码少1~3 个字节，因为几乎所有的MCU 均有为0 转移的指令，采用后一种方式能够生成这类指令。在使用while 循环时也一样，使用自减指令控制循环会比使用自加指令控制循环生成的代码更少 1~3 个字母。但是在循环中有通过循环变量"i"读写数组的指令时，使用预减循环时有可能使数组超界，要引起注意。(3)while 循环和do…while 循环用 while 循环时有以下两种循环形式：unsigned int i；i=0；while(i 1000){i++；//用户程序}或：unsigned int i；i=1000；do i--；//用户程序 while(i 0)；在这两种循环中，使用do…while 循环编译后生成的代码的长度短于while 循环。6、查表在程序中一般不进行非常复杂的运算，如浮点数的乘除及开方等，以及一些复杂的数学模型的插补运算，对这些即消耗时间又消费资源的运算，应尽量使用查表的方式，并且将数据表置于程序存储区。如果直接生成所需的表比较困难，也尽量在启动时先计算，然后在数据存储器中生成所需的表，后以在程序运行直接查表就可以了，减少了程序执行过程中重复计算的工作量。7、其它比如使用在线汇编及将字符串和一些常量保存在程序存储器中，均有利于优化。
G. 在C++中，进行逻辑运算时，为什么要对逻辑表达式进行优化
那样不就可以脊空简化计算量了吗。如果樱芹瞎出现在循环中，那减少的运算量将首颤是非常巨大的。
有这样的规定？
H. javashort怎么-1
注：如未特别说明，Java语言规范 jls 均基于JDK8，使用环境是 eclipse4.5 + win10 + JDK 8
本篇的知识点，主要是涉及到 Java 中一些比较答橡雹常见的默认窄化处理(Java编译器自动添加的)，这里将从一个问题开始，据说这也是一道常见的笔试题/面试题：
为什么 short i = 1; i += 1; 可以正确编译运行而 short i = 1; i = i + 1; 会出现编译错误？
其他说法：都放在一起编译会出现有什么结果，哪一行报错？为什么？
笔者注：其实这其中会涉及到一些编译优化和底层的知识，限于知识面，本篇不涉及，如有需要，可自行搜索。
本文的目录结构如下：
1、结论
关于开篇提出的问题，这里先直接给出结论：
Java语言规范规定基础数据类型运算默认使用32位精度的int类型
只要是对基本类型做窄化处理的，例如 long -> int -> short -> char，都需要做强制转换，有些是Java编译器默认添加的，有的则是代码中显式做强制转换的。
short i = 1; i += 1;可以正确编译运行是因为Java编译器自己添加了强制窄化处理，即对于任何的T a; X b; a += b;等价于T a; X b; a = (T) (a + b);Java编译器会默认做这个显式强制转换(尽管有时候会出现精度问题，例如 b 是 float 、 double 类型，强烈建议不要有这样的操作)。前面的i += 1其实就等价于i = (int) (i + 1)，即便将数字1换成是double类型的1.0D也是如此。
short i = 1; i = i + 1;编译不通过的原因就很明显了：无论是代码中，还是Java编译器，都没有做强制转换，int 类型直接赋给 short ，因此编译出错。
对于常量(数字常量、常量表达式、final常量等)，Java编译器同样也可以做默认的强制类型转换，只要常量在对应清帆的数据范围内即可。
2、详如歼解
接下来讲详细分析为什么 short i = 1; i += 1; 可以正确编译而 short i = 1; i = i + 1; 则会编译失败。先列一下搜出来的一些令人眼前一亮(or 困惑)的代码
public static voidmain(String[] args) {//注:short ∈ [-32768, 32767]
{/** 1、对于 +=, -=, *=, /=, Java编译器默认会添加强制类型转换，
* 即 T a; X b; a += b; 等价于 T a; X b; a = (T) (a + b);*/
//0是int类型的常量，且在short范围内，被Java编译器默认强制转换的
short i = 0;
i+= 1; //等价于 i = (short) (i + 1);
System.out.println("[xin01] i=" + i); //输出结果: 1
i = (short) (i + 1);
System.out.println("[xin02] i=" + i); //输出结果: 2
/** 下面这2行都会有编译报错提示：
* Exception in thread "main" java.lang.Error: Unresolved compilation problem:
* Type mismatch: cannot convert from int to short
* [注]错误: 不兼容的类型: 从int转换到short可能会有损失
* Eclipse 也会有提示： Type mismatch: cannot convert from int to short*/
//i = i + 1;//i = 32768;
i= 0;
i+= 32768; //等价于 i = (short) (i + 32768); 下同
System.out.println("[xin03] i=" + i); //输出结果: -32768
i += -32768;
System.out.println("[xin04] i=" + i); //输出结果: 0
i= 0;long j = 32768;
i+=j;
System.out.println("[xin05] i=" + i); //输出结果: -32768
i= 0;float f = 1.23F;
i+=f;
System.out.println("[xin06] i=" + i); //(小数位截断)输出结果: 1
i= 0;double d = 4.56D;
i+=d;
System.out.println("[xin07] i=" + i); //(小数位截断)输出结果: 4
i= 10;
i*= 3.14D;
System.out.println("[xin08] i=" + i); //输出结果: 31
i= 100;
i/= 2.5D;
System.out.println("[xin09] i=" + i); //输出结果: 40
}
{/** 2、常量表达式和编译器优化: 常量折叠*/
//2 * 16383 = 32766//(-2) * 16384 = -32768//都在 short 范围内，常量表达式在编译优化后直接用对应的常量结果，然后编译器做强制转换
short i = 2 * 16383; //等价于 short i = (short) (2 * 16383);
short j = (-2) * 16384;//2 * 16384 = 32768,超过 short 范围，编译器不会做转换//Type mismatch: cannot convert from int to short//short k = 2 * 16384;//常量表达式在编译优化后直接用对应的常量结果，然后编译器做强制转换
short cThirty = 3 * 10;short three = 3;short ten = 10;//Type mismatch: cannot convert from int to short//short thirty = three * ten;
final short fTthree = 3;final short fTen = 10;//常量表达式在编译优化后直接用对应的常量结果，然后编译器做强制转换
short fThirty = fTthree *fTen;final short a = 16384;final short b = 16383;//常量表达式在编译优化后直接用对应的常量结果，然后编译器做强制转换
short c = a +b;
}
}
接下来根据代码罗列的两部分分别进行说明：
2.1、对于 +=, -=, *=, /=, Java编译器默认会添加强制类型转换，即 T a; X b; a += b; 等价于 T a; X b; a = (T) (a + b);
A compound assignment expression of the formE1 op= E2is equivalent toE1 = (T) ((E1) op (E2)), whereTis the type ofE1, except thatE1is evaluated only once.
For example, the following code is correct:
short x = 3;
x+= 4.6;
and results in x having the value 7 because it is equivalent to:
short x = 3;
x= (short)(x + 4.6);
笔者注：
实际上，直接加上强制类型转换的写法，也是大家都熟悉且理解起来最清晰的方式，可以避免可能潜在的类型不匹配时出现的精度损失问题，使用的时候需要注意。当然，笔者认为这些方式都没有好坏之分，正确地使用即可。
Java从语言规范层面对此做了限制。有兴趣的还可以通过 class文件和 javap -c 反汇编对所使用的字节码作进一步的研究。
知道了Java语言相关的规范约定，我们就可以看出，与之对应的是以下这种出现编译错误的写法(报错提示：Type mismatch: cannot convert from int to short)：
short i = 1;//i + 1 是 int 类型，需要强制向下类型转换
i = i + 1;
2.2、常量表达式和编译器优化: 常量折叠
需要注意的是，前面的示例short x = 3;中的3其实默认是 int 类型，但是却可以赋值给short类型的x。这里涉及到到的其实是 常量表达式。
In addition, if the expression is a constant expression (
A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the variable.
A narrowing primitive conversion followed by a boxing conversion may be used if the type of the variable is:
Byte and the value of the constant expression is representable in the type byte.
Short and the value of the constant expression is representable in the type short.
Character and the value of the constant expression is representable in the type char.
对于常量表达式，其结果是可以自动做窄化处理的，只要是在对应的数据类型范围内，Java编译器就进行做默认强制类型转换。
Some expressions have a value that can be determined at compile time. These are constant expressions (
true(short)(1*2*3*4*5*6)
Integer.MAX_VALUE/ 2
2.0 *Math.PI"The integer " + Long.MAX_VALUE + " is mighty big."
A constant variable is a final variable of primitive type or type String that is initialized with a constant expression (
通过常量表达式赋值的final变量都是常量，这种也是编译期可以确认最终值，会通过编译优化直接赋予最终值，而且可以直接依靠编译器做窄化处理。
对于这一块，其实对应的是一个比较基础的编译器优化：常量折叠(Constant Folding)，有兴趣的可以自行搜索。stackoverflow 上由相关的讨论，参考[9]、[10]、[11]
笔者注：
尽管常量表达式最终都被编译器优化为直接值，但是为了清晰，提高可读性、可维护性，代码中没必要对常量直接换算，例如一天 24 * 60 * 60 秒，其实可以分别用可读性更强的final常量来表示。
Bloch大神的 Java Puzzlers 中也有相关的一些说明，有兴趣的可以去看看
I. 关于c语言逻辑表达式的问题，求高手啊
c语言中，为了加快编译速度，有一条这样的规定，当一个逻辑表达式的值能够确定下来的时候，它不会执行下面的语句。
例如：a && b这个表达式，如果a为假，则 a&&b一定为假，不管迅前b为真，还是假，也就是a等于假亮尘时，这个表达式的值已经确定了。所以b不会执行了。但，如果a为真，则 a&&b的值就确定不了，因为b若为假，则表达式为假，b为真，表达式为真，所以还需要判断b的真假，所以b会执行。
++ix 结果为2，为真。敬昌禅
++iy 结果为2，为真
所以++ix&&++iy 为真， 因为 ||有一个为真，就为真，所以 ++iz不会执行，因为已经得出前面为真了。
J. 一个正则表达式优化
优化结果就是a
原因是正则表达式的机制是“急于表功”即悄渗懒惰的，右侧其它4个表达式由于都包括a在内，因此即使在匹配时有符合ab或abc……的字符串，正则引擎在查找时都需要第一个先找到a，启好脊再找b，再袜明找c，可是在找到a以后就已经匹配了第一个可选路径a，此时正则引擎急于表功，立即返回结果，所以后面4个可选路径其实都废掉了，永远轮不到它们。优化下来就是a。
估计这是一道考题吧？实际应用中不会遇到这种正则式的，都会由长至短写成abcde|abcd|abc|ab|a