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

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

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


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

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

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

4、 魔鬼数字。

5、 空指针异常。

6、 数组下标越界。

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

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

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

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

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

解读

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

示例

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

  1. publicclass Test {  
  2. publicstaticvoid main(String[] args)  
  3.  
  4. String a = new String("a");  
  5. String a2 = "a" 
  6. if(a == a2)  
  7.  
  8. System.out.println("a == a2return true.");  
  9.  
  10. else  
  11.  
  12. System.out.println("a == a2 returnfalse.");  
  13.  
  14. if(a.equals(a2))  
  15.  System.out.println("a.equals(a2)return true.");  
  16.  
  17. else  
  18.  
  19. System.out.println("a.equals(a2)return false.");  
  20.  
  21.  
  22.  

最终输出的结果为: 

  1. a == a2 return false 
  2. a.equals(a2) return true 

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

解读

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

示例

  1. publicclass Test { 
  2.  publicstaticvoid main(String[] args) 
  3.  { 
  4.  List<Person> list = new ArrayList<Person>(); 
  5.  Person p1 = new Person("张三", 23); 
  6.  Person p2 = new Person("李四", 26); 
  7.  Person p3 = new Person("王五", 34); 
  8.  Person p4 = new Person("刘二", 15); 
  9.  Person p5 = new Person("朱六", 40); 
  10.   
  11.  list.add(p1); 
  12.  list.add(p2); 
  13.  list.add(p3); 
  14.  list.add(p4); 
  15.  list.add(p5); 
  16.  for(Person p : list) 
  17.  { 
  18.  if("王五".equals(p.getName())) 
  19.  { 
  20.  list.remove(p); // 不能在此时删除对象。 
  21.  } 
  22. elseif("李四".equals(p.getName())) 
  23.  { 
  24.  list.remove(p); // 不能在此时删除对象。 
  25.  } 
  26.  } 
  27.  System.out.println(list.size()); 
  28.  } 
  29.   
  30. class Person 
  31.  private String name
  32.  privateintage; 
  33.   
  34.  public Person(String nameint age) 
  35.  { 
  36.  this.name = name
  37.  this.age = age; 
  38.  } 
  39.   
  40.  public String getName() 
  41.  { 
  42.  returnname; 
  43.  } 
  44.   
  45.  publicvoid setName(String name
  46.  { 
  47.  this.name = name
  48.  } 
  49.   
  50.  publicint getAge() 
  51.  { 
  52.  returnage; 
  53.  } 
  54.   
  55.  publicvoid setAge(int age) 
  56.  { 
  57.  this.age = age; 
  58.  } 

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

  1. List<Person> list = new ArrayList<Person>(); 
  2.  Person p1 = new Person(new String("张三"), 23); 
  3.  Person p2 = new Person(new String("李四"), 26); 
  4.  Person p3 = new Person(new String("王五"), 34); 
  5.  Person p4 = new Person(new String("刘二"), 15); 
  6.  Person p5 = new Person(new String("朱六"), 40); 
  7.   
  8.  list.add(p1); 
  9.  list.add(p2); 
  10.  list.add(p3); 
  11.  list.add(p4); 
  12.  list.add(p5); 
  13.   
  14.  Person wangwu = null
  15.  Person lisi = null
  16.  for(Person p : list) 
  17.  { 
  18.  if("王五".equals(p.getName())) 
  19.  { 
  20.  wangwu = p; 
  21.  } 
  22.  elseif("李四".equals(p.getName())) 
  23.  { 
  24.  lisi = p; 
  25.  } 
  26.  } 
  27.   
  28.  list.remove(wangwu); 
  29.  list.remove(lisi); 

3 日志规范性

解读

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

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

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

示例

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

  1. public voidsaveProduct1(ProductServiceStruct product) 
  2.  log.debug("enter method: addProduct()"); 
  3.   
  4.  log.debug("check product status"); 
  5.  if(product.getProduct().getProductStatus() != ProductFieldEnum.ProductStatus.RELEASE) 
  6.  { 
  7.  thrownew PMSException(PMSErrorCode.Product.ADD_ERROR); 
  8.  } 
  9.   
  10.  log.debug("check tariff"); 
  11.  BooleanResult result =checkTariff(product.getTariffs()); 
  12.  if(!result.getResult()) 
  13.  { 
  14.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR); 
  15.  } 
  16.   
  17.  log.debug("before add product"); 
  18.  ProductService prodSrv = (ProductService)ServiceLocator.findService(ProductService.class); 
  19.  try 
  20.  { 
  21.  prodSrv.addProduct(product); 
  22.  } 
  23.  catch(BMEException e) 
  24.  { 
  25.  // 未记录异常栈,无法定位问题根源 
  26.  } 
  27.   
  28.  log.debug("after add product"); 
  29.  log.debug("exit method: updateProduct()"); // 错误的日志 

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

  1. public voidsaveProduct2(ProductServiceStruct product) 
  2.  if(product.getProduct().getProductStatus() != ProductFieldEnum.ProductStatus.RELEASE) 
  3.  { 
  4.  log.error( 
  5.  "productstatus " 
  6.  +product.getProduct().getProductStatus() 
  7.  + "error, expect " + ProductFieldEnum.ProductStatus.RELEASE); 
  8.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR); 
  9.  } 
  10.   
  11.  BooleanResult result =checkTariff(product.getTariffs()); 
  12.  if(!result.getResult()) 
  13.  { 
  14.  log.error( 
  15.  "checkproduct tariff error " 
  16.  + result.getResultCode() 
  17.  + ":" 
  18.  + result.getResultDesc()); 
  19.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR); 
  20.  } 
  21.   
  22.  ProductService prodSrv = (ProductService)ServiceLocator.findService(ProductService.class); 
  23.  try 
  24.  { 
  25.  prodSrv.addProduct(product); 
  26.  } 
  27.  catch(BMEException e) 
  28.  { 
  29.  log.error("add product error", e); 
  30.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR,e); 
  31.  } 

