Java程序员容易犯的10大低级错误

最新推荐文章于 2023-03-03 11:44:47 发布
最新推荐文章于 2023-03-03 11:44:47 发布
阅读量3.8k 收藏 3
点赞数
分类专栏： Java SE 文章标签： java string integer list null equals
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fwwdn/article/details/7495528
版权

本文根据java开发人员在编码过程中容易忽视或经常出错的地方进行了整理，总结了十个比较常见的低级错误点，方便大家学习。

1、不能用“==”比较两个字符串内容相等。

2、 对list做foreach循环时，循环代码中不能修改list的结构。

3、 日志和实际情况不一致；捕获异常后没有在日志中记录异常栈。

4、 魔鬼数字。

5、 空指针异常。

6、 数组下标越界。

7、 将字符串转换为数字时没有捕获NumberFormatException异常。

8、 对文件、IO、数据库等资源进行操作后没有及时、正确进行释放。

9、 循环体编码时不考虑性能，循环体中包含不需要的重复逻辑。

10、数据类没有重载toString()方法。

1不能用“==”比较两个字符串内容相等。

解读

两个字符串在比较内容是否相等的时候，如果使用“==”，当两个字符串不是指向内存中同一地址，那么即使这两个字符串内容一样，但是用“==”比较出来的结果也是false。所以两个字符串在比较内容是否相等的时候一定要使用“equals”方法。

示例

下面就是一个字符串比较的例子：

publicclass Test {
    publicstaticvoid main(String[] args)
    {
       String a = new String("a");
       String a2 = "a";
       if(a == a2)
       {
           System.out.println("a == a2return true.");
       }
       else
       {
           System.out.println("a == a2 returnfalse.");
       }
      
       if(a.equals(a2))
       {
           System.out.println("a.equals(a2)return true.");
       }
       else
       {
           System.out.println("a.equals(a2)return false.");
       }
    }
}

最终输出的结果为：

a == a2 return false.

a.equals(a2) return true.

2   不能在foreach循环中修改list结构

解读

在jdk1.5版以上的foreach循环写法中，不能在循环代码中对正在循环的list的结构进行修改，即对list做add、remove等操作，如果做了这些操作，必须立即退出循环，否则会抛出异常。

示例

publicclass Test {
    publicstaticvoid main(String[] args)
    {
       List<Person> list = new ArrayList<Person>();
       Person p1 = new Person("张三", 23);
       Person p2 = new Person("李四", 26);
       Person p3 = new Person("王五", 34);
       Person p4 = new Person("刘二", 15);
       Person p5 = new Person("朱六", 40);
 
       list.add(p1);
       list.add(p2);
       list.add(p3);
       list.add(p4);
       list.add(p5);
       for(Person p : list)
       {
           if("王五".equals(p.getName()))
           {
              list.remove(p); // 不能在此时删除对象。
           }
elseif("李四".equals(p.getName()))
           {
              list.remove(p); // 不能在此时删除对象。
           }
       }
       System.out.println(list.size());
    }
}

class Person
{
    private String name;
    privateintage;
 
    public Person(String name, int age)
    {
       this.name = name;
       this.age = age;
    }

    public String getName()
    {
       returnname;
    }
 
    publicvoid setName(String name)
    {
       this.name = name;
    }
 
    publicint getAge()
    {
       returnage;
    }

    publicvoid setAge(int age)
    {
       this.age = age;
    }
}

解决上面代码红色部分的问题，可以通过循环取出对象，然后再循环结束后再进行删除。

       List<Person> list = new ArrayList<Person>();
       Person p1 = new Person(new String("张三"), 23);
       Person p2 = new Person(new String("李四"), 26);
       Person p3 = new Person(new String("王五"), 34);
       Person p4 = new Person(new String("刘二"), 15);
       Person p5 = new Person(new String("朱六"), 40);
 
       list.add(p1);
       list.add(p2);
       list.add(p3);
       list.add(p4);
       list.add(p5);

       Person wangwu = null;
       Person lisi = null;
       for(Person p : list)
       {
           if("王五".equals(p.getName()))
           {
              wangwu = p;
           }
           elseif("李四".equals(p.getName()))
           {
              lisi = p;
           }
       }
      
       list.remove(wangwu);
       list.remove(lisi);

