Java“坑爹”的10大功能点

作为一门面向对象的编程语言，Java凭借其简单易用、功能强大的特点受到了广大编程爱好者的青睐，伴随着开源社区的推波助澜，Java语言更是席卷全球，势不可挡，在世界各地都有Java技术的从业者，它也常年高居编程语言排行榜的首位，足以表明Java的强悍与王者之风。

创新互联建站网站建设公司是一家服务多年做网站建设策划设计制作的公司,为广大用户提供了成都网站设计、成都做网站、外贸网站建设，成都网站设计，1元广告，成都做网站选创新互联建站，贴合企业需求，高性价比，满足客户不同层次的需求一站式服务欢迎致电。

然而，即便是如此强大的编程语言，也有很多“坑爹”的功能，稍不注意，我们就会掉入坑里，轻则遭到同事的嘲笑和鄙视，重则造成悲惨后果而不得不跑路。

当然，坑爹这个词加上了双引号，因为大部分时候，都是由于我们不够熟练、违反我们的常识才造成了令人不愉快的后果。

今天我们就来梳理一下Java中最“坑爹”、最违反常识的功能点，以排行榜的方式发布，以飨读者。说明一下，本文中的代码基于JDK8来编译实现。

1、switch必须加上break才结束

对于多重分支选择，一系列的if-else-if语句会让代码的可读性变差，建议使用switch语句来代替，然而switch case中的分支判断，必须加上break语句才会中止其它case的执行，比如：

 
 
 
 
      
  
  
  
  1. int count = 1;    
    2.   
  
  
  
  2. switch(count){    
    3.   
  
  
  
  3.     case 1:    
    4.   
  
  
  
  4.         System.out.println("one");    
    5.   
  
  
  
  5.     case 2:    
    6.   
  
  
  
  6.         System.out.println("two");    
    7.   
  
  
  
  7.     case 3:    
    8.   
  
  
  
  8.         System.out.println("three");   
    9.   
  
  
  
  9. }   
    10.

上面的代码会输出：

 
 
 
 
      
  
  
  
  1. one    
    2.   
  
  
  
  2. two    
    3.   
  
  
  
  3. three   
    4.

然而，这并不是我们想要的，或者说违反了我们的常识。满足了某种条件，当然就只需要执行这种条件下的逻辑即可，其他的case应该不予理会、直接跳过，象上面这段代码，只需要输出one就行了。

当然，在每个case结尾处加上break就可以达到我们期望的效果。Java 12 骚 switch 居然还能这样玩，推荐看下这篇。

这个功能点稍显“坑爹”，也是初学者常犯的错误，所以它也光荣上榜，排名第10位。

2、逻辑运算符的“短路”现象

使用逻辑运算符时，我们会遇到“短路”的现象：一旦能够确定整个表达式的值，就不会计算余下的部分了，当然，这个功能点其实是非常有用的，但对于初学者来说，可能会感觉比较惊讶，使用不当就会产生“坑爹”后果。比如下面的代码：

 
 
 
 
      
  
  
  
  1. int num = 1;    
    2.   
  
  
  
  2. System.out.println(false && ((num++)==1));    
    3.   
  
  
  
  3. System.out.println(num);   
    4.

就会输出false和1，因为逻辑与&&的前半部分为false，不管后半部分为true还是false，整个表达式都会返回false，所以就不会再计算后面的部分了，如果把false改成true，那么后半部分就会得到执行，num也就变成2了。

它在“坑爹”榜单中位列第9位。

3、数组下标从零开始

Java程序员都清楚，数组的下标是从零开始的，比如，我们要遍历一个数组，可以采用如下的方式：

 
 
 
 
      
  
  
  
  1. int[] arr = new int[]{1,3,5,7,9};    
    2.   
  
  
  
  2. for(int i=0;i  
  
  
  
  3. System.out.println("the element is:"+arr[i]);    
    4.   
  
  
  
  4. } 
    5.

这跟我们日常生活中的经验是相违背的，正常情况都是从第1个元素开始计数的，特别是对于初学者来说有点难以接受，会觉得很惊讶。即使对于经验丰富的程序员来说，有些地方也需要格外注意，比如：

 
 
 
 
      
  
  
  
  1. String str = "hello world";    
    2.   
  
  
  
  2. System.out.println(str.charAt(1)); 
    3.