4 魔鬼数字

解读

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

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

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

示例 

  1. public void addProduct(ProductServiceStruct product) 
  2.  // 魔鬼数字,无法理解3具体代表产品的什么状态 
  3.  if(product.getProduct().getProductStatus() != 3) 
  4.  { 
  5.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR); 
  6.  } 
  7.   
  8.  BooleanResult result =checkTariff(product.getTariffs()); 
  9.  if(!result.getResult()) 
  10.  { 
  11.  thrownew PMSException(PMSErrorCode.Product.ADD_ERROR); 
  12.  } 
  13.   
  14. /** 
  15. *产品未激活状态 
  16. */ 
  17. privatestaticfinalintUNACTIVATED = 0; 
  18. /** 
  19. *产品已激活状态 
  20. */ 
  21. privatestaticfinalintACTIVATED = 1; 
  22.   
  23. public voidaddProduct2(ProductServiceStruct product) 
  24.  if(product.getProduct().getProductStatus() != ACTIVATED) 
  25.  { 
  26.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR); 
  27.  } 
  28.   
  29.  BooleanResult result =checkTariff(product.getTariffs()); 
  30.  if(!result.getResult()) 
  31.  { 
  32.  thrownewPMSException(PMSErrorCode.Product.ADD_ERROR); 
  33.  } 

5 空指针异常

解读

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

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

示例 

  1. public classNullPointer 
  2.  staticfinal Integer RESULT_CODE_OK = 0; 
  3.  staticfinal Result RESULT_OK = newResult(); 
  4.   
  5.  publicvoid printResult(Integer resultCode) 
  6.  { 
  7.  Result result = getResult(resultCode); 
  8.   
  9.  // result可能为null,造成空指针异常 
  10.  if(result.isValid()) 
  11.  { 
  12.  print(result); 
  13.  } 
  14.  } 
  15.   
  16.  publicResult getResult(Integer resultCode) 
  17.  { 
  18.  // 即使resultCode为null,仍然可以正确执行,减少额外的判空语句 
  19.  if(RESULT_CODE_OK.equals(resultCode)) 
  20.  { 
  21.  returnRESULT_OK; 
  22.  } 
  23.  returnnull; 
  24.  } 
  25.   
  26.  publicvoid print(Result result) 
  27.  { 
  28.  ... 
  29.  } 

6 下标越界

解读

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

示例 

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

7 字符串转数字

解读

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

示例

错误例子: 

  1. public Integer getInteger1(String number) 
  2.  // 如果number格式非法,会抛出NumberFormatException 
  3.  returnInteger.valueOf(number); 

正确的处理方法如下: 

  1. public Integer getInteger2(String number) 
  2.  try 
  3.  { 
  4.  returnInteger.valueOf(number); 
  5.  } 
  6.  catch(NumberFormatException e) 
  7.  { 
  8.  ... 
  9.  //记录日志异常信息 
  10.  returnnull; 
  11.  } 

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

8 资源释放