3   日志规范性

解读

日志是定位问题时最重要的依据，业务流程中缺少必要的日志会给定位问题带来很多麻烦，甚至可能造成问题完全无法定位。

异常产生后，必须在日志中以ERROR或以上级别记录异常栈，否则会导致异常栈丢失，无法确认异常产生的位置。并不需要在每次捕获异常时都记录异常日志，这样可能导致异常被多次重复记录，影响问题的定位。但异常发生后其异常栈必须至少被记录一次。

和注释一样，日志也不是越多越好。无用的冗余日志不但不能帮助定位问题，还会干扰问题的定位。而错误的日志更是会误导问题，必须杜绝。

示例

下面的例子虽然打印了很多日志，但基本上都是无用的日志，难以帮助定位问题。甚至还有错误的日志会干扰问题的定位：

public voidsaveProduct1(ProductServiceStruct product)
{
    log.debug("enter method: addProduct()");
 
    log.debug("check product status");
    if(product.getProduct().getProductStatus() != ProductFieldEnum.ProductStatus.RELEASE)
    {
        thrownew PMSException(PMSErrorCode.Product.ADD_ERROR);
    }

    log.debug("check tariff");
    BooleanResult result =checkTariff(product.getTariffs());
    if(!result.getResult())
    {
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    log.debug("before add product");
    ProductService prodSrv = (ProductService)ServiceLocator.findService(ProductService.class);
    try
    {
        prodSrv.addProduct(product);
    }
    catch(BMEException e)
    {
        // 未记录异常栈，无法定位问题根源
    }

    log.debug("after add product");
    log.debug("exit method: updateProduct()");  // 错误的日志
}

而下面的例子日志打印的不多，但都是关键信息，可以很好的帮助定位问题：

public voidsaveProduct2(ProductServiceStruct product)
{
    if(product.getProduct().getProductStatus() != ProductFieldEnum.ProductStatus.RELEASE)
    {
        log.error(
                "productstatus "
                +product.getProduct().getProductStatus()
                + "error, expect " + ProductFieldEnum.ProductStatus.RELEASE);
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR);
    }

    BooleanResult result =checkTariff(product.getTariffs());
    if(!result.getResult())
    {
        log.error(
                "checkproduct tariff error "
                + result.getResultCode()
                + ":"
                + result.getResultDesc());
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR);
    }

    ProductService prodSrv = (ProductService)ServiceLocator.findService(ProductService.class);
    try
    {
        prodSrv.addProduct(product);
    }
    catch(BMEException e)
    {
        log.error("add product error", e);
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR,e);
    }
}

4   魔鬼数字

解读

在代码中使用魔鬼数字（没有具体含义的数字、字符串等）将会导致代码难以理解，应该将数字定义为名称有意义的常量。

将数字定义为常量的最终目的是为了使代码更容易理解，所以并不是只要将数字定义为常量就不是魔鬼数字了。如果常量的名称没有意义，无法帮助理解代码，同样是一种魔鬼数字。

在个别特殊情况下，将数字定义为常量反而会导致代码更难以理解，此时就不应该强求将数字定义为常量。

示例

public void addProduct(ProductServiceStruct product)
{
    // 魔鬼数字，无法理解3具体代表产品的什么状态
    if(product.getProduct().getProductStatus() != 3)
    {
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR);
    }

    BooleanResult result =checkTariff(product.getTariffs());
    if(!result.getResult())
    {
        thrownew PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
}
 
/**
*产品未激活状态
*/
privatestaticfinalintUNACTIVATED = 0;
/**
*产品已激活状态
*/
privatestaticfinalintACTIVATED = 1;

public voidaddProduct2(ProductServiceStruct product)
{
    if(product.getProduct().getProductStatus() != ACTIVATED)
    {
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR);
    }

    BooleanResult result =checkTariff(product.getTariffs());
    if(!result.getResult())
    {
        thrownewPMSException(PMSErrorCode.Product.ADD_ERROR);
    }
}

5   空指针异常

解读

空指针异常是编码过程中最常见的异常，在使用一个对象的时候，如果对象可能为空，并且使用次对象可能会造成空指针异常，那么需要先判断对象是否为空，再使用这个对象。

