在编程时，开发者经常会遭遇各式各样的莫名错误。近日，Sushil Das在Geek On Java上列举了Java开发中常见的5个错误，与君共「搭」。代码编辑常见的错误行为
在编程时，开发者经常会遭遇各式各样的莫名错误。近日，Sushil Das在Geek On Java上列举了Java开发中常见的5个错误，与君共「搭」。
1，空的过度使用
避免过度使用null值是一个最佳实践。例如，更好的做法是让方法返回空的数组或者集合而不是null值，因为这样可以防止程序抛出NullPointerException。下面代码片段会从另一个方法获得一个集合：
List <String> accountIds = person.getAccountIds（）;
for（String accountId：accountIds）{
processAccount（accountId）;
}
当一个人没有帐户的时候，getAccountIds（）将返回null值，程序就会抛出NullPointerException异常。因此需要加入空检查来解决这个问题。如果将返回的null值替换成一个空的列表，那么NullPointerException也不会出现。而且，因为我们不再需要对变量accountId做空检查，代码将变得更加简洁。
当你想避免null值的时候，不同场景可能采取不同做法。其中一个方法就是使用可选类型，它可以是一个空对象，也可以是一些值的封装。
可选<String> optionalString = Optional.ofNullable（nullableString）;
if（optionalString.isPresent（））{
System.out.println（optionalString.get（））;
}
事实上，Java8提供了一个更简洁的方法：
可选<String> optionalString = Optional.ofNullable（nullableString）;
optionalString.ifPresent（的System.out ::的println）;
Java是从Java8版本开始支持可选类型，但是它在函数式编程世界早已广为人知。在此之前，它已经在谷歌Guava中针对Java的早期版本被使用。
2，忽视异常
我们经常对异常置之不理。然而，针对初学者和有经验的Java 程序员，最佳实践仍是处理它们。异常抛出通常是带有目的性的，因此在大多数情况下需要记录引起异常的事件。别小看这件事，如果必要的话，你可以重新抛出它，在一个对话框中将为你的其他开发者提供知晓前因后果的信息，或者将你的信息记录在日志中。应该解释为什么没有处理这个异常。
selfie = person.shootASelfie（）;
尝试{
selfie.show（）;
} catch（NullPointerException e）{
//也许，看不见的人。谁在乎，无论如何？
}
强调某个异常不重要的一个简便途径就是将此信息作为异常的变量名，像这样：
尝试{selfie.delete（）; } catch（NullPointerException unimportant）{}
3，并发修改异常
这种异常发生在集合对象被修改，同时还没有使用迭代器对象提供的方法去更新集合中的内容。例如，这里有一个帽子列表，并想删除其中所有含耳瓣的值：
List <IHat> hats = new ArrayList <>（）;
hats.add（新的Ushanka（））; //那个耳罩有
hats.add（新的Fedora（））;
hats.add（新Sombrero（））;
（帽子：帽子）{
if（hat.hasEarFlaps（））{
帽子。移除（帽子）;
}
}
如果运行此代码，ConcurrentModificationException将会被抛出，因为代码在遍历这个集合的同时对其进行修改。另外一个进程试图列表内容，同样的异常也可能会出现。
在多线程中并发修改集合内容是非常常见的，因此需要使用并发编程中常用的方法进行处理，例如同步锁，对于并发修改采用特殊的集合等等.Java在单线程和多线程情况下解决这个问题有微小的差别。
收集对象并在另一个循环中删除它们
直接的解决方案是将带有ear flaps的帽子放进一个列表，之后用另一个循环删除它。不过这需要一个额外的集合来存放将被删除的帽子。
List <IHat> hatsToRemove = new LinkedList <>（）;
（帽子：帽子）{
if（hat.hasEarFlaps（））{
hatsToRemove.add（帽子）;
}
}
for（IHat hat：hatsToRemove）{
hats.remove（hat）;
}
使用Iterator.remove方法
这个方法更简单，同时并不需要创建额外的集合：
Iterator <IHat> hatIterator = hats.iterator（）;
while（hatIterator.hasNext（））{
IHat hat = hatIterator.next（）;
如果（hat.hasEarFlaps（））{
hatIterator.remove（）;
}
}
使用的ListIterator的方法
实现ListIterator接口的迭代器不仅支持删除操作，还支持添加和设置操作.ListIterator接口实现了Iterator接口，因此这个例子看起来和迭代器是一个非常合适的选择。的删除方法很像。唯一的区别是hat iterator的类型和我们获得迭代器的方式 - 使用listIterator（）方法。下面的片段展示了如何使用ListIterator.remove和ListIterator.add方法将带有耳瓣的帽子替换成带有sombreros的。
IHat sombrero =新Sombrero（）;
ListIterator <IHat> hatIterator = hats.listIterator（）;
while（hatIterator.hasNext（））{
IHat hat = hatIterator.next（）;
如果（hat.hasEarFlaps（））{
hatIterator.remove（）;
hatIterator.add（阔边帽）;
}
}
使用ListIterator，调用remove和add方法可替换为只调用一个set方法：
IHat sombrero =新Sombrero（）;
ListIterator <IHat> hatIterator = hats.listIterator（）;
while（hatIterator.hasNext（））{
IHat hat = hatIterator.next（）;
如果（hat.hasEarFlaps（））{
hatIterator.set（sombrero）; //设置而不是删除并添加
}
}
使用Java 8中的流方法
在Java8中，开发人员可以将一个集合转换为流，并且根据一些条件过滤流。这个例子讲述了流api是如何过滤帽子和避免ConcurrentModificationException。hats = hats.stream（）。filter（（hat - >！ hat.hasEarFlaps（）））
.collect（Collectors.toCollection（ArrayList的::新））;
Collectors.toCollection方法将会创建一个新的ArrayList，它负责存放被过滤掉的hats值。如果过滤条件过滤掉了大量条目，这里将会产生一个很大的ArrayList。因此，需要谨慎使用。
使用Java 8中的List.removeIf方法
可以使用Java 8中另一个更简洁明了的方法 - removeIf方法：
hats.removeIf（IHAT :: hasEarFlaps）;
在底层，它使用Iterator.remove来完成这个操作。
使用特殊的集合
因为CopyOnWriteArrayList提供了修改的方法（例如set，add，remove），它不会去改变原始集合数组，而是创建了一个新的修改版本。这就允许遍历原来版本集合的同时进行修改，从而不会出出ConcurrentModificationException异常。这种集合的缺点也非常明显 - 针对每次修改都产生一个新的集合。
还有其他适用于不同场景的集合，比如CopyOnWriteSet和ConcurrentHashMap。
关于另一个可能可能在并发修改集合时产生的错误是，从一个集合创建了一个流，在遍历流的时候，同时修改后端的集合。针对流的一般准则是，在查询流的时候，避免修改后端的集合。接下来的例子将展示如何正确地处理stream：
List <IHat> filteredHats = hats.stream（）。peek（hat - > {
if（hat.hasEarFlaps（））{
hats.remove（hat）;
}
}）。collect（Collectors.toCollection（ArrayList :: new）） ;
偷看方法收集所有的元素，并对每一个元素执行既定动作。在这里，动作即为尝试从一个基础列表中删除数据，这显然是错误的。为避免这样的操作，可以尝试一些上面讲解的方法。
4，违约
有时候，为了更好地协作，由标准库或者第三方提供的代码必须遵守共同的依赖准则。例如，必须遵守hashCode和equals的共同约定，从而保证Java集合框架中的一系列集合类和其它使用hashCode和equals方法的类能够正常工作。不遵守约定并不会产生异常或者破坏代码编译之类的错误;它很阴险，因为它随时可能在毫无危险提示的情况下更改应用程序行为。
错误代码可能潜入生产环境，从而造成一大堆不良影响。这些包括较差的UI体验，错误的数据报告，较差的应用性能，数据丢失或者更多。庆幸的是，这些灾难性的错误不会经常发生。在之前已经提供了hashCode和equals约定，它出现的场景可能是：集合依赖于将对象进行哈希或者比较，就像HashMap和HashSet。简单来说，这个约定有两个准则：
如果两个对象相等，那么hash代码必须相等。
如果两个对象有相同的哈希码，那么它们可能相等也可能不相等。
破坏约定的第一条准则，当你试图从一个hashmap中检索数据的时候将导致错误。第二个准则意味着拥有相同哈希码的对象不一定相等。
下面看一下破坏第一条准则的后果：
public static class Boat {
private String name;
Boat（String name）{
this.name = name;
}
@Override
public boolean equals（Object o）{
if（this == o）return true;
如果（o == null || getClass（）！= o.getClass（））返回false;
Boat boat =（Boat）o;
return！（name！= null？！name.equals（boat.name）：boat.name！= null）;
}
@Override
public int hashCode（）{
return（int）（Math.random（）* 5000）;
}
}
正如你所见，Boat类重写了equals和hashCode方法。然而，它破坏了约定，因为hashCode针对每次调用的相同对象返回了随机值。下面的代码很可能在hashset中找不到一个名为企业的船，尽管事实上我们提前加入了这种类型的船：
public static void main（String [] args）{
Set <Boat> boats = new HashSet <>（）;
boats.add（新船（“企业”））;
System.out.printf（“我们有一艘名为'Enterprise'的船：％b / n”，boats.contains（新船（“企业”）））;
}
另一个约定的例子是finalize方法。这里是官方Java文档关于它功能描述的引用：
finalize的常规约定是：当JavaTM虚拟机确定任何线程都无法再通过任何方式访问指定对象时，这个方法会被调用，此后这个对象只能在某个其他（准备终止的）对象或类终结时被作为某行的结果.finalize方法有多个功能，其中包括再次使此对象对其他线程可用;不过，连接对象的finalize方法可执行显式I / O事务，以便在永久丢弃对象之前中断连接。
你可以决定在诸如文件处理器中使用finalize方法来释放资源，但是这种用法是很糟糕的。由于它是在垃圾回收期间被调用的，而GC的时间并不确定，因此finalize被调用的时间将无法保证。
5，使用原始类型而不是参数化的
根据Java文档描述：原始类型要么是非参数化的，要么是类R的（同时也是非继承R父类或者父接口的）非静态成员。在Java泛型被引入之前，并没有原始类型的替代类型.Java从1.5版本开始支持泛型编程，毫无疑问这是一个重要的功能提升。然而，由于向后兼容的原因，这里存在一个陷阱可能会破坏整个类型系统。着眼下例：
List listOfNumbers = new ArrayList（）;
listOfNumbers.add（10）;
listOfNumbers.add（ “二”）;
listOfNumbers.forEach（n - > System.out.println（（int）n * 2））;
这是一个由数字组成的列表被定义为原始的ArrayList。由于它并没有指定类型参数，因此可以给它添加任何对象。但是最后一行将其包含的元素映射为int类型并乘以2，打印出翻倍之后的数据到标准输出。
此代码编译时不会出错，但是一旦运行就会抛出运行时错误，因为这里试图将字符类型映射为整形。很显然，如果隐藏了必要信息，类型系统将不能帮助写出安全代码。
为了解决这个问题，需要为存入集合中的对象指定具体类型：
List <Integer> listOfNumbers = new ArrayList <>（）;
listOfNumbers.add（10）;
listOfNumbers.add（ “二”）;
listOfNumbers.forEach（n - > System.out.println（（int）n * 2））;
与之前代码的唯一差别即是定义集合的那一行：
List <Integer> listOfNumbers = new ArrayList <>（）;
修改之后的代码编译不可能被通过，因为这里试图向只期望存储整形的集合中添加字符串。编译器将显示错误信息，并指向试图向列表中添加二十字符的那一行。参数化泛型类型是个不错的主意。这样的话，编译器就能够检查所有可能的类型，从而由于类型不一致而导致的运行时异常几率将大大降低。