Index: trunk/src/org/openstreetmap/josm/data/osm/CyclicUploadDependencyException.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/CyclicUploadDependencyException.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/CyclicUploadDependencyException.java	(revision 16445)
@@ -8,4 +8,5 @@
 import java.util.List;
 import java.util.Stack;
+import java.util.stream.Collectors;
 
 /**
@@ -38,15 +39,6 @@
     @Override
     public String getMessage() {
-        StringBuilder sb = new StringBuilder();
-        sb.append(tr("Cyclic dependency between relations:"))
-          .append('[');
-        for (int i = 0; i < cycle.size(); i++) {
-            if (i > 0) {
-                sb.append(',');
-            }
-            sb.append(formatRelation(cycle.get(i)));
-        }
-        sb.append(']');
-        return sb.toString();
+        return cycle.stream().map(this::formatRelation)
+                .collect(Collectors.joining(",", tr("Cyclic dependency between relations:") + '[', "]"));
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/DataSet.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/DataSet.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/DataSet.java	(revision 16445)
@@ -213,8 +213,7 @@
                 Way newWay = new Way(w, false, false);
                 primMap.put(w, newWay);
-                List<Node> newNodes = new ArrayList<>();
-                for (Node n : w.getNodes()) {
-                    newNodes.add((Node) primMap.get(n));
-                }
+                List<Node> newNodes = w.getNodes().stream()
+                        .map(n -> (Node) primMap.get(n))
+                        .collect(Collectors.toList());
                 newWay.setNodes(newNodes);
                 addPrimitive(newWay);
Index: trunk/src/org/openstreetmap/josm/data/osm/DefaultNameFormatter.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/DefaultNameFormatter.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/DefaultNameFormatter.java	(revision 16445)
@@ -18,4 +18,5 @@
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -220,11 +221,8 @@
 
         String result = name.toString();
-        for (NameFormatterHook hook: formatHooks) {
-            String hookResult = hook.checkFormat(node, result);
-            if (hookResult != null)
-                return hookResult;
-        }
-
-        return result;
+        return formatHooks.stream().map(hook -> hook.checkFormat(node, result))
+                .filter(Objects::nonNull)
+                .findFirst().orElse(result);
+
     }
 
@@ -312,11 +310,8 @@
 
         String result = name.toString();
-        for (NameFormatterHook hook: formatHooks) {
-            String hookResult = hook.checkFormat(way, result);
-            if (hookResult != null)
-                return hookResult;
-        }
-
-        return result;
+        return formatHooks.stream().map(hook -> hook.checkFormat(way, result))
+                .filter(Objects::nonNull)
+                .findFirst().orElse(result);
+
     }
 
@@ -350,11 +345,8 @@
 
         String result = name.toString();
-        for (NameFormatterHook hook: formatHooks) {
-            String hookResult = hook.checkFormat(relation, result);
-            if (hookResult != null)
-                return hookResult;
-        }
-
-        return result;
+        return formatHooks.stream().map(hook -> hook.checkFormat(relation, result))
+                .filter(Objects::nonNull)
+                .findFirst().orElse(result);
+
     }
 
@@ -463,9 +455,8 @@
                 return relation.getName();
         } else if (":LocationCode".equals(nameTag)) {
-            for (String m : relation.keySet()) {
-                if (m.endsWith(nameTag))
-                    return relation.get(m);
-            }
-            return null;
+            return relation.keySet().stream()
+                    .filter(m -> m.endsWith(nameTag))
+                    .map(relation::get)
+                    .findFirst().orElse(null);
         } else if (nameTag.startsWith("?") && OsmUtils.isTrue(relation.get(nameTag.substring(1)))) {
             return tr(nameTag.substring(1));
Index: trunk/src/org/openstreetmap/josm/data/osm/FilterMatcher.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/FilterMatcher.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/FilterMatcher.java	(revision 16445)
@@ -202,11 +202,6 @@
 
     private static boolean oneParentWayNotFiltered(OsmPrimitive primitive, boolean hidden) {
-        List<OsmPrimitive> refs = primitive.getReferrers();
-        for (OsmPrimitive p: refs) {
-            if (p instanceof Way && !isFiltered(p, hidden))
-                return true;
-        }
-
-        return false;
+        return primitive.referrers(Way.class)
+                .anyMatch(p -> !isFiltered(p, hidden));
     }
 
@@ -223,10 +218,6 @@
 
     private static boolean oneParentMultipolygonNotFiltered(OsmPrimitive primitive, boolean hidden) {
-        for (Relation r : new SubclassFilteredCollection<OsmPrimitive, Relation>(
-                primitive.getReferrers(), OsmPrimitive::isMultipolygon)) {
-            if (!isFiltered(r, hidden))
-                return true;
-        }
-        return false;
+        return new SubclassFilteredCollection<OsmPrimitive, Relation>(primitive.getReferrers(), OsmPrimitive::isMultipolygon).stream()
+                .anyMatch(r -> !isFiltered(r, hidden));
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/FilterModel.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/FilterModel.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/FilterModel.java	(revision 16445)
@@ -14,4 +14,5 @@
 import java.util.Set;
 import java.util.Stack;
+import java.util.stream.Collectors;
 
 import javax.swing.JOptionPane;
@@ -88,8 +89,7 @@
      */
     public void savePrefs(String prefEntry) {
-        Collection<FilterPreferenceEntry> entries = new ArrayList<>();
-        for (Filter flt : filters) {
-            entries.add(flt.getPreferenceEntry());
-        }
+        Collection<FilterPreferenceEntry> entries = filters.stream()
+                .map(Filter::getPreferenceEntry)
+                .collect(Collectors.toList());
         StructUtils.putListOfStructs(Config.getPref(), prefEntry, entries, FilterPreferenceEntry.class);
     }