在进行常量和变量的相等判断时，建议将常量定义为Java对象封装类型（如将int类型的常量定义为Integer类型），这样在比较时可以将常量放在左边，调用equals方法进行比较，可以省去不必要的判空。

示例

public classNullPointer
{
    staticfinal Integer RESULT_CODE_OK = 0;
    staticfinal Result RESULT_OK = newResult();
 
    publicvoid printResult(Integer resultCode)
    {
        Result result = getResult(resultCode);

        // result可能为null，造成空指针异常
        if(result.isValid())
        {
            print(result);
        }
    }
 
    publicResult getResult(Integer resultCode)
    {
        // 即使resultCode为null，仍然可以正确执行，减少额外的判空语句
        if(RESULT_CODE_OK.equals(resultCode))
        {
            returnRESULT_OK;
        }
        returnnull;
    }

    publicvoid print(Result result)
    {
        ...
    }
}

6   下标越界

解读

访问数组、List等容器内的元素时，必须首先检查下标是否越界，杜绝下标越界异常的发生。

示例

publicclass ArrayOver
{
    publicvoid checkArray(String name)
    {
        // 获取一个数组对象
        String[] cIds = ContentService.queryByName(name);
        if(null != cIds)
        {
           // 只是考虑到cids有可能为null的情况，但是cids完全有可能是个0长度的数组，因此cIds[0]有可能数组下标越界
            String cid=cIds[0];
            cid.toCharArray();
        }
    }
}

7   字符串转数字

解读

调用Java方法将字符串转换为数字时，如果字符串的格式非法，会抛出运行时异常NumberFormatException。

示例

错误例子：

public Integer getInteger1(String number)
{
    // 如果number格式非法，会抛出NumberFormatException
    returnInteger.valueOf(number);
}

正确的处理方法如下：

public Integer getInteger2(String number)
{
    try
    {
        returnInteger.valueOf(number);
    }
    catch(NumberFormatException e)
    {
        ...
       //记录日志异常信息
        returnnull;
    }
}

注意：在捕获异常后一定要记录日志。

8   资源释放

解读

在使用文件、IO流、数据库连接等不会自动释放的资源时，应该在使用完毕后马上将其关闭。关闭资源的代码应该在try...catch...finally的finally内执行，否则可能造成资源无法释放。

示例

错误案例如下：

public voidwriteProduct1(ProductServiceStruct product)
{
    try
    {
        FileWriter fileWriter = new FileWriter("");
        fileWriter.append(product.toString());
        // 如果append()抛出异常，close()方法就不会执行，造成IO流长时间无法释放
        fileWriter.close();
    }
    catch(IOException e)
    {
        ...
    }
}
关闭IO流的正确方法如下：
public voidwriteProduct2(ProductServiceStruct product)
{
    FileWriter fileWriter = null;
    try
    {
        fileWriter = new FileWriter("");
        fileWriter.append(product.toString());
    }
    catch(IOException e)
    {
        ...
       //记录日志
    }
    finally
    {
        // 不管前面是否发生异常，finally中的代码一定会执行
        if(fileWriter != null)
        {
            try
            {
                fileWriter.close();
            }
            catch(IOException e)
            {
                ...
             //记录日志
            }
        }
    }
}

注意：在捕获异常后一定要记录日志。

9   循环体性能

解读

循环体是软件中最容易造成性能问题的地方，所以在进行循环体编码时务必考虑性能问题。

在循环体内重复使用且不会变化的资源（如变量、文件对象、数据库连接等），应该在循环体开始前构造并初始化，避免在循环体内重复和构造初始化造成CPU资源的浪费。

除非业务场景需要，避免在循环体内构造try...catch块，因为每次进入、退出try...catch块都会消耗一定的CPU资源，将try...catch块放在循环体之外可以节省大量的执行时间。

示例

public voidaddProducts(List<ProductServiceStruct> prodList)
{
    for(ProductServiceStruct product : prodList)
    {
        // prodSrv在每次循环时都会重新获取，造成不必要的资源消耗
        ProductService prodSrv =(ProductService) ServiceLocator.findService(ProductService.class);
 
        // 避免在循环体内try...catch，放在循环体之外可以节省执行时间
        try
        {
            prodSrv.addProduct(product);
        }
        catch(BMEException e)
        {
            ...
         //记录日志
        }
    }
}

