收集对象并在另一个循环中删除它们
直接的解决方案是将带有 ear flaps 的 hats 放进一个 list，之后用另一个循环删除它。不过这需要一个额外的集合来存放将要被删除的 hats。
</>
List<IHat> hatsToRemove = new LinkedList<>();
for (IHat hat : hats) {
if (hat.hasEarFlaps()) {
hatsToRemove.add(hat);
}
}
for (IHat hat : hatsToRemove) {
hats.remove(hat);
}
使用 Iterator.remove 方法
这个方法更简单，同时并不需要创建额外的集合：
</>
Iterator<IHat> hatIterator = hats.iterator();
while (hatIterator.hasNext()) {
IHat hat = hatIterator.next();
if (hat.hasEarFlaps()) {
hatIterator.remove();
}
}
使用 ListIterator 的方法
当需要修改的集合实现了 List 接口时，list iterator 是非常合适的选择。实现 ListIterator 接口的 iterator 不仅支持删除操作，还支持 add 和 set 操作。ListIterator 接口实现了 Iterator 接口，因此这个例子看起来和 Iterator 的 remove 方法很像。唯一的区别是 hat iterator 的类型和我们获得 iterator 的方式——使用 listIterator() 方法。下面的片段展示了如何使用 ListIterator.remove 和 ListIterator.add 方法将带有 ear flaps 的 hat 替换成带有sombreros 的。
</>
IHat sombrero = new Sombrero();
ListIterator<IHat> hatIterator = hats.listIterator();
while (hatIterator.hasNext()) {
IHat hat = hatIterator.next();
if (hat.hasEarFlaps()) {
hatIterator.remove();
hatIterator.add(sombrero);
}
}
使用 ListIterator，调用 remove 和 add 方法可替换为只调用一个 set 方法：
</>
IHat sombrero = new Sombrero();
ListIterator<IHat> hatIterator = hats.listIterator();
while (hatIterator.hasNext()) {
IHat hat = hatIterator.next();
if (hat.hasEarFlaps()) {
hatIterator.set(sombrero); // set instead of remove and add
}
}
使用Java 8中的 stream 方法
在 Java8 中，开发人员可以将一个 collection 转换为 stream，并且根据一些条件过滤 stream。这个例子讲述了 stream api 是如何过滤 hats 和避免 ConcurrentModificationException。 hats = hats.stream().filter((hat -> !hat.hasEarFlaps()))
</>
.collect(Collectors.toCollection(ArrayList::new));
Collectors.toCollection 方法将会创建一个新的 ArrayList，它负责存放被过滤掉的 hats 值。如果过滤条件过滤掉了大量条目，这里将会产生一个很大的 ArrayList。因此，需要谨慎使用。
使用 Java 8 中的 List.removeIf 方法
可以使用 Java 8 中另一个更简洁明了的方法—— removeIf 方法:
</>
hats.removeIf(IHat::hasEarFlaps);
在底层，它使用 Iterator.remove 来完成这个操作。
使用特殊的集合
如果在一开始就决定使用 CopyOnWriteArrayList 而不是 ArrayList，那就不会出现问题。因为 CopyOnWriteArrayList 提供了修改的方法（例如 set，add，remove），它不会去改变原始集合数组，而是创建了一个新的修改版本。这就允许遍历原来版本集合的同时进行修改，从而不会抛出 ConcurrentModificationException 异常。这种集合的缺点也非常明显——针对每次修改都产生一个新的集合。
还有其他适用于不同场景的集合，比如 CopyOnWriteSet 和 ConcurrentHashMap。
关于另一个可能可能在并发修改集合时产生的错误是，从一个 collection 创建了一个 stream，在遍历 stream 的时候，同时修改后端的 collection。针对 stream 的一般准则是，在查询 stream 的时候，避免修改后端的 collection。接下来的例子将展示如何正确地处理 stream：
</>
List<IHat> filteredHats = hats.stream().peek(hat -> {
if (hat.hasEarFlaps()) {
hats.remove(hat);
}
}).collect(Collectors.toCollection(ArrayList::new));
peek 方法收集所有的元素，并对每一个元素执行既定动作。在这里，动作即为尝试从一个基础列表中删除数据，这显然是错误的。为避免这样的操作，可以尝试一些上面讲解的方法。
4. 违约
有时候，为了更好地协作，由标准库或者第三方提供的代码必须遵守共同的依赖准则。例如，必须遵守 hashCode 和 equals 的共同约定，从而保证 Java 集合框架中的一系列集合类和其它使用 hashCode 和 equals 方法的类能够正常工作。不遵守约定并不会产生 exception 或者破坏代码编译之类的错误；它很阴险，因为它随时可能在毫无危险提示的情况下更改应用程序行为。
错误代码可能潜入生产环境，从而造成一大堆不良影响。这包括较差的 UI 体验、错误的数据报告、较差的应用性能、数据丢失或者更多。庆幸的是，这些灾难性的错误不会经常发生。在之前已经提及了 hashCode 和equals 约定，它出现的场景可能是：集合依赖于将对象进行哈希或者比较，就像 HashMap 和 HashSet。简单来说，这个约定有两个准则：
如果两个对象相等，那么 hash code 必须相等。
如果两个对象有相同的 hash code，那么它们可能相等也可能不相等。
破坏约定的第一条准则，当你试图从一个 hashmap 中检索数据的时候将会导致错误。第二个准则意味着拥有相同 hash code 的对象不一定相等。
下面看一下破坏第一条准则的后果：
</>
public static class Boat {
private String name;
Boat(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return 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 中找不到一个名为 Enterprise 的boat，尽管事实上我们提前加入了这种类型的 boat：
</>
public static void main(String[] args) {
Set<Boat> boats = new HashSet<>();
boats.add(new Boat("Enterprise"));
System.out.printf("We have a boat named 'Enterprise' : %b\n", boats.contains(new Boat("Enterprise")));
}
另一个约定的例子是 finalize 方法。这里是官方 Java 文档关于它功能描述的引用：
finalize 的常规约定是：当 JavaTM 虚拟机确定任何线程都无法再通过任何方式访问指定对象时，这个方法会被调用，此后这个对象只能在某个其他（准备终止的）对象或类终结时被作为某个行为的结果。finalize 方法有多个功能，其中包括再次使此对象对其他线程可用；不过 finalize 的主要目的是在不可撤消地丢弃对象之前执行清除操作。例如，表示输入/输出连接对象的 finalize 方法可执行显式 I/O 事务，以便在永久丢弃对象之前中断连接。
你可以决定在诸如文件处理器中使用 finalize 方法来释放资源，但是这种用法是很糟糕的。由于它是在垃圾回收期间被调用的，而 GC 的时间并不确定，因此 finalize 被调用的时间将无法保证。
5. 使用原始类型而不是参数化的
根据 Java 文档描述：原始类型要么是非参数化的，要么是类 R 的（同时也是非继承 R 父类或者父接口的）非静态成员。在 Java 泛型被引入之前，并没有原始类型的替代类型。Java 从1.5版本开始支持泛型编程，毫无疑问这是一个重要的功能提升。然而，由于向后兼容的原因，这里存在一个陷阱可能会破坏整个类型系统。着眼下例：
</>
List listOfNumbers = new ArrayList();
listOfNumbers.add(10);
listOfNumbers.add("Twenty");
listOfNumbers.forEach(n -> System.out.println((int) n * 2));
这是一个由数字组成的列表被定义为原始的 ArrayList。由于它并没有指定类型参数，因此可以给它添加任何对象。但是最后一行将其包含的元素映射为 int 类型并乘以 2，打印出翻倍之后的数据到标准输出。
此代码编译时不会出错，但是一旦运行就会抛出运行时错误，因为这里试图将字符类型映射为整形。很显然，如果隐藏了必要信息，类型系统将不能帮助写出安全代码。
为了解决这个问题，需要为存入集合中的对象指定具体类型：
</>
List<Integer> listOfNumbers = new ArrayList<>();
listOfNumbers.add(10);
listOfNumbers.add("Twenty");
listOfNumbers.forEach(n -> System.out.println((int) n * 2));
与之前代码的唯一差别即是定义集合的那一行：
</>
List<Integer> listOfNumbers = new ArrayList<>();
修改之后的代码编译不可能被通过，因为这里试图向只期望存储整形的集合中添加字符串。编译器将会显示错误信息，并指向试图向列表中添加 Twenty 字符的那一行。参数化泛型类型是个不错的主意。这样的话，编译器就能够检查所有可能的类型，从而由于类型不一致而导致的运行时异常几率将大大降低。