Index: trunk/src/org/openstreetmap/josm/data/osm/IRelation.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/IRelation.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/IRelation.java	(revision 16445)
@@ -3,7 +3,5 @@
 
 import java.util.Collection;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -125,12 +123,8 @@
      */
     default Collection<? extends IPrimitive> getIncompleteMembers() {
-        Set<IPrimitive> ret = new HashSet<>();
-        for (M rm : getMembers()) {
-            if (!rm.getMember().isIncomplete()) {
-                continue;
-            }
-            ret.add(rm.getMember());
-        }
-        return ret;
+        return getMembers().stream()
+                .filter(rm -> rm.getMember().isIncomplete())
+                .map(rm -> rm.getMember())
+                .collect(Collectors.toSet());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/NodeGraph.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/NodeGraph.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/NodeGraph.java	(revision 16445)
@@ -18,4 +18,6 @@
 import java.util.Set;
 import java.util.TreeMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.openstreetmap.josm.tools.Pair;
@@ -210,11 +212,5 @@
 
     protected Set<Node> getTerminalNodes() {
-        Set<Node> ret = new LinkedHashSet<>();
-        for (Node n: getNodes()) {
-            if (isTerminalNode(n)) {
-                ret.add(n);
-            }
-        }
-        return ret;
+        return getNodes().stream().filter(this::isTerminalNode).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
@@ -248,10 +244,6 @@
 
     protected List<Node> buildPathFromNodePairs(Deque<NodePair> path) {
-        List<Node> ret = new ArrayList<>(path.size() + 1);
-        for (NodePair pair : path) {
-            ret.add(pair.getA());
-        }
-        ret.add(path.peekLast().getB());
-        return ret;
+        return Stream.concat(path.stream().map(NodePair::getA), Stream.of(path.peekLast().getB()))
+                .collect(Collectors.toList());
     }
 
@@ -307,9 +299,8 @@
             Set<Node> nodes = getTerminalNodes();
             nodes = nodes.isEmpty() ? getMostFrequentVisitedNodesFirst() : nodes;
-            for (Node n : nodes) {
-                List<Node> path = buildSpanningPath(n);
-                if (!path.isEmpty())
-                    return path;
-            }
+            return nodes.stream()
+                    .map(this::buildSpanningPath)
+                    .filter(path -> !path.isEmpty())
+                    .findFirst().orElse(null);
         }
         return null;
Index: trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitiveType.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitiveType.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitiveType.java	(revision 16445)
@@ -101,9 +101,7 @@
      */
     public static OsmPrimitiveType from(String value) {
-        for (OsmPrimitiveType type: values()) {
-            if (type.getAPIName().equalsIgnoreCase(value))
-                return type;
-        }
-        return null;
+        return Arrays.stream(values())
+                .filter(type -> type.getAPIName().equalsIgnoreCase(value))
+                .findFirst().orElse(null);
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/PrimitiveData.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/PrimitiveData.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/PrimitiveData.java	(revision 16445)
@@ -6,5 +6,4 @@
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -12,4 +11,5 @@
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
@@ -88,13 +88,6 @@
      * @return a filtered list for given primitive type
      */
-    @SuppressWarnings("unchecked")
     public static <T extends PrimitiveData> List<T> getFilteredList(Collection<T> list, OsmPrimitiveType type) {
-        List<T> ret = new ArrayList<>();
-        for (PrimitiveData p: list) {
-            if (type.getDataClass().isInstance(p)) {
-                ret.add((T) p);
-            }
-        }
-        return ret;
+        return list.stream().filter(p -> type.getDataClass().isInstance(p)).map(p -> (T) p).collect(Collectors.toList());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java	(revision 16445)
@@ -9,4 +9,5 @@
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.stream.IntStream;
 
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -321,10 +322,7 @@
         int indexOf(QBLevel<T> findThis) {
             QBLevel<T>[] children = getChildren();
-            for (int i = 0; i < QuadTiling.TILES_PER_LEVEL; i++) {
-                if (children[i] == findThis) {
-                    return i;
-                }
-            }
-            return -1;
+            return IntStream.range(0, QuadTiling.TILES_PER_LEVEL)
+                    .filter(i -> children[i] == findThis)
+                    .findFirst().orElse(-1);
         }
 
@@ -406,28 +404,15 @@
     @Override
     public boolean removeAll(Collection<?> objects) {
-        boolean changed = false;
-        for (Object o : objects) {
-            changed |= remove(o);
-        }
-        return changed;
+        return objects.stream().map(this::remove).reduce(false, (a, b) -> a || b);
     }
 
     @Override
     public boolean addAll(Collection<? extends T> objects) {
-        boolean changed = false;
-        for (T o : objects) {
-            changed |= add(o);
-        }
-        return changed;
+        return objects.stream().map(this::add).reduce(false, (a, b) -> a || b);
     }
 
     @Override
     public boolean containsAll(Collection<?> objects) {
-        for (Object o : objects) {
-            if (!this.contains(o)) {
-                return false;
-            }
-        }
-        return true;
+        return objects.stream().allMatch(this::contains);
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/Relation.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/Relation.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/Relation.java	(revision 16445)
@@ -2,5 +2,4 @@
 package org.openstreetmap.josm.data.osm;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -274,9 +273,9 @@
             RelationData relationData = (RelationData) data;
 
-            List<RelationMember> newMembers = new ArrayList<>();
-            for (RelationMemberData member : relationData.getMembers()) {
-                newMembers.add(new RelationMember(member.getRole(), Optional.ofNullable(getDataSet().getPrimitiveById(member))
-                        .orElseThrow(() -> new AssertionError("Data consistency problem - relation with missing member detected"))));
-            }
+            List<RelationMember> newMembers = relationData.getMembers().stream()
+                    .map(member -> new RelationMember(member.getRole(), Optional
+                            .ofNullable(getDataSet().getPrimitiveById(member))
+                            .orElseThrow(() -> new AssertionError("Data consistency problem - relation with missing member detected"))))
+                    .collect(Collectors.toList());
             setMembers(newMembers);
         } finally {
@@ -510,8 +509,5 @@
     @Override
     public boolean hasIncompleteMembers() {
-        for (RelationMember rm: members) {
-            if (rm.getMember().isIncomplete()) return true;
-        }
-        return false;
+        return Arrays.stream(members).anyMatch(rm -> rm.getMember().isIncomplete());
     }
 
@@ -523,12 +519,8 @@
     @Override
     public Collection<OsmPrimitive> getIncompleteMembers() {
-        Set<OsmPrimitive> ret = new HashSet<>();
-        for (RelationMember rm: members) {
-            if (!rm.getMember().isIncomplete()) {
-                continue;
-            }
-            ret.add(rm.getMember());
-        }
-        return ret;
+        return Arrays.stream(members)
+                .filter(rm -> rm.getMember().isIncomplete())
+                .map(RelationMember::getMember)
+                .collect(Collectors.toSet());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/RelationToChildReference.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/RelationToChildReference.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/RelationToChildReference.java	(revision 16445)
@@ -3,8 +3,8 @@
 
 import java.util.Collection;
-import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 /**
@@ -21,13 +21,8 @@
     public static Set<RelationToChildReference> getRelationToChildReferences(OsmPrimitive child) {
         Set<Relation> parents = child.referrers(Relation.class).collect(Collectors.toSet());
-        Set<RelationToChildReference> references = new HashSet<>();
-        for (Relation parent: parents) {
-            for (int i = 0; i < parent.getMembersCount(); i++) {
-                if (parent.getMember(i).refersTo(child)) {
-                    references.add(new RelationToChildReference(parent, i, parent.getMember(i)));
-                }
-            }
-        }
-        return references;
+        return parents.stream().flatMap(parent1 -> IntStream.range(0, parent1.getMembersCount())
+                .filter(i -> parent1.getMember(i).refersTo(child))
+                .mapToObj(i -> new RelationToChildReference(parent1, i, parent1.getMember(i))))
+                .collect(Collectors.toSet());
     }
 
@@ -40,9 +35,7 @@
      */
     public static Set<RelationToChildReference> getRelationToChildReferences(Collection<? extends OsmPrimitive> children) {
-        Set<RelationToChildReference> references = new HashSet<>();
-        for (OsmPrimitive child: children) {
-            references.addAll(getRelationToChildReferences(child));
-        }
-        return references;
+        return children.stream()
+                .flatMap(child -> getRelationToChildReferences(child).stream())
+                .collect(Collectors.toSet());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/Storage.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/Storage.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/Storage.java	(revision 16445)
@@ -239,11 +239,8 @@
     @Override
     public synchronized int hashCode() {
-        int h = 0;
-        if (hash != null) {
-            for (T t : this) {
-                h += hash.getHashCode(t);
-            }
-        }
-        return h;
+        if (hash == null) {
+            return 0;
+        }
+        return this.stream().mapToInt(hash::getHashCode).sum();
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/Way.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/Way.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/Way.java	(revision 16445)
@@ -11,4 +11,5 @@
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -120,11 +121,5 @@
      */
     public boolean containsNode(Node node) {
-        if (node == null) return false;
-
-        for (Node n : nodes) {
-            if (n.equals(node))
-                return true;
-        }
-        return false;
+        return node != null && Arrays.asList(nodes).contains(node);
     }
 
@@ -326,9 +321,6 @@
         if (!super.hasEqualSemanticAttributes(other, testInterestingTagsOnly))
             return false;
-        for (int i = 0; i < getNodesCount(); i++) {
-            if (!getNode(i).hasEqualSemanticAttributes(w.getNode(i)))
-                return false;
-        }
-        return true;
+        return IntStream.range(0, getNodesCount())
+                .allMatch(i -> getNode(i).hasEqualSemanticAttributes(w.getNode(i)));
     }
 
@@ -373,11 +365,7 @@
         try {
             boolean closed = isClosed() && selection.contains(lastNode());
-            List<Node> copy = new ArrayList<>();
-
-            for (Node n: nodes) {
-                if (!selection.contains(n)) {
-                    copy.add(n);
-                }
-            }
+            List<Node> copy = Arrays.stream(nodes)
+                    .filter(n -> !selection.contains(n))
+                    .collect(Collectors.toList());
 
             int i = copy.size();
@@ -524,8 +512,6 @@
         /* circular ways have only inner nodes, so return true for them! */
         if (n == nodes[0] && n == nodes[nodes.length-1]) return true;
-        for (int i = 1; i < nodes.length - 1; ++i) {
-            if (nodes[i] == n) return true;
-        }
-        return false;
+        return IntStream.range(1, nodes.length - 1)
+                .anyMatch(i -> nodes[i] == n);
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/history/History.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/history/History.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/history/History.java	(revision 16445)
@@ -7,4 +7,5 @@
 import java.util.Date;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
@@ -26,10 +27,7 @@
 
     private static History filter(History history, FilterPredicate predicate) {
-        List<HistoryOsmPrimitive> out = new ArrayList<>();
-        for (HistoryOsmPrimitive primitive: history.versions) {
-            if (predicate.matches(primitive)) {
-                out.add(primitive);
-            }
-        }
+        List<HistoryOsmPrimitive> out = history.versions.stream()
+                .filter(predicate::matches)
+                .collect(Collectors.toList());
         return new History(history.id, history.type, out);
     }
@@ -175,9 +173,5 @@
      */
     public boolean contains(long version) {
-        for (HistoryOsmPrimitive primitive: versions) {
-            if (primitive.matches(id, version))
-                return true;
-        }
-        return false;
+        return versions.stream().anyMatch(primitive -> primitive.matches(id, version));
     }
 
@@ -190,9 +184,7 @@
      */
     public HistoryOsmPrimitive getByVersion(long version) {
-        for (HistoryOsmPrimitive primitive: versions) {
-            if (primitive.matches(id, version))
-                return primitive;
-        }
-        return null;
+        return versions.stream()
+                .filter(primitive -> primitive.matches(id, version))
+                .findFirst().orElse(null);
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java	(revision 16445)
@@ -6,10 +6,9 @@
 import java.util.Collection;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Set;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.Changeset;
@@ -112,9 +111,7 @@
         if (versions == null)
             return null;
-        for (HistoryOsmPrimitive primitive: versions) {
-            if (primitive.matches(id, version))
-                return primitive;
-        }
-        return null;
+        return versions.stream()
+                .filter(primitive -> primitive.matches(id, version))
+                .findFirst().orElse(null);
     }
 
@@ -199,11 +196,8 @@
      */
     public Collection<Long> getChangesetIds() {
-        final Set<Long> ids = new HashSet<>();
-        for (Collection<HistoryOsmPrimitive> i : data.values()) {
-            for (HistoryOsmPrimitive j : i) {
-                ids.add(j.getChangesetId());
-            }
-        }
-        return ids;
+        return data.values().stream()
+                .flatMap(Collection::stream)
+                .map(HistoryOsmPrimitive::getChangesetId)
+                .collect(Collectors.toSet());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/search/SearchCompiler.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/search/SearchCompiler.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/search/SearchCompiler.java	(revision 16445)
@@ -744,9 +744,6 @@
                     // But since we're doing a regex match we'll have to loop over all the keys to see if they match our regex,
                     // and only then try to match against the value
-                    for (String k: osm.keySet()) {
-                        if (keyPattern.matcher(k).find() && valuePattern.matcher(osm.get(k)).find()) {
-                            return true;
-                        }
-                    }
+                    return osm.keySet().stream()
+                            .anyMatch(k -> keyPattern.matcher(k).find() && valuePattern.matcher(osm.get(k)).find());
                 }
             } else {
@@ -768,10 +765,5 @@
                 mv = osm.get(key);
                 if (!caseSensitive && mv == null) {
-                    for (String k: osm.keySet()) {
-                        if (key.equalsIgnoreCase(k)) {
-                            mv = osm.get(k);
-                            break;
-                        }
-                    }
+                    mv = osm.keySet().stream().filter(key::equalsIgnoreCase).map(osm::get).findFirst().orElse(mv);
                 }
             }
@@ -984,31 +976,15 @@
                 return osm.hasTag(key);
             case ANY_KEY:
-                for (String v:osm.getKeys().values()) {
-                    if (v.equals(value))
-                        return true;
-                }
-                return false;
+                return osm.getKeys().values().stream().anyMatch(v -> v.equals(value));
             case EXACT:
                 return value.equals(osm.get(key));
             case ANY_KEY_REGEXP:
-                for (String v:osm.getKeys().values()) {
-                    if (valuePattern.matcher(v).matches())
-                        return true;
-                }
-                return false;
+                return osm.getKeys().values().stream().anyMatch(v -> valuePattern.matcher(v).matches());
             case ANY_VALUE_REGEXP:
             case EXACT_REGEXP:
-                for (String k : osm.keySet()) {
-                    if (keyPattern.matcher(k).matches()
-                            && (mode == Mode.ANY_VALUE_REGEXP || valuePattern.matcher(osm.get(k)).matches()))
-                        return true;
-                }
-                return false;
+                return osm.keySet().stream().anyMatch(k -> keyPattern.matcher(k).matches()
+                        && (mode == Mode.ANY_VALUE_REGEXP || valuePattern.matcher(osm.get(k)).matches()));
             case MISSING_KEY_REGEXP:
-                for (String k:osm.keySet()) {
-                    if (keyPattern.matcher(k).matches())
-                        return false;
-                }
-                return true;
+                return osm.keySet().stream().noneMatch(k -> keyPattern.matcher(k).matches());
             }
             throw new AssertionError("Missed state");
@@ -1279,16 +1255,9 @@
         @Override
         public boolean match(OsmPrimitive osm) {
-            for (OsmPrimitive ref: osm.getReferrers()) {
-                if (ref instanceof Relation && !ref.isIncomplete() && !ref.isDeleted()) {
-                    for (RelationMember m : ((Relation) ref).getMembers()) {
-                        if (m.getMember() == osm) {
-                            String testRole = m.getRole();
-                            if (role.equals(testRole == null ? "" : testRole))
-                                return true;
-                        }
-                    }
-                }
-            }
-            return false;
+            return osm.referrers(Relation.class)
+                    .filter(ref -> !ref.isIncomplete() && !ref.isDeleted())
+                    .flatMap(ref -> ref.getMembers().stream()).filter(m -> m.getMember() == osm)
+                    .map(RelationMember::getRole)
+                    .anyMatch(testRole -> role.equals(testRole == null ? "" : testRole));
         }
 
@@ -1698,16 +1667,11 @@
         @Override
         public boolean match(OsmPrimitive osm) {
-            boolean isParent = false;
-
             if (osm instanceof Way) {
-                for (Node n : ((Way) osm).getNodes()) {
-                    isParent |= match.match(n);
-                }
+                return ((Way) osm).getNodes().stream().anyMatch(match::match);
             } else if (osm instanceof Relation) {
-                for (RelationMember member : ((Relation) osm).getMembers()) {
-                    isParent |= match.match(member.getMember());
-                }
-            }
-            return isParent;
+                return ((Relation) osm).getMembers().stream().anyMatch(member -> match.match(member.getMember()));
+            } else {
+                return false;
+            }
         }
 
@@ -1729,9 +1693,5 @@
         @Override
         public boolean match(OsmPrimitive osm) {
-            boolean isChild = false;
-            for (OsmPrimitive p : osm.getReferrers()) {
-                isChild |= match.match(p);
-            }
-            return isChild;
+            return osm.getReferrers().stream().anyMatch(match::match);
         }
 
@@ -1931,11 +1891,5 @@
         @Override
         public boolean match(OsmPrimitive osm) {
-            for (TaggingPreset preset : this.presets) {
-                if (preset.test(osm)) {
-                    return true;
-                }
-            }
-
-            return false;
+            return this.presets.stream().anyMatch(preset -> preset.test(osm));
         }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/search/SearchMode.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/search/SearchMode.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/search/SearchMode.java	(revision 16445)
@@ -1,4 +1,6 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm.search;
+
+import java.util.Arrays;
 
 /**
@@ -36,9 +38,7 @@
      */
     public static SearchMode fromCode(char code) {
-        for (SearchMode mode: values()) {
-            if (mode.getCode() == code)
-                return mode;
-        }
-        return null;
+        return Arrays.stream(values())
+                .filter(mode -> mode.getCode() == code)
+                .findFirst().orElse(null);
     }
 }
Index: trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java	(revision 16445)
@@ -2,5 +2,4 @@
 package org.openstreetmap.josm.data.osm.visitor;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -20,4 +19,5 @@
 import org.openstreetmap.josm.data.osm.WayData;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
@@ -79,8 +79,5 @@
             return;
         WayData clone = w.save();
-        List<Long> newNodes = new ArrayList<>(w.getNodesCount());
-        for (Node n: w.getNodes()) {
-            newNodes.add(mappedPrimitives.get(n).getUniqueId());
-        }
+        List<Long> newNodes = Utils.transform(w.getNodes(), n -> mappedPrimitives.get(n).getUniqueId());
         clone.setNodeIds(newNodes);
         mappedPrimitives.put(w, clone);
Index: trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java	(revision 16445)
@@ -204,8 +204,5 @@
     public boolean isRegistered(Class<? extends AbstractMapRenderer> renderer) {
         CheckParameterUtil.ensureParameterNotNull(renderer);
-        for (Descriptor d: descriptors) {
-            if (d.getRenderer().equals(renderer)) return true;
-        }
-        return false;
+        return descriptors.stream().anyMatch(d -> d.getRenderer().equals(renderer));
     }
 
Index: trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/relations/Multipolygon.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/relations/Multipolygon.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/relations/Multipolygon.java	(revision 16445)
@@ -129,22 +129,10 @@
         boolean isOuterRole(String role) {
             if (role == null) return false;
-            for (String candidate: outerExactRoles) {
-                if (role.equals(candidate)) return true;
-            }
-            for (String candidate: outerRolePrefixes) {
-                if (role.startsWith(candidate)) return true;
-            }
-            return false;
+            return outerExactRoles.stream().anyMatch(role::equals) || outerRolePrefixes.stream().anyMatch(role::startsWith);
         }
 
         boolean isInnerRole(String role) {
             if (role == null) return false;
-            for (String candidate: innerExactRoles) {
-                if (role.equals(candidate)) return true;
-            }
-            for (String candidate: innerRolePrefixes) {
-                if (role.startsWith(candidate)) return true;
-            }
-            return false;
+            return innerExactRoles.stream().anyMatch(role::equals) || innerRolePrefixes.stream().anyMatch(role::startsWith);
         }
     }
@@ -482,9 +470,5 @@
             if (nodes.size() < 3 || !getFirstNode().equals(getLastNode()))
                 return false;
-            for (PolyData inner : inners) {
-                if (!inner.isClosed())
-                    return false;
-            }
-            return true;
+            return inners.stream().allMatch(PolyData::isClosed);
         }
 
Index: trunk/src/org/openstreetmap/josm/data/validation/TestError.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/TestError.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/TestError.java	(revision 16445)
@@ -13,4 +13,6 @@
 import java.util.TreeSet;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.openstreetmap.josm.command.Command;
@@ -281,4 +283,16 @@
 
     /**
+     * Gets all primitives of the given type affected by this error
+     * @param type restrict primitives to subclasses
+     * @param <T> type of primitives
+     * @return the primitives as Stream
+     */
+    public final <T extends OsmPrimitive> Stream<T> primitives(Class<T> type) {
+        return primitives.stream()
+                .filter(type::isInstance)
+                .map(type::cast);
+    }
+
+    /**
      * Gets the severity of this error
      * @return the severity of this error
@@ -308,9 +322,5 @@
             strings.add(type + '_' + o.getId());
         }
-        StringBuilder ignorestring = new StringBuilder(getIgnoreSubGroup());
-        for (String o : strings) {
-            ignorestring.append(':').append(o);
-        }
-        return ignorestring.toString();
+        return strings.stream().map(o -> ':' + o).collect(Collectors.joining("", getIgnoreSubGroup(), ""));
     }
 
Index: trunk/src/org/openstreetmap/josm/data/validation/routines/DomainValidator.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/routines/DomainValidator.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/routines/DomainValidator.java	(revision 16445)
@@ -20,4 +20,5 @@
 import java.util.Arrays;
 import java.util.Locale;
+import java.util.stream.IntStream;
 
 import org.openstreetmap.josm.tools.Logging;
@@ -1912,9 +1913,8 @@
             throw new IllegalStateException("Can only invoke this method before calling getInstance");
         }
-        String[] copy = new String[tlds.length];
         // Comparisons are always done with lower-case entries
-        for (int i = 0; i < tlds.length; i++) {
-            copy[i] = tlds[i].toLowerCase(Locale.ENGLISH);
-        }
+        String[] copy = Arrays.stream(tlds)
+                .map(tld -> tld.toLowerCase(Locale.ENGLISH))
+                .toArray(String[]::new);
         Arrays.sort(copy);
         switch(table) {
@@ -2040,10 +2040,5 @@
             return true;
         }
-        for (int i = 0; i < input.length(); i++) {
-            if (input.charAt(i) > 0x7F) { // CHECKSTYLE IGNORE MagicNumber
-                return false;
-            }
-        }
-        return true;
+        return IntStream.range(0, input.length()).noneMatch(i -> input.charAt(i) > 0x7F); // CHECKSTYLE IGNORE MagicNumber
     }
 
Index: trunk/src/org/openstreetmap/josm/data/validation/routines/RegexValidator.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/routines/RegexValidator.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/routines/RegexValidator.java	(revision 16445)
@@ -17,6 +17,10 @@
 package org.openstreetmap.josm.data.validation.routines;
 
+import java.util.Arrays;
+import java.util.Objects;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 /**
@@ -138,13 +142,6 @@
     @Override
     public boolean isValid(String value) {
-        if (value == null) {
-            return false;
-        }
-        for (int i = 0; i < patterns.length; i++) {
-            if (patterns[i].matcher(value).matches()) {
-                return true;
-            }
-        }
-        return false;
+        return value != null
+                && IntStream.range(0, patterns.length).anyMatch(i -> patterns[i].matcher(value).matches());
     }
 
@@ -166,13 +163,9 @@
             return null;
         }
-        for (int i = 0; i < patterns.length; i++) {
-            Matcher matcher = patterns[i].matcher(value);
+        for (Pattern pattern : patterns) {
+            Matcher matcher = pattern.matcher(value);
             if (matcher.matches()) {
                 int count = matcher.groupCount();
-                String[] groups = new String[count];
-                for (int j = 0; j < count; j++) {
-                    groups[j] = matcher.group(j+1);
-                }
-                return groups;
+                return IntStream.range(0, count).mapToObj(j -> matcher.group(j + 1)).toArray(String[]::new);
             }
         }
@@ -192,6 +185,6 @@
             return null;
         }
-        for (int i = 0; i < patterns.length; i++) {
-            Matcher matcher = patterns[i].matcher(value);
+        for (Pattern pattern : patterns) {
+            Matcher matcher = pattern.matcher(value);
             if (matcher.matches()) {
                 int count = matcher.groupCount();
@@ -199,12 +192,5 @@
                     return matcher.group(1);
                 }
-                StringBuilder buffer = new StringBuilder();
-                for (int j = 0; j < count; j++) {
-                    String component = matcher.group(j+1);
-                    if (component != null) {
-                        buffer.append(component);
-                    }
-                }
-                return buffer.toString();
+                return IntStream.range(0, count).mapToObj(j -> matcher.group(j + 1)).filter(Objects::nonNull).collect(Collectors.joining());
             }
         }
@@ -218,14 +204,6 @@
     @Override
     public String toString() {
-        StringBuilder buffer = new StringBuilder(32);
-        buffer.append("RegexValidator{");
-        for (int i = 0; i < patterns.length; i++) {
-            if (i > 0) {
-                buffer.append(',');
-            }
-            buffer.append(patterns[i].pattern());
-        }
-        buffer.append('}');
-        return buffer.toString();
+        return Arrays.stream(patterns).map(Pattern::pattern)
+                .collect(Collectors.joining(",", "RegexValidator{", "}"));
     }
 }
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java	(revision 16445)
@@ -6,4 +6,5 @@
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
@@ -245,5 +246,4 @@
      */
     private void checkForImpliedConnectivity(Relation relation, Map<String, Integer> roleLanes) {
-        boolean connImplied = true;
         Map<Integer, Map<Integer, Boolean>> connTagLanes = parseConnectivityTag(relation);
         // Don't flag connectivity as already implied when:
@@ -256,19 +256,12 @@
         //   the highway that they're merging into
 
-        connImplied = checkMemberTagsForImpliedConnectivity(relation, roleLanes) && !checkForIntersectionAtMembers(relation);
-        // Check if connectivity tag implies default connectivity
-        if (connImplied) {
-            for (Entry<Integer, Map<Integer, Boolean>> to : connTagLanes.entrySet()) {
-                int fromLane = to.getKey();
-                for (Entry<Integer, Boolean> lane : to.getValue().entrySet()) {
-                    if (lane.getKey() != null && fromLane != lane.getKey()) {
-                        connImplied = false;
-                        break;
-                    }
-                }
-                if (!connImplied)
-                    break;
-            }
-        }
+        boolean connImplied = checkMemberTagsForImpliedConnectivity(relation, roleLanes) && !checkForIntersectionAtMembers(relation)
+                // Check if connectivity tag implies default connectivity
+                && connTagLanes.entrySet().stream()
+                .noneMatch(to -> {
+                    int fromLane = to.getKey();
+                    return to.getValue().entrySet().stream()
+                            .anyMatch(lane -> lane.getKey() != null && fromLane != lane.getKey());
+                });
 
         if (connImplied) {
@@ -293,22 +286,13 @@
             List<Way> parentWays = viaNode.getParentWays();
             if (parentWays.size() > 2) {
-                for (Way thisWay : parentWays) {
-                    if (!relationMembers.contains(thisWay) && thisWay.hasTag("highway")) {
-                        return true;
-                    }
-                }
+                return parentWays.stream()
+                        .anyMatch(thisWay -> !relationMembers.contains(thisWay) && thisWay.hasTag("highway"));
             }
         } else if (viaPrim.getType() == OsmPrimitiveType.WAY) {
             Way viaWay = (Way) viaPrim;
-            for (Node thisNode : viaWay.getNodes()) {
-                List<Way> parentWays = thisNode.getParentWays();
-                if (parentWays.size() > 2) {
-                    for (Way thisWay : parentWays) {
-                        if (!relationMembers.contains(thisWay) && thisWay.hasTag("highway")) {
-                            return true;
-                        }
-                    }
-                }
-            }
+            return viaWay.getNodes().stream()
+                    .map(Node::getParentWays).filter(parentWays -> parentWays.size() > 2)
+                    .flatMap(Collection::stream)
+                    .anyMatch(thisWay -> !relationMembers.contains(thisWay) && thisWay.hasTag("highway"));
         }
         return false;
@@ -380,11 +364,5 @@
         necessaryRoles.add(VIA);
         necessaryRoles.add(TO);
-
-        List<String> roleList = new ArrayList<>();
-        for (RelationMember relationMember: relation.getMembers()) {
-            roleList.add(relationMember.getRole());
-        }
-
-        return !roleList.containsAll(necessaryRoles);
+        return !relation.getMemberRoles().containsAll(necessaryRoles);
     }
 
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java	(revision 16445)
@@ -13,4 +13,5 @@
 import java.util.Objects;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.coor.EastNorth;
@@ -240,9 +241,5 @@
             Set<String> s1 = getBoundaryTags(w1);
             Set<String> s2 = getBoundaryTags(w2);
-            for (String type : s1) {
-                if (s2.contains(type))
-                    return false;
-            }
-            return true;
+            return s1.stream().noneMatch(s2::contains);
         }
 