在循环体中遇到字符串相加，一定要使用StringBuffer这个类。

10     数据类重载toString()方法

解读

数据类如果没有重载toString()方法，在记录日志的时候会无法记录数据对象的属性值，给定位问题带来困难。

示例

public classMdspProductExt
{
    privateString key;
   
    privateString value;
 
    publicString getKey()
    {
       returnkey;
    }
 
    publicvoid setKey(String key)
    {
        this.key = key;
    }
 
    publicString getValue()
    {
        returnvalue;
    }

    publicvoid setValue(String value)
    {
        this.value = value;
    }
}

class BusinessProcess
{
    privateDebugLog log = LogFactory.getDebugLog(BusinessProcess.class);
   
    publicvoid doBusiness(MdspProductExtprodExt)
    {
        try
        {
            ...
        }
        catch(PMSException e)
        {
            // MdspProductExt未重载toString()方法，日志中无法记录对象内属性的值，只能记录对象地址
            log.error("error while process prodExt " +prodExt);
        }
    }
}
fwwdn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 低级错误_JAVA十大低级错误，你都遇到过吗？
weixin_39528029的博客
02-24 112
为了规范大家的编程行为，借鉴前人的编程经验，避免低级错误的不断发生，Java十大低级错误，供所有Java开发人员学习：1、方法和变量命名随意而不规范，没有类注释、方法注释或注释不规范，代码修改后，不同步修改注释，导致注释与代码不符。2、数据类不重载toString()方法(说明：编程规范要求“所有的数据类必须重载toString() 方法，返回该类有意义的内容”)。3、对方法的调用不进行空指针判断...
开发过程中经常犯的低级错误
qq_29391861的博客
06-10 818
1、命名规范 一个版本做一个接口的迁移，在进行包名命名的时候发生了错误，包名命名采取的是所又字母小写的方式进行命名，而我确实进行驼峰方式命名，如本该是userservice，我的命名方式为userService。 如果觉得一个全局静态变量完全没必要，而将这个全局静态变量迁移到方法中作为临时变量，应该把大写改为驼峰命名，如 ： private final static String ALIWPAY...
开发中常见的低级错误--被自己气哭
冷月心的博客
05-17 671
开发中常见的低级错误--被自己气哭
Java开发人员经常会犯的5个错误总结
最新发布
ma_nong33的博客
03-03 356
这是一个细微的差异，仅会导致一年左右的变更问题，因此您的代码本可以一直正常运行，而仅在新的一年中引发问题。下面是源码Objects.equals()，其中a.equals(b)使用的是Long.equals()会判断对象类型，因为编译器已经认为常量是int类型，所以比较结果一定是false。因为使用了线程池，线程是可以复用的，所以在使用ThreadLocal获取用户信息的时候，很可能会误获取到别人的信息。在我们日常的开发中，经常需要对日期进行格式化，但是很多人使用的格式不对，导致出现意想不到的情况。
Java入门教程：Java初学者容易犯的错误
kaikeba的博客
08-18 343
万事开头难，Java编程的初学者常常会遇到各种各样的问题。对于自学的读者来说，则是需要花费更多的时间、精力来解决这些问题，而且一旦遇到的问题几天都得不到解决，往往会带来很大的挫败感。 所以本节介绍一些初学者经常出现的错误，以便减少读者在学习中的障碍。 1）大小写问题 之前我们已经提到，Java是区分大小写的语言。但由于大部分读者都是Windows操作系统的忠实拥护者，因此对大小问题往往都不够重视（Linux平台是区分大小写的）。 例如，有的读者编写的Java程序的类是HelloJava，但当他运行Java程
Java程序员容易犯的10个错误
11-10
Java程序员容易犯的10个错误，Arrays.asList() 会返回一个ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类java.util.Arrays.ArrayList 有set(), get(), contains()方法，但并支持添加...
Java 程序员容易犯的10个SQL错误
08-31
本文介绍了Java 程序员容易犯的10个SQL错误。具有很好的参考价值，下面跟着小编一起来看下吧
Java程序员常犯的五个错误
09-03
总结以前经验针对java编程的一些习惯，给出一些关于java编程的建议： 当你开始成为一个程序员的时候，在编程的时候很容易陷入下面所述的一些坏习惯，下面把Java程序员常犯的五个错误整理如下,需要的朋友可以参考下
Java程序员们最常犯的10个错误
11-30
Java程序员们最常犯的10个错误 Java程序员们最常犯的10个错误
java程序中容易出错的地方
10-31
很容易错的地方,听说一些老程序员也经常犯的错误哦,希望大家编程 的时候尽量不要错了
惊呆了！Java程序员最常犯的错竟然是这10个
沉默王二
01-07 1万+
和绝大多数的程序员一样，我也非常的宅。周末最奢侈的享受就是逛一逛技术型网站，比如说 programcreek，这个小网站上有一些非常有意思的主题。比如说：Java 程序员最常犯的错竟然是这 10 个，像这类令人好奇心想害死猫的主题，非常值得扒出来给大家分享一下。 PS：别问我“为什么标题要加上‘惊呆了’？”问了答案就只有一个——吓唬人——总得勾起大家的阅读兴趣嘛（我容易吗我）。 01、把 Arr...
Java开发人员最常犯的9个错误
Nothing
09-06 262
1.Array转ArrayList 当需要把Array转成ArrayList的时候，开发人员经常这样做： String [] strArray = {"0" , "1" , "2"}; List<String> list = Arrays.asList(intArray); Arrays.asList会返回一个ArrayList，但是要特别注意，这个ArrayList是Arrays类...
Java 开发者最容易犯的10个错误
风之子
03-28 259
java
java基础中容易出错的地方
qq_37922915的博客
05-27 386
一、 byte a=1; byte b=2; byte c=a+b; //编译错误，因为short，char,byte运算时是转换为int在计算的。 // 换成 int c=a+b;正确 二、 char x='a'; char x1='b'; char x3=(char)(x+x1); System.out.println(x3); //输...
程序员低级错误大收集 各个痛心疾首
jgfyyfd的博客
11-04 558
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 先汇总一下错误的分类吧
Java开发人员最常犯的10个错误
weixin_34274029的博客
05-19 631
这个列表总结了10个Java开发人员最常犯的错误。 Array转ArrayList 当需要把Array转成ArrayList的时候，开发人员经常这样做： List&lt;String&gt; list = Arrays.asList(arr); Arrays.asList()会返回一个ArrayList，但是要特别注意，这个ArrayList是Arrays类的静态内部类，并不是ja...
程序员低级错误大收集,各个痛心疾首。
热门推荐
老紫竹的专栏
04-22 1万+
先汇总一下错误的分类吧1 全角问题2 =和==的问题3 空格问题4 拼写问题5 疏忽，忘记做该做的事情6 新东西，不是很熟悉下面是明细，呵呵呵。1 老紫竹(java2000_net)我最难忘的一次，是自作聪明的在一个for循环后面加上了一个分号，而且是在大量的代码重构之后，运行时偶尔发生这个错误。大概用了我近1周的时间。从那之后，我的代码
十个JAVA程序员容易犯的错误
weixin_30788239的博客
01-08 289
十个JAVA程序员容易犯的错误 1. Array 转 ArrayList 一般开发者喜欢用： List<String> list = Arrays.asList(arr); Arrays.asList() 会返回一个ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList 类java.util.Arrays.ArrayList 有set...
大学一年的Java程序员应该如何学习
02-06
首先，在大学一年中学习Java编程语言，需要有扎实的基础知识。应该从Java语言基础入手，包括变量、数据类型、运算符、控制语句、数组、方法等。然后，学习Java面向对象编程的基本概念，包括类、对象、继承、多态、封装等。 学习Java的同时，还应该学习一些常用的Java核心类库和常用框架。例如：集合框架、Java IO 流、Java多线程、Java反射等，这些都是编写高质量Java程序所必需的。 除了学习理论知识，还应该多写代码来巩固学习成果。可以尝试编写一些简单的Java程序，并不断挑战自己，写出更复杂的程序。此外，可以尝试参与一些练手的小项目来练习。 另外，不断学习新知识、保持对技术的兴趣和好奇心，是成为优秀Java程序员的关键。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值