我们知道，charAt的作用是获取字符串中某个位置的字符，然而，上面的代码并不是输出第一个字符h，而是e，因为数组是从零开始计数的，这个也是比较“坑爹”啊。当然，设计者这么做的原因是考虑到了内存偏移量的因素。

每次在编写这样的代码时，都需要做这样的1到0的映射和转换（熟练了就是下意识的转换），确实也有点“坑爹”，所以它也不能幸免，排在第8位。

4、ArrayList遍历删除时报错

Talk is cheap，先上代码：

 
 
 
 
      
  
  
  
  1. public static void main(String[] args) {    
    2.   
  
  
  
  2.    List list = new ArrayList();    
    3.   
  
  
  
  3.    list.add("abc");    
    4.   
  
  
  
  4.    list.add("bc");    
    5.   
  
  
  
  5.    list.add("bc");    
    6.   
  
  
  
  6.    list.add("abcd");    
    7.   
  
  
  
  7.    list.add("abcdef");    
    8.   
  
  
  
  8.    //报错    
    9.   
  
  
  
  9.    int length = list.size();    
    10.   
  
  
  
  10.    for(int i = 0;i < length;i++){    
    11.   
  
  
  
  11.        if(list.get(i).equals("bc")){    
    12.   
  
  
  
  12.            list.remove(i);    
    13.   
  
  
  
  13.        }    
    14.   
  
  
  
  14.    }    
    15.   
  
  
  
  15. } 
    16.

想从ArrayList中删除某个元素，于是，我们就写了上面的代码，但是它却抛出了IndexOutOfBoundsException异常，原因是ArrayList在删除元素后会重新计算数量，把list.size放在for循环中即可：

 
 
 
 
      
  
  
  
  1. for(int i=0;i  
  
  
  
  2.    if(list.get(i).equals("bc")){    
    3.   
  
  
  
  3.        list.remove(i);    
    4.   
  
  
  
  4.    }    
    5.   
  
  
  
  5. } 
    6.

当然，这种方法也存在问题，建议使用迭代器的方式来删除元素。ArrayList 增删千万不要乱用…推荐看一下这篇。

对于不太熟练的程序员来说，有时候就会掉入这样的陷阱之中。这是排名第7的情况。关注微信公众号：Java技术栈，在后台回复：Java，可以获取我整理的 N 篇 Java 教程，都是干货。

5、字符转成数字的坑

有时候，我们想把字符直接通过类型转换变成整数，比如像下面这样：

 
 
 
 
      
  
  
  
  1. char symbol = '8';    
    2.   
  
  
  
  2. System.out.println((int) symbol);   
    3.

我们想要的结果是8，然而，上面的代码却输出了56，略显“坑爹”，具体原因参考ASCII的知识。

6、while循环体的“障眼法”

对于while循环语句，如果你没有加上大括号，即使后面的语句挨在一起，也只会执行第一条statement，比如：

 
 
 
 
      
  
  
  
  1. int i = 0;    
    2.   
  
  
  
  2. while(i++<3)    
    3.   
  
  
  
  3.     System.out.print("A");    
    4.   
  
  
  
  4.     System.out.print("B"); 
    5.

上面的代码会输出：

 
 
 
 
      
  
  
  
  1. AAAB   
    2.

而不是3个A、3个B，更“坑爹”的是，如果两条语句放在一行上，迷惑性会更大：

 
 
 
 
      
  
  
  
  1. int i = 0;    
    2.   
  
  
  
  2. while(i++<3)    
    3.   
  
  
  
  3.     System.out.print("A");System.out.print("B"); 
    4.

上面这种写法同样是输出AAAB。所以，象这样的情况，哪怕只有一条语句，也建议加上大括号，完美避坑。

7、Integer类有缓存

这个功能点也是面试的高频热点之一，稍不注意，也有可能被带入沟里，我们看看下面这段代码：

 
 
 
 
      
  
  
  
  1. public static void main(String[] args){    
    2.   
  
  
  
  2.    Integer a = 100;    
    3.   
  
  
  
  3.    Integer b = 100;    
    4.   
  
  
  
  4.    Integer c = 200;    
    5.   
  
  
  
  5.    Integer d = 200;    
    6.   
  
  
  
  6.    System.out.println(a==b);    
    7.   
  
  
  
  7.    System.out.println(c==d);    
    8.   
  
  
  
  8. }   
    9.