@@ -421,9 +418,7 @@
      */
     public static List<List<WaySegment>> getSegments(Map<Point2D, List<WaySegment>> cellSegments, EastNorth n1, EastNorth n2) {
-        List<List<WaySegment>> cells = new ArrayList<>();
-        for (Point2D cell : ValUtil.getSegmentCells(n1, n2, OsmValidator.getGridDetail())) {
-            cells.add(cellSegments.computeIfAbsent(cell, k -> new ArrayList<>()));
-        }
-        return cells;
+        return ValUtil.getSegmentCells(n1, n2, OsmValidator.getGridDetail()).stream()
+                .map(cell -> cellSegments.computeIfAbsent(cell, k -> new ArrayList<>()))
+                .collect(Collectors.toList());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateNode.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateNode.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateNode.java	(revision 16445)
@@ -10,5 +10,4 @@
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
@@ -16,4 +15,5 @@
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -135,11 +135,8 @@
             // multiple nodes at the same position -> check if all nodes have a distinct elevation
             List<Node> nodes = (List<Node>) v;
-            Set<String> eles = new HashSet<>();
-            for (Node n : nodes) {
-                String ele = n.get("ele");
-                if (ele != null) {
-                    eles.add(ele);
-                }
-            }
+            Set<String> eles = nodes.stream()
+                    .map(n -> n.get("ele"))
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toSet());
             if (eles.size() == nodes.size()) {
                 // All nodes at this position have a distinct elevation.
@@ -310,7 +307,5 @@
     @Override
     public Command fixError(TestError testError) {
-        final Set<Node> nodes = testError.getPrimitives().stream()
-                .filter(Node.class::isInstance)
-                .map(Node.class::cast)
+        final Set<Node> nodes = testError.primitives(Node.class)
                 // Filter nodes that have already been deleted (see #5764 and #5773)
                 .filter(n -> !n.isDeleted())
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateRelation.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateRelation.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateRelation.java	(revision 16445)
@@ -247,12 +247,7 @@
     public Command fixError(TestError testError) {
         if (testError.getCode() == SAME_RELATION) return null;
-        Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
-        Set<Relation> relFix = new HashSet<>();
-
-        for (OsmPrimitive osm : sel) {
-            if (osm instanceof Relation && !osm.isDeleted()) {
-                relFix.add((Relation) osm);
-            }
-        }
+        Set<Relation> relFix = testError.primitives(Relation.class)
+                .filter(r -> !r.isDeleted())
+                .collect(Collectors.toSet());
 
         if (relFix.size() < 2)
@@ -308,12 +303,6 @@
 
         // We fix it only if there is no more than one relation that is relation member.
-        Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
-        Set<Relation> rels = new HashSet<>();
-
-        for (OsmPrimitive osm : sel) {
-            if (osm instanceof Relation) {
-                rels.add((Relation) osm);
-            }
-        }
+        Set<Relation> rels = testError.primitives(Relation.class)
+                .collect(Collectors.toSet());
 
         if (rels.size() < 2)
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateWay.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateWay.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateWay.java	(revision 16445)
@@ -14,4 +14,5 @@
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 import org.openstreetmap.josm.command.ChangeCommand;
@@ -227,7 +228,7 @@
                 }
             }
-            for (int i = lowestIndex; i < wNodes.size()-1; i++) {
-                wNodesToUse.add(wNodes.get(i));
-            }
+            IntStream.range(lowestIndex, wNodes.size() - 1)
+                    .mapToObj(wNodes::get)
+                    .forEach(wNodesToUse::add);
             for (int i = 0; i < lowestIndex; i++) {
                 wNodesToUse.add(wNodes.get(i));
@@ -238,9 +239,8 @@
         }
         // Build the list of lat/lon
-        List<LatLon> wLat = new ArrayList<>(wNodesToUse.size());
-        for (Node node : wNodesToUse) {
-            wLat.add(node.getCoor());
-        }
-        return wLat;
+
+        return wNodesToUse.stream()
+                .map(Node::getCoor)
+                .collect(Collectors.toList());
     }
 