解读

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

示例

错误案例如下: 

  1. public voidwriteProduct1(ProductServiceStruct product) 
  2.  try 
  3.  { 
  4.  FileWriter fileWriter = new FileWriter(""); 
  5.  fileWriter.append(product.toString()); 
  6.  // 如果append()抛出异常,close()方法就不会执行,造成IO流长时间无法释放 
  7.  fileWriter.close(); 
  8.  } 
  9.  catch(IOException e) 
  10.  { 
  11.  ... 
  12.  } 
  13. 关闭IO流的正确方法如下: 
  14. public voidwriteProduct2(ProductServiceStruct product) 
  15.  FileWriter fileWriter = null
  16.  try 
  17.  { 
  18.  fileWriter = new FileWriter(""); 
  19.  fileWriter.append(product.toString()); 
  20.  } 
  21.  catch(IOException e) 
  22.  { 
  23.  ... 
  24.  //记录日志 
  25.  } 
  26.  finally 
  27.  { 
  28.  // 不管前面是否发生异常,finally中的代码一定会执行 
  29.  if(fileWriter != null
  30.  { 
  31.  try 
  32.  { 
  33.  fileWriter.close(); 
  34.  } 
  35.  catch(IOException e) 
  36.  { 
  37.  ... 
  38.  //记录日志 
  39.  } 
  40.  } 
  41.  } 

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

9 循环体性能

解读

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

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

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

示例

  1. public voidaddProducts(List<ProductServiceStruct> prodList) 
  2.  for(ProductServiceStruct product : prodList) 
  3.  { 
  4.  // prodSrv在每次循环时都会重新获取,造成不必要的资源消耗 
  5.  ProductService prodSrv =(ProductService) ServiceLocator.findService(ProductService.class); 
  6.   
  7.  // 避免在循环体内try...catch,放在循环体之外可以节省执行时间 
  8.  try 
  9.  { 
  10.  prodSrv.addProduct(product); 
  11.  } 
  12.  catch(BMEException e) 
  13.  { 
  14.  ... 
  15.  //记录日志 
  16.  } 
  17.  } 

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

10 数据类重载toString()方法

解读

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

示例 

  1. public classMdspProductExt 
  2.  privateString key
  3.   
  4.  privateString value; 
  5.   
  6.  publicString getKey() 
  7.  { 
  8.  returnkey; 
  9.  } 
  10.   
  11.  publicvoid setKey(String key
  12.  { 
  13.  this.key = key
  14.  } 
  15.   
  16.  publicString getValue() 
  17.  { 
  18.  returnvalue; 
  19.  } 
  20.   
  21.  publicvoid setValue(String value) 
  22.  { 
  23.  this.value = value; 
  24.  } 
  25.   
  26. class BusinessProcess 
  27.  privateDebugLog log = LogFactory.getDebugLog(BusinessProcess.class); 
  28.   
  29.  publicvoid doBusiness(MdspProductExtprodExt) 
  30.  { 
  31.  try 
  32.  { 
  33.  ... 
  34.  } 
  35.  catch(PMSException e) 
  36.  { 
  37.  // MdspProductExt未重载toString()方法,日志中无法记录对象内属性的值,只能记录对象地址 
  38.  log.error("error while process prodExt " +prodExt); 
  39.  } 
  40.  } 

这10个低级错误你有没有犯过呢?

责任编辑:庞桂玉 来源: 今日头条
相关推荐

2016-01-11 11:32:41

Java程序员错误

2011-05-31 15:19:17

2011-07-11 10:12:59

2011-07-06 08:49:05

程序员

2018-06-27 13:10:22

程序员面试易犯错误

2021-09-02 08:40:10

程序员错误

2011-05-31 15:38:37

CSS

2009-11-23 15:22:16

2021-06-04 10:15:17

JavaSQL编程语言

2021-03-15 08:15:16

程序员架构代码

2018-03-15 10:21:50

程序员面试低级错误

2018-09-19 14:45:21

初级程序员错误

2017-09-15 11:28:55

程序员编程常犯错误

2013-07-09 13:52:31

程序员Android

2018-05-28 14:55:56

职业错误程序员

2022-12-26 11:02:06

云计算CIOIT

2016-11-02 12:56:58

Linux新手错误

2012-06-18 09:20:38

亚马逊云服务Amazon

2016-01-31 09:47:13

Java程序员构建工具

2014-04-23 10:15:42

程序员机器学习
点赞
收藏

51CTO技术栈公众号