上面的代码竟然输出：

 
 
 
 
      
  
  
  
  1. true    
    2.   
  
  
  
  2. false   
    3.

这确实太出乎意料了，同样的代码，只是数值不同（而且差别不太大的样子），就产生了不一样的输出，这也太离谱了。

原来，Integer中有一个静态内部类IntegerCache，在类加载的时候，它会把[-128, 127]之间的值缓存起来，而Integer a = 100这样的赋值方式，会首先调用Integer类中的静态valueOf方法，这个方法会尝试从缓存里取值，如果在这个范围之内就不用重新new一个对象了：

 
 
 
 
      
  
  
  
  1. public static Integer valueOf(int i) {    
    2.   
  
  
  
  2.    if (i >= IntegerCache.low && i <= IntegerCache.high)    
    3.   
  
  
  
  3.        return IntegerCache.cache[i + (-IntegerCache.low)];   
    4.   
  
  
  
  4.    return new Integer(i);    
    5.   
  
  
  
  5. }   
    6.

此功能入选“坑爹”排行榜的第4名。IntegerCache的妙用和陷阱，推荐看一下。

8、空方法体导致死循环

如果循环的方法体为空，则会导致死循环，比如，下面的代码打印出数字1，2，3：

 
 
 
 
      
  
  
  
  1. int i = 1;    
    2.   
  
  
  
  2. while(i<4){    
    3.   
  
  
  
  3.    System.out.println(i++);    
    4.   
  
  
  
  4. }   
    5.

如果你在敲键盘的时候，不小心在while结尾处加了一个分号（如果方法体没有加大括号，更容易产生这种情况）：

 
 
 
 
      
  
  
  
  1. int i = 1;    
    2.   
  
  
  
  2. while(i<4);{    
    3.   
  
  
  
  3.    System.out.println(i++);    
    4.   
  
  
  
  4. }   
    5.

你猜怎么着，上面的代码可以正常编译并运行，然而，它却陷入了死循环……是不是非常“坑爹”？for循环也存在类似的情况。

它高居排行榜的第3位。

9、神奇的=+

我们知道，对于类似a=a+b这样的赋值语句，有一种简写方式：a +=b，然而，如果你不小心写成了a =+ b，结果又会是什么呢？我们看看下面的代码：

 
 
 
 
      
  
  
  
  1. int i = 100;    
    2.   
  
  
  
  2. i =+ 2;  //注意，加号在后面    
    3.   
  
  
  
  3. System.out.println(i);   
    4.

上面的代码既不会输出102，也不会报错，而是输出2，这的确出乎意料，完全不是我们期望的结果，太神奇了，非常的“坑爹”。

所以，它排名第2，稳居榜眼的位置。

10、Java注释能够识别Unicode

先看看代码：

 
 
 
 
      
  
  
  
  1. public static void main(String[] args){    
    2.   
  
  
  
  2.     // \\u000d System.out.println("Hello World!");    
    3.   
  
  
  
  3. }   
    4.

乍一看，代码都被注释掉了，当然不会输出任何东西，然而，它还是输出每个程序员都倍感亲切的Hello World，这是因为，unicode解码发生在代码编译之前，编译器将\u样式的代码进行文本转义，即使是注释也是这样，然后\u000a被转换成\n换行符，所以println代码得以正常执行。

这样的功能着实“坑爹”，极其违反常识，它必须要上榜，必须要荣登状元的位置。

标题名称：Java“坑爹”的10大功能点
本文地址：http://www.shufengxianlan.com/qtweb/news32/507182.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

服务器托管知识

行业网站建设

网站seo优化　　 　成都棕树机房　　 　网络口碑营销　　 　商标注册　　 　成都申请ssl证书　　 　绵阳电信机房　　 　名片设计　　 　成都网站安全运维　　 　云南护栏打桩机　　 　南充护栏钻孔机　　 　网站维护报价　　 　虚拟主机　　 　百度推广公司　　 　南京护栏钻孔机　　 　友益建筑机械凿　　 　温江网站设计　　 　网站seo优化　　 　江安网站建设　　 　邛崃网站建设　　 　手机网站制作