@@ -250,12 +250,7 @@
     @Override
     public Command fixError(TestError testError) {
-        Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
-        Set<Way> wayz = new HashSet<>();
-
-        for (OsmPrimitive osm : sel) {
-            if (osm instanceof Way && !osm.isDeleted()) {
-                wayz.add((Way) osm);
-            }
-        }
+        Set<Way> wayz = testError.primitives(Way.class)
+                .filter(w -> !w.isDeleted())
+                .collect(Collectors.toSet());
 
         if (wayz.size() < 2)
@@ -315,23 +310,11 @@
 
         // We fix it only if there is no more than one way that is relation member.
-        Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
-        Set<Way> wayz = new HashSet<>();
-
-        for (OsmPrimitive osm : sel) {
-            if (osm instanceof Way) {
-                wayz.add((Way) osm);
-            }
-        }
-
+        Set<Way> wayz = testError.primitives(Way.class).collect(Collectors.toSet());
         if (wayz.size() < 2)
             return false;
 
-        int waysWithRelations = 0;
-        for (Way w : wayz) {
-            List<Relation> rel = w.referrers(Relation.class).collect(Collectors.toList());
-            if (!rel.isEmpty()) {
-                ++waysWithRelations;
-            }
-        }
+        long waysWithRelations = wayz.stream()
+                .filter(w -> w.referrers(Relation.class).anyMatch(x -> true))
+                .count();
         return waysWithRelations <= 1;
     }
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/MapCSSTagChecker.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/MapCSSTagChecker.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/MapCSSTagChecker.java	(revision 16445)
@@ -16,5 +16,4 @@
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -27,4 +26,5 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -463,8 +463,7 @@
             try {
                 final Selector matchingSelector = whichSelectorMatchesPrimitive(p);
-                Collection<Command> cmds = new LinkedList<>();
-                for (FixCommand fixCommand : fixCommands) {
-                    cmds.add(fixCommand.createCommand(p, matchingSelector));
-                }
+                Collection<Command> cmds = fixCommands.stream()
+                        .map(fixCommand -> fixCommand.createCommand(p, matchingSelector))
+                        .collect(Collectors.toList());
                 if (deletion && !p.isDeleted()) {
                     cmds.add(new DeleteCommand(p));
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/MultipolygonTest.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/MultipolygonTest.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/MultipolygonTest.java	(revision 16445)
@@ -16,4 +16,6 @@
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 import org.openstreetmap.josm.command.ChangeCommand;
@@ -191,11 +193,9 @@
                     .build());
         }
-        Map<Long, RelationMember> wayMap = new HashMap<>();
-        for (int i = 0; i < r.getMembersCount(); i++) {
-            RelationMember mem = r.getMember(i);
-            if (!mem.isWay())
-                continue;
-            wayMap.put(mem.getWay().getUniqueId(), mem); // duplicate members were checked before
-        }
+
+        Map<Long, RelationMember> wayMap = r.getMembers().stream()
+                .filter(RelationMember::isWay)
+                .collect(Collectors.toMap(mem -> mem.getWay().getUniqueId(), mem -> mem, (a, b) -> b));
+        // duplicate members were checked before
         if (wayMap.isEmpty())
             return;
@@ -230,11 +230,6 @@
             }
         }
-        boolean checkRoles = true;
-        for (int i = oldErrorsSize; i < errors.size(); i++) {
-            if (errors.get(i).getSeverity() != Severity.OTHER) {
-                checkRoles = false;
-                break;
-            }
-        }
+        boolean checkRoles = IntStream.range(oldErrorsSize, errors.size())
+                .noneMatch(i -> errors.get(i).getSeverity() != Severity.OTHER);
         if (checkRoles) {
             // we found no intersection or crossing between the polygons and they are closed
@@ -251,10 +246,5 @@
      */
     private static boolean hasIntersectionWay(PolyData pd, Set<Way> intersectionWays) {
-        for (Way w : intersectionWays) {
-            if (pd.getWayIds().contains(w.getUniqueId())) {
-                return true;
-            }
-        }
-        return false;
+        return intersectionWays.stream().anyMatch(w -> pd.getWayIds().contains(w.getUniqueId()));
     }
 
@@ -874,9 +864,7 @@
          */
         private Node getNonIntersectingNode(PolyData pd1, PolyData pd2) {
-            for (Node n : pd2.getNodes()) {
-                if (!sharedNodes.contains(n) || !pd1.getNodes().contains(n))
-                    return n;
-            }
-            return null;
+            return pd2.getNodes().stream()
+                    .filter(n -> !sharedNodes.contains(n) || !pd1.getNodes().contains(n))
+                    .findFirst().orElse(null);
         }
     }
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/PowerLines.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/PowerLines.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/PowerLines.java	(revision 16445)
@@ -90,6 +90,5 @@
     public void endTest() {
         for (TestError e : potentialErrors) {
-            e.getPrimitives().stream()
-                    .map(Node.class::cast)
+            e.primitives(Node.class)
                     .filter(n -> !isInPowerStation(n))
                     .findAny()
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/RelationChecker.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/RelationChecker.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/RelationChecker.java	(revision 16445)
@@ -97,9 +97,6 @@
         }
         for (TaggingPreset p : TaggingPresets.getTaggingPresets()) {
-            for (TaggingPresetItem i : p.data) {
-                if (i instanceof Roles) {
-                    relationpresets.add(p);
-                    break;
-                }
+            if (p.data.stream().anyMatch(i -> i instanceof Roles)) {
+                relationpresets.add(p);
             }
         }
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java	(revision 16445)
@@ -637,10 +637,8 @@
             EnumSet<TaggingPresetType> presetTypes = EnumSet.of(presetType);
 
-            Collection<TaggingPreset> matchingPresets = new LinkedHashSet<>();
-            for (Entry<TaggingPreset, List<TaggingPresetItem>> e : presetIndex.entrySet()) {
-                if (TaggingPresetItem.matches(e.getValue(), tags)) {
-                    matchingPresets.add(e.getKey());
-                }
-            }
+            Collection<TaggingPreset> matchingPresets = presetIndex.entrySet().stream()
+                    .filter(e -> TaggingPresetItem.matches(e.getValue(), tags))
+                    .map(Entry::getKey)
+                    .collect(Collectors.toCollection(LinkedHashSet::new));
             Collection<TaggingPreset> matchingPresetsOK = matchingPresets.stream().filter(
                     tp -> tp.typeMatches(presetTypes)).collect(Collectors.toList());
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/UnclosedWays.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/UnclosedWays.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/UnclosedWays.java	(revision 16445)
@@ -9,4 +9,5 @@
 import java.util.HashSet;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.OsmUtils;
@@ -168,9 +169,5 @@
      */
     public Set<String> getCheckedKeys() {
-        Set<String> keys = new HashSet<>();
-        for (UnclosedWaysCheck c : checks) {
-            keys.add(c.key);
-        }
-        return keys;
+        return Arrays.stream(checks).map(c -> c.key).collect(Collectors.toSet());
     }
 
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/WayConnectedToArea.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/WayConnectedToArea.java	(revision 16444)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/WayConnectedToArea.java	(revision 16445)
@@ -35,12 +35,6 @@
         }
 
-        boolean hasway = false;
         List<OsmPrimitive> r = w.firstNode().getReferrers();
-        for (OsmPrimitive p : r) {
-            if (p != w && p.hasKey(HIGHWAY)) {
-                hasway = true;
-                break;
-            }
-        }
+        boolean hasway = r.stream().anyMatch(p -> p != w && p.hasKey(HIGHWAY));
         if (!hasway) {
             for (OsmPrimitive p : r) {
@@ -48,12 +42,6 @@
             }
         }
-        hasway = false;
         r = w.lastNode().getReferrers();
-        for (OsmPrimitive p : r) {
-            if (p != w && p.hasKey(HIGHWAY)) {
-                hasway = true;
-                break;
-            }
-        }
+        hasway = r.stream().anyMatch(p -> p != w && p.hasKey(HIGHWAY));
         if (!hasway) {
             for (OsmPrimitive p : r) {
@@ -70,12 +58,8 @@
             addPossibleError(w, wayNode, p, p);
         } else {
-            for (OsmPrimitive r : p.getReferrers()) {
-                if (r instanceof Relation
-                        && r.hasTag("type", "multipolygon")
-                        && isArea(r)) {
-                    addPossibleError(w, wayNode, p, r);
-                    break;
-                }
-            }
+            p.referrers(Relation.class)
+                    .filter(r -> r.isMultipolygon() && isArea(r))
+                    .findFirst()
+                    .ifPresent(r -> addPossibleError(w, wayNode, p, r));
         }
     }