Changeset 16445 in josm


Ignore:
Timestamp:
2020-05-17T17:02:28+02:00 (3 weeks ago)
Author:
simon04
Message:

see #19251 - Java 8: use Stream

Location:
trunk
Files:
42 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/osm/CyclicUploadDependencyException.java

    r12673 r16445  
    88import java.util.List;
    99import java.util.Stack;
     10import java.util.stream.Collectors;
    1011
    1112/**
     
    3839    @Override
    3940    public String getMessage() {
    40         StringBuilder sb = new StringBuilder();
    41         sb.append(tr("Cyclic dependency between relations:"))
    42           .append('[');
    43         for (int i = 0; i < cycle.size(); i++) {
    44             if (i > 0) {
    45                 sb.append(',');
    46             }
    47             sb.append(formatRelation(cycle.get(i)));
    48         }
    49         sb.append(']');
    50         return sb.toString();
     41        return cycle.stream().map(this::formatRelation)
     42                .collect(Collectors.joining(",", tr("Cyclic dependency between relations:") + '[', "]"));
    5143    }
    5244
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r16212 r16445  
    213213                Way newWay = new Way(w, false, false);
    214214                primMap.put(w, newWay);
    215                 List<Node> newNodes = new ArrayList<>();
    216                 for (Node n : w.getNodes()) {
    217                     newNodes.add((Node) primMap.get(n));
    218                 }
     215                List<Node> newNodes = w.getNodes().stream()
     216                        .map(n -> (Node) primMap.get(n))
     217                        .collect(Collectors.toList());
    219218                newWay.setNodes(newNodes);
    220219                addPrimitive(newWay);
  • trunk/src/org/openstreetmap/josm/data/osm/DefaultNameFormatter.java

    r16438 r16445  
    1818import java.util.Locale;
    1919import java.util.Map;
     20import java.util.Objects;
    2021import java.util.Set;
    2122import java.util.stream.Collectors;
     
    220221
    221222        String result = name.toString();
    222         for (NameFormatterHook hook: formatHooks) {
    223             String hookResult = hook.checkFormat(node, result);
    224             if (hookResult != null)
    225                 return hookResult;
    226         }
    227 
    228         return result;
     223        return formatHooks.stream().map(hook -> hook.checkFormat(node, result))
     224                .filter(Objects::nonNull)
     225                .findFirst().orElse(result);
     226
    229227    }
    230228
     
    312310
    313311        String result = name.toString();
    314         for (NameFormatterHook hook: formatHooks) {
    315             String hookResult = hook.checkFormat(way, result);
    316             if (hookResult != null)
    317                 return hookResult;
    318         }
    319 
    320         return result;
     312        return formatHooks.stream().map(hook -> hook.checkFormat(way, result))
     313                .filter(Objects::nonNull)
     314                .findFirst().orElse(result);
     315
    321316    }
    322317
     
    350345
    351346        String result = name.toString();
    352         for (NameFormatterHook hook: formatHooks) {
    353             String hookResult = hook.checkFormat(relation, result);
    354             if (hookResult != null)
    355                 return hookResult;
    356         }
    357 
    358         return result;
     347        return formatHooks.stream().map(hook -> hook.checkFormat(relation, result))
     348                .filter(Objects::nonNull)
     349                .findFirst().orElse(result);
     350
    359351    }
    360352
     
    463455                return relation.getName();
    464456        } else if (":LocationCode".equals(nameTag)) {
    465             for (String m : relation.keySet()) {
    466                 if (m.endsWith(nameTag))
    467                     return relation.get(m);
    468             }
    469             return null;
     457            return relation.keySet().stream()
     458                    .filter(m -> m.endsWith(nameTag))
     459                    .map(relation::get)
     460                    .findFirst().orElse(null);
    470461        } else if (nameTag.startsWith("?") && OsmUtils.isTrue(relation.get(nameTag.substring(1)))) {
    471462            return tr(nameTag.substring(1));
  • trunk/src/org/openstreetmap/josm/data/osm/FilterMatcher.java

    r14206 r16445  
    202202
    203203    private static boolean oneParentWayNotFiltered(OsmPrimitive primitive, boolean hidden) {
    204         List<OsmPrimitive> refs = primitive.getReferrers();
    205         for (OsmPrimitive p: refs) {
    206             if (p instanceof Way && !isFiltered(p, hidden))
    207                 return true;
    208         }
    209 
    210         return false;
     204        return primitive.referrers(Way.class)
     205                .anyMatch(p -> !isFiltered(p, hidden));
    211206    }
    212207
     
    223218
    224219    private static boolean oneParentMultipolygonNotFiltered(OsmPrimitive primitive, boolean hidden) {
    225         for (Relation r : new SubclassFilteredCollection<OsmPrimitive, Relation>(
    226                 primitive.getReferrers(), OsmPrimitive::isMultipolygon)) {
    227             if (!isFiltered(r, hidden))
    228                 return true;
    229         }
    230         return false;
     220        return new SubclassFilteredCollection<OsmPrimitive, Relation>(primitive.getReferrers(), OsmPrimitive::isMultipolygon).stream()
     221                .anyMatch(r -> !isFiltered(r, hidden));
    231222    }
    232223
  • trunk/src/org/openstreetmap/josm/data/osm/FilterModel.java

    r16187 r16445  
    1414import java.util.Set;
    1515import java.util.Stack;
     16import java.util.stream.Collectors;
    1617
    1718import javax.swing.JOptionPane;
     
    8889     */
    8990    public void savePrefs(String prefEntry) {
    90         Collection<FilterPreferenceEntry> entries = new ArrayList<>();
    91         for (Filter flt : filters) {
    92             entries.add(flt.getPreferenceEntry());
    93         }
     91        Collection<FilterPreferenceEntry> entries = filters.stream()
     92                .map(Filter::getPreferenceEntry)
     93                .collect(Collectors.toList());
    9494        StructUtils.putListOfStructs(Config.getPref(), prefEntry, entries, FilterPreferenceEntry.class);
    9595    }
  • trunk/src/org/openstreetmap/josm/data/osm/IRelation.java

    r16119 r16445  
    33
    44import java.util.Collection;
    5 import java.util.HashSet;
    65import java.util.List;
    7 import java.util.Set;
    86import java.util.stream.Collectors;
    97
     
    125123     */
    126124    default Collection<? extends IPrimitive> getIncompleteMembers() {
    127         Set<IPrimitive> ret = new HashSet<>();
    128         for (M rm : getMembers()) {
    129             if (!rm.getMember().isIncomplete()) {
    130                 continue;
    131             }
    132             ret.add(rm.getMember());
    133         }
    134         return ret;
     125        return getMembers().stream()
     126                .filter(rm -> rm.getMember().isIncomplete())
     127                .map(rm -> rm.getMember())
     128                .collect(Collectors.toSet());
    135129    }
    136130
  • trunk/src/org/openstreetmap/josm/data/osm/NodeGraph.java

    r15574 r16445  
    1818import java.util.Set;
    1919import java.util.TreeMap;
     20import java.util.stream.Collectors;
     21import java.util.stream.Stream;
    2022
    2123import org.openstreetmap.josm.tools.Pair;
     
    210212
    211213    protected Set<Node> getTerminalNodes() {
    212         Set<Node> ret = new LinkedHashSet<>();
    213         for (Node n: getNodes()) {
    214             if (isTerminalNode(n)) {
    215                 ret.add(n);
    216             }
    217         }
    218         return ret;
     214        return getNodes().stream().filter(this::isTerminalNode).collect(Collectors.toCollection(LinkedHashSet::new));
    219215    }
    220216
     
    248244
    249245    protected List<Node> buildPathFromNodePairs(Deque<NodePair> path) {
    250         List<Node> ret = new ArrayList<>(path.size() + 1);
    251         for (NodePair pair : path) {
    252             ret.add(pair.getA());
    253         }
    254         ret.add(path.peekLast().getB());
    255         return ret;
     246        return Stream.concat(path.stream().map(NodePair::getA), Stream.of(path.peekLast().getB()))
     247                .collect(Collectors.toList());
    256248    }
    257249
     
    307299            Set<Node> nodes = getTerminalNodes();
    308300            nodes = nodes.isEmpty() ? getMostFrequentVisitedNodesFirst() : nodes;
    309             for (Node n : nodes) {
    310                 List<Node> path = buildSpanningPath(n);
    311                 if (!path.isEmpty())
    312                     return path;
    313             }
     301            return nodes.stream()
     302                    .map(this::buildSpanningPath)
     303                    .filter(path -> !path.isEmpty())
     304                    .findFirst().orElse(null);
    314305        }
    315306        return null;
  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitiveType.java

    r15820 r16445  
    101101     */
    102102    public static OsmPrimitiveType from(String value) {
    103         for (OsmPrimitiveType type: values()) {
    104             if (type.getAPIName().equalsIgnoreCase(value))
    105                 return type;
    106         }
    107         return null;
     103        return Arrays.stream(values())
     104                .filter(type -> type.getAPIName().equalsIgnoreCase(value))
     105                .findFirst().orElse(null);
    108106    }
    109107
  • trunk/src/org/openstreetmap/josm/data/osm/PrimitiveData.java

    r15820 r16445  
    66import java.io.ObjectOutputStream;
    77import java.io.Serializable;
    8 import java.util.ArrayList;
    98import java.util.Arrays;
    109import java.util.Collection;
     
    1211import java.util.List;
    1312import java.util.Map;
     13import java.util.stream.Collectors;
    1414
    1515import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
     
    8888     * @return a filtered list for given primitive type
    8989     */
    90     @SuppressWarnings("unchecked")
    9190    public static <T extends PrimitiveData> List<T> getFilteredList(Collection<T> list, OsmPrimitiveType type) {
    92         List<T> ret = new ArrayList<>();
    93         for (PrimitiveData p: list) {
    94             if (type.getDataClass().isInstance(p)) {
    95                 ret.add((T) p);
    96             }
    97         }
    98         return ret;
     91        return list.stream().filter(p -> type.getDataClass().isInstance(p)).map(p -> (T) p).collect(Collectors.toList());
    9992    }
    10093
  • trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java

    r15891 r16445  
    99import java.util.List;
    1010import java.util.NoSuchElementException;
     11import java.util.stream.IntStream;
    1112
    1213import org.openstreetmap.josm.data.coor.LatLon;
     
    321322        int indexOf(QBLevel<T> findThis) {
    322323            QBLevel<T>[] children = getChildren();
    323             for (int i = 0; i < QuadTiling.TILES_PER_LEVEL; i++) {
    324                 if (children[i] == findThis) {
    325                     return i;
    326                 }
    327             }
    328             return -1;
     324            return IntStream.range(0, QuadTiling.TILES_PER_LEVEL)
     325                    .filter(i -> children[i] == findThis)
     326                    .findFirst().orElse(-1);
    329327        }
    330328
     
    406404    @Override
    407405    public boolean removeAll(Collection<?> objects) {
    408         boolean changed = false;
    409         for (Object o : objects) {
    410             changed |= remove(o);
    411         }
    412         return changed;
     406        return objects.stream().map(this::remove).reduce(false, (a, b) -> a || b);
    413407    }
    414408
    415409    @Override
    416410    public boolean addAll(Collection<? extends T> objects) {
    417         boolean changed = false;
    418         for (T o : objects) {
    419             changed |= add(o);
    420         }
    421         return changed;
     411        return objects.stream().map(this::add).reduce(false, (a, b) -> a || b);
    422412    }
    423413
    424414    @Override
    425415    public boolean containsAll(Collection<?> objects) {
    426         for (Object o : objects) {
    427             if (!this.contains(o)) {
    428                 return false;
    429             }
    430         }
    431         return true;
     416        return objects.stream().allMatch(this::contains);
    432417    }
    433418
  • trunk/src/org/openstreetmap/josm/data/osm/Relation.java

    r16212 r16445  
    22package org.openstreetmap.josm.data.osm;
    33
    4 import java.util.ArrayList;
    54import java.util.Arrays;
    65import java.util.Collection;
     
    274273            RelationData relationData = (RelationData) data;
    275274
    276             List<RelationMember> newMembers = new ArrayList<>();
    277             for (RelationMemberData member : relationData.getMembers()) {
    278                 newMembers.add(new RelationMember(member.getRole(), Optional.ofNullable(getDataSet().getPrimitiveById(member))
    279                         .orElseThrow(() -> new AssertionError("Data consistency problem - relation with missing member detected"))));
    280             }
     275            List<RelationMember> newMembers = relationData.getMembers().stream()
     276                    .map(member -> new RelationMember(member.getRole(), Optional
     277                            .ofNullable(getDataSet().getPrimitiveById(member))
     278                            .orElseThrow(() -> new AssertionError("Data consistency problem - relation with missing member detected"))))
     279                    .collect(Collectors.toList());
    281280            setMembers(newMembers);
    282281        } finally {
     
    510509    @Override
    511510    public boolean hasIncompleteMembers() {
    512         for (RelationMember rm: members) {
    513             if (rm.getMember().isIncomplete()) return true;
    514         }
    515         return false;
     511        return Arrays.stream(members).anyMatch(rm -> rm.getMember().isIncomplete());
    516512    }
    517513
     
    523519    @Override
    524520    public Collection<OsmPrimitive> getIncompleteMembers() {
    525         Set<OsmPrimitive> ret = new HashSet<>();
    526         for (RelationMember rm: members) {
    527             if (!rm.getMember().isIncomplete()) {
    528                 continue;
    529             }
    530             ret.add(rm.getMember());
    531         }
    532         return ret;
     521        return Arrays.stream(members)
     522                .filter(rm -> rm.getMember().isIncomplete())
     523                .map(RelationMember::getMember)
     524                .collect(Collectors.toSet());
    533525    }
    534526
  • trunk/src/org/openstreetmap/josm/data/osm/RelationToChildReference.java

    r14654 r16445  
    33
    44import java.util.Collection;
    5 import java.util.HashSet;
    65import java.util.Objects;
    76import java.util.Set;
    87import java.util.stream.Collectors;
     8import java.util.stream.IntStream;
    99
    1010/**
     
    2121    public static Set<RelationToChildReference> getRelationToChildReferences(OsmPrimitive child) {
    2222        Set<Relation> parents = child.referrers(Relation.class).collect(Collectors.toSet());
    23         Set<RelationToChildReference> references = new HashSet<>();
    24         for (Relation parent: parents) {
    25             for (int i = 0; i < parent.getMembersCount(); i++) {
    26                 if (parent.getMember(i).refersTo(child)) {
    27                     references.add(new RelationToChildReference(parent, i, parent.getMember(i)));
    28                 }
    29             }
    30         }
    31         return references;
     23        return parents.stream().flatMap(parent1 -> IntStream.range(0, parent1.getMembersCount())
     24                .filter(i -> parent1.getMember(i).refersTo(child))
     25                .mapToObj(i -> new RelationToChildReference(parent1, i, parent1.getMember(i))))
     26                .collect(Collectors.toSet());
    3227    }
    3328
     
    4035     */
    4136    public static Set<RelationToChildReference> getRelationToChildReferences(Collection<? extends OsmPrimitive> children) {
    42         Set<RelationToChildReference> references = new HashSet<>();
    43         for (OsmPrimitive child: children) {
    44             references.addAll(getRelationToChildReferences(child));
    45         }
    46         return references;
     37        return children.stream()
     38                .flatMap(child -> getRelationToChildReferences(child).stream())
     39                .collect(Collectors.toSet());
    4740    }
    4841
  • trunk/src/org/openstreetmap/josm/data/osm/Storage.java

    r14273 r16445  
    239239    @Override
    240240    public synchronized int hashCode() {
    241         int h = 0;
    242         if (hash != null) {
    243             for (T t : this) {
    244                 h += hash.getHashCode(t);
    245             }
    246         }
    247         return h;
     241        if (hash == null) {
     242            return 0;
     243        }
     244        return this.stream().mapToInt(hash::getHashCode).sum();
    248245    }
    249246
  • trunk/src/org/openstreetmap/josm/data/osm/Way.java

    r16212 r16445  
    1111import java.util.Set;
    1212import java.util.stream.Collectors;
     13import java.util.stream.IntStream;
    1314
    1415import org.openstreetmap.josm.data.coor.LatLon;
     
    120121     */
    121122    public boolean containsNode(Node node) {
    122         if (node == null) return false;
    123 
    124         for (Node n : nodes) {
    125             if (n.equals(node))
    126                 return true;
    127         }
    128         return false;
     123        return node != null && Arrays.asList(nodes).contains(node);
    129124    }
    130125
     
    326321        if (!super.hasEqualSemanticAttributes(other, testInterestingTagsOnly))
    327322            return false;
    328         for (int i = 0; i < getNodesCount(); i++) {
    329             if (!getNode(i).hasEqualSemanticAttributes(w.getNode(i)))
    330                 return false;
    331         }
    332         return true;
     323        return IntStream.range(0, getNodesCount())
     324                .allMatch(i -> getNode(i).hasEqualSemanticAttributes(w.getNode(i)));
    333325    }
    334326
     
    373365        try {
    374366            boolean closed = isClosed() && selection.contains(lastNode());
    375             List<Node> copy = new ArrayList<>();
    376 
    377             for (Node n: nodes) {
    378                 if (!selection.contains(n)) {
    379                     copy.add(n);
    380                 }
    381             }
     367            List<Node> copy = Arrays.stream(nodes)
     368                    .filter(n -> !selection.contains(n))
     369                    .collect(Collectors.toList());
    382370
    383371            int i = copy.size();
     
    524512        /* circular ways have only inner nodes, so return true for them! */
    525513        if (n == nodes[0] && n == nodes[nodes.length-1]) return true;
    526         for (int i = 1; i < nodes.length - 1; ++i) {
    527             if (nodes[i] == n) return true;
    528         }
    529         return false;
     514        return IntStream.range(1, nodes.length - 1)
     515                .anyMatch(i -> nodes[i] == n);
    530516    }
    531517
  • trunk/src/org/openstreetmap/josm/data/osm/history/History.java

    r10647 r16445  
    77import java.util.Date;
    88import java.util.List;
     9import java.util.stream.Collectors;
    910
    1011import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     
    2627
    2728    private static History filter(History history, FilterPredicate predicate) {
    28         List<HistoryOsmPrimitive> out = new ArrayList<>();
    29         for (HistoryOsmPrimitive primitive: history.versions) {
    30             if (predicate.matches(primitive)) {
    31                 out.add(primitive);
    32             }
    33         }
     29        List<HistoryOsmPrimitive> out = history.versions.stream()
     30                .filter(predicate::matches)
     31                .collect(Collectors.toList());
    3432        return new History(history.id, history.type, out);
    3533    }
     
    175173     */
    176174    public boolean contains(long version) {
    177         for (HistoryOsmPrimitive primitive: versions) {
    178             if (primitive.matches(id, version))
    179                 return true;
    180         }
    181         return false;
     175        return versions.stream().anyMatch(primitive -> primitive.matches(id, version));
    182176    }
    183177
     
    190184     */
    191185    public HistoryOsmPrimitive getByVersion(long version) {
    192         for (HistoryOsmPrimitive primitive: versions) {
    193             if (primitive.matches(id, version))
    194                 return primitive;
    195         }
    196         return null;
     186        return versions.stream()
     187                .filter(primitive -> primitive.matches(id, version))
     188                .findFirst().orElse(null);
    197189    }
    198190
  • trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java

    r16123 r16445  
    66import java.util.Collection;
    77import java.util.HashMap;
    8 import java.util.HashSet;
    98import java.util.List;
    109import java.util.Map;
    1110import java.util.Objects;
    12 import java.util.Set;
    1311import java.util.concurrent.CopyOnWriteArrayList;
     12import java.util.stream.Collectors;
    1413
    1514import org.openstreetmap.josm.data.osm.Changeset;
     
    112111        if (versions == null)
    113112            return null;
    114         for (HistoryOsmPrimitive primitive: versions) {
    115             if (primitive.matches(id, version))
    116                 return primitive;
    117         }
    118         return null;
     113        return versions.stream()
     114                .filter(primitive -> primitive.matches(id, version))
     115                .findFirst().orElse(null);
    119116    }
    120117
     
    199196     */
    200197    public Collection<Long> getChangesetIds() {
    201         final Set<Long> ids = new HashSet<>();
    202         for (Collection<HistoryOsmPrimitive> i : data.values()) {
    203             for (HistoryOsmPrimitive j : i) {
    204                 ids.add(j.getChangesetId());
    205             }
    206         }
    207         return ids;
     198        return data.values().stream()
     199                .flatMap(Collection::stream)
     200                .map(HistoryOsmPrimitive::getChangesetId)
     201                .collect(Collectors.toSet());
    208202    }
    209203
  • trunk/src/org/openstreetmap/josm/data/osm/search/SearchCompiler.java

    r16263 r16445  
    744744                    // But since we're doing a regex match we'll have to loop over all the keys to see if they match our regex,
    745745                    // and only then try to match against the value
    746                     for (String k: osm.keySet()) {
    747                         if (keyPattern.matcher(k).find() && valuePattern.matcher(osm.get(k)).find()) {
    748                             return true;
    749                         }
    750                     }
     746                    return osm.keySet().stream()
     747                            .anyMatch(k -> keyPattern.matcher(k).find() && valuePattern.matcher(osm.get(k)).find());
    751748                }
    752749            } else {
     
    768765                mv = osm.get(key);
    769766                if (!caseSensitive && mv == null) {
    770                     for (String k: osm.keySet()) {
    771                         if (key.equalsIgnoreCase(k)) {
    772                             mv = osm.get(k);
    773                             break;
    774                         }
    775                     }
     767                    mv = osm.keySet().stream().filter(key::equalsIgnoreCase).map(osm::get).findFirst().orElse(mv);
    776768                }
    777769            }
     
    984976                return osm.hasTag(key);
    985977            case ANY_KEY:
    986                 for (String v:osm.getKeys().values()) {
    987                     if (v.equals(value))
    988                         return true;
    989                 }
    990                 return false;
     978                return osm.getKeys().values().stream().anyMatch(v -> v.equals(value));
    991979            case EXACT:
    992980                return value.equals(osm.get(key));
    993981            case ANY_KEY_REGEXP:
    994                 for (String v:osm.getKeys().values()) {
    995                     if (valuePattern.matcher(v).matches())
    996                         return true;
    997                 }
    998                 return false;
     982                return osm.getKeys().values().stream().anyMatch(v -> valuePattern.matcher(v).matches());
    999983            case ANY_VALUE_REGEXP:
    1000984            case EXACT_REGEXP:
    1001                 for (String k : osm.keySet()) {
    1002                     if (keyPattern.matcher(k).matches()
    1003                             && (mode == Mode.ANY_VALUE_REGEXP || valuePattern.matcher(osm.get(k)).matches()))
    1004                         return true;
    1005                 }
    1006                 return false;
     985                return osm.keySet().stream().anyMatch(k -> keyPattern.matcher(k).matches()
     986                        && (mode == Mode.ANY_VALUE_REGEXP || valuePattern.matcher(osm.get(k)).matches()));
    1007987            case MISSING_KEY_REGEXP:
    1008                 for (String k:osm.keySet()) {
    1009                     if (keyPattern.matcher(k).matches())
    1010                         return false;
    1011                 }
    1012                 return true;
     988                return osm.keySet().stream().noneMatch(k -> keyPattern.matcher(k).matches());
    1013989            }
    1014990            throw new AssertionError("Missed state");
     
    12791255        @Override
    12801256        public boolean match(OsmPrimitive osm) {
    1281             for (OsmPrimitive ref: osm.getReferrers()) {
    1282                 if (ref instanceof Relation && !ref.isIncomplete() && !ref.isDeleted()) {
    1283                     for (RelationMember m : ((Relation) ref).getMembers()) {
    1284                         if (m.getMember() == osm) {
    1285                             String testRole = m.getRole();
    1286                             if (role.equals(testRole == null ? "" : testRole))
    1287                                 return true;
    1288                         }
    1289                     }
    1290                 }
    1291             }
    1292             return false;
     1257            return osm.referrers(Relation.class)
     1258                    .filter(ref -> !ref.isIncomplete() && !ref.isDeleted())
     1259                    .flatMap(ref -> ref.getMembers().stream()).filter(m -> m.getMember() == osm)
     1260                    .map(RelationMember::getRole)
     1261                    .anyMatch(testRole -> role.equals(testRole == null ? "" : testRole));
    12931262        }
    12941263
     
    16981667        @Override
    16991668        public boolean match(OsmPrimitive osm) {
    1700             boolean isParent = false;
    1701 
    17021669            if (osm instanceof Way) {
    1703                 for (Node n : ((Way) osm).getNodes()) {
    1704                     isParent |= match.match(n);
    1705                 }
     1670                return ((Way) osm).getNodes().stream().anyMatch(match::match);
    17061671            } else if (osm instanceof Relation) {
    1707                 for (RelationMember member : ((Relation) osm).getMembers()) {
    1708                     isParent |= match.match(member.getMember());
    1709                 }
    1710             }
    1711             return isParent;
     1672                return ((Relation) osm).getMembers().stream().anyMatch(member -> match.match(member.getMember()));
     1673            } else {
     1674                return false;
     1675            }
    17121676        }
    17131677
     
    17291693        @Override
    17301694        public boolean match(OsmPrimitive osm) {
    1731             boolean isChild = false;
    1732             for (OsmPrimitive p : osm.getReferrers()) {
    1733                 isChild |= match.match(p);
    1734             }
    1735             return isChild;
     1695            return osm.getReferrers().stream().anyMatch(match::match);
    17361696        }
    17371697
     
    19311891        @Override
    19321892        public boolean match(OsmPrimitive osm) {
    1933             for (TaggingPreset preset : this.presets) {
    1934                 if (preset.test(osm)) {
    1935                     return true;
    1936                 }
    1937             }
    1938 
    1939             return false;
     1893            return this.presets.stream().anyMatch(preset -> preset.test(osm));
    19401894        }
    19411895
  • trunk/src/org/openstreetmap/josm/data/osm/search/SearchMode.java

    r12659 r16445  
    11// License: GPL. For details, see LICENSE file.
    22package org.openstreetmap.josm.data.osm.search;
     3
     4import java.util.Arrays;
    35
    46/**
     
    3638     */
    3739    public static SearchMode fromCode(char code) {
    38         for (SearchMode mode: values()) {
    39             if (mode.getCode() == code)
    40                 return mode;
    41         }
    42         return null;
     40        return Arrays.stream(values())
     41                .filter(mode -> mode.getCode() == code)
     42                .findFirst().orElse(null);
    4343    }
    4444}
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java

    r15418 r16445  
    22package org.openstreetmap.josm.data.osm.visitor;
    33
    4 import java.util.ArrayList;
    54import java.util.HashMap;
    65import java.util.List;
     
    2019import org.openstreetmap.josm.data.osm.WayData;
    2120import org.openstreetmap.josm.tools.CheckParameterUtil;
     21import org.openstreetmap.josm.tools.Utils;
    2222
    2323/**
     
    7979            return;
    8080        WayData clone = w.save();
    81         List<Long> newNodes = new ArrayList<>(w.getNodesCount());
    82         for (Node n: w.getNodes()) {
    83             newNodes.add(mappedPrimitives.get(n).getUniqueId());
    84         }
     81        List<Long> newNodes = Utils.transform(w.getNodes(), n -> mappedPrimitives.get(n).getUniqueId());
    8582        clone.setNodeIds(newNodes);
    8683        mappedPrimitives.put(w, clone);
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java

    r15586 r16445  
    204204    public boolean isRegistered(Class<? extends AbstractMapRenderer> renderer) {
    205205        CheckParameterUtil.ensureParameterNotNull(renderer);
    206         for (Descriptor d: descriptors) {
    207             if (d.getRenderer().equals(renderer)) return true;
    208         }
    209         return false;
     206        return descriptors.stream().anyMatch(d -> d.getRenderer().equals(renderer));
    210207    }
    211208
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/relations/Multipolygon.java

    r16134 r16445  
    129129        boolean isOuterRole(String role) {
    130130            if (role == null) return false;
    131             for (String candidate: outerExactRoles) {
    132                 if (role.equals(candidate)) return true;
    133             }
    134             for (String candidate: outerRolePrefixes) {
    135                 if (role.startsWith(candidate)) return true;
    136             }
    137             return false;
     131            return outerExactRoles.stream().anyMatch(role::equals) || outerRolePrefixes.stream().anyMatch(role::startsWith);
    138132        }
    139133
    140134        boolean isInnerRole(String role) {
    141135            if (role == null) return false;
    142             for (String candidate: innerExactRoles) {
    143                 if (role.equals(candidate)) return true;
    144             }
    145             for (String candidate: innerRolePrefixes) {
    146                 if (role.startsWith(candidate)) return true;
    147             }
    148             return false;
     136            return innerExactRoles.stream().anyMatch(role::equals) || innerRolePrefixes.stream().anyMatch(role::startsWith);
    149137        }
    150138    }
     
    482470            if (nodes.size() < 3 || !getFirstNode().equals(getLastNode()))
    483471                return false;
    484             for (PolyData inner : inners) {
    485                 if (!inner.isClosed())
    486                     return false;
    487             }
    488             return true;
     472            return inners.stream().allMatch(PolyData::isClosed);
    489473        }
    490474
  • trunk/src/org/openstreetmap/josm/data/validation/TestError.java

    r16296 r16445  
    1313import java.util.TreeSet;
    1414import java.util.function.Supplier;
     15import java.util.stream.Collectors;
     16import java.util.stream.Stream;
    1517
    1618import org.openstreetmap.josm.command.Command;
     
    281283
    282284    /**
     285     * Gets all primitives of the given type affected by this error
     286     * @param type restrict primitives to subclasses
     287     * @param <T> type of primitives
     288     * @return the primitives as Stream
     289     */
     290    public final <T extends OsmPrimitive> Stream<T> primitives(Class<T> type) {
     291        return primitives.stream()
     292                .filter(type::isInstance)
     293                .map(type::cast);
     294    }
     295
     296    /**
    283297     * Gets the severity of this error
    284298     * @return the severity of this error
     
    308322            strings.add(type + '_' + o.getId());
    309323        }
    310         StringBuilder ignorestring = new StringBuilder(getIgnoreSubGroup());
    311         for (String o : strings) {
    312             ignorestring.append(':').append(o);
    313         }
    314         return ignorestring.toString();
     324        return strings.stream().map(o -> ':' + o).collect(Collectors.joining("", getIgnoreSubGroup(), ""));
    315325    }
    316326
  • trunk/src/org/openstreetmap/josm/data/validation/routines/DomainValidator.java

    r16223 r16445  
    2020import java.util.Arrays;
    2121import java.util.Locale;
     22import java.util.stream.IntStream;
    2223
    2324import org.openstreetmap.josm.tools.Logging;
     
    19121913            throw new IllegalStateException("Can only invoke this method before calling getInstance");
    19131914        }
    1914         String[] copy = new String[tlds.length];
    19151915        // Comparisons are always done with lower-case entries
    1916         for (int i = 0; i < tlds.length; i++) {
    1917             copy[i] = tlds[i].toLowerCase(Locale.ENGLISH);
    1918         }
     1916        String[] copy = Arrays.stream(tlds)
     1917                .map(tld -> tld.toLowerCase(Locale.ENGLISH))
     1918                .toArray(String[]::new);
    19191919        Arrays.sort(copy);
    19201920        switch(table) {
     
    20402040            return true;
    20412041        }
    2042         for (int i = 0; i < input.length(); i++) {
    2043             if (input.charAt(i) > 0x7F) { // CHECKSTYLE IGNORE MagicNumber
    2044                 return false;
    2045             }
    2046         }
    2047         return true;
     2042        return IntStream.range(0, input.length()).noneMatch(i -> input.charAt(i) > 0x7F); // CHECKSTYLE IGNORE MagicNumber
    20482043    }
    20492044
  • trunk/src/org/openstreetmap/josm/data/validation/routines/RegexValidator.java

    r15586 r16445  
    1717package org.openstreetmap.josm.data.validation.routines;
    1818
     19import java.util.Arrays;
     20import java.util.Objects;
    1921import java.util.regex.Matcher;
    2022import java.util.regex.Pattern;
     23import java.util.stream.Collectors;
     24import java.util.stream.IntStream;
    2125
    2226/**
     
    138142    @Override
    139143    public boolean isValid(String value) {
    140         if (value == null) {
    141             return false;
    142         }
    143         for (int i = 0; i < patterns.length; i++) {
    144             if (patterns[i].matcher(value).matches()) {
    145                 return true;
    146             }
    147         }
    148         return false;
     144        return value != null
     145                && IntStream.range(0, patterns.length).anyMatch(i -> patterns[i].matcher(value).matches());
    149146    }
    150147
     
    166163            return null;
    167164        }
    168         for (int i = 0; i < patterns.length; i++) {
    169             Matcher matcher = patterns[i].matcher(value);
     165        for (Pattern pattern : patterns) {
     166            Matcher matcher = pattern.matcher(value);
    170167            if (matcher.matches()) {
    171168                int count = matcher.groupCount();
    172                 String[] groups = new String[count];
    173                 for (int j = 0; j < count; j++) {
    174                     groups[j] = matcher.group(j+1);
    175                 }
    176                 return groups;
     169                return IntStream.range(0, count).mapToObj(j -> matcher.group(j + 1)).toArray(String[]::new);
    177170            }
    178171        }
     
    192185            return null;
    193186        }
    194         for (int i = 0; i < patterns.length; i++) {
    195             Matcher matcher = patterns[i].matcher(value);
     187        for (Pattern pattern : patterns) {
     188            Matcher matcher = pattern.matcher(value);
    196189            if (matcher.matches()) {
    197190                int count = matcher.groupCount();
     
    199192                    return matcher.group(1);
    200193                }
    201                 StringBuilder buffer = new StringBuilder();
    202                 for (int j = 0; j < count; j++) {
    203                     String component = matcher.group(j+1);
    204                     if (component != null) {
    205                         buffer.append(component);
    206                     }
    207                 }
    208                 return buffer.toString();
     194                return IntStream.range(0, count).mapToObj(j -> matcher.group(j + 1)).filter(Objects::nonNull).collect(Collectors.joining());
    209195            }
    210196        }
     
    218204    @Override
    219205    public String toString() {
    220         StringBuilder buffer = new StringBuilder(32);
    221         buffer.append("RegexValidator{");
    222         for (int i = 0; i < patterns.length; i++) {
    223             if (i > 0) {
    224                 buffer.append(',');
    225             }
    226             buffer.append(patterns[i].pattern());
    227         }
    228         buffer.append('}');
    229         return buffer.toString();
     206        return Arrays.stream(patterns).map(Pattern::pattern)
     207                .collect(Collectors.joining(",", "RegexValidator{", "}"));
    230208    }
    231209}
  • trunk/src/org/openstreetmap/josm/data/validation/tests/ConnectivityRelations.java

    r16372 r16445  
    66
    77import java.util.ArrayList;
     8import java.util.Collection;
    89import java.util.Collections;
    910import java.util.Comparator;
     
    245246     */
    246247    private void checkForImpliedConnectivity(Relation relation, Map<String, Integer> roleLanes) {
    247         boolean connImplied = true;
    248248        Map<Integer, Map<Integer, Boolean>> connTagLanes = parseConnectivityTag(relation);
    249249        // Don't flag connectivity as already implied when:
     
    256256        //   the highway that they're merging into
    257257
    258         connImplied = checkMemberTagsForImpliedConnectivity(relation, roleLanes) && !checkForIntersectionAtMembers(relation);
    259         // Check if connectivity tag implies default connectivity
    260         if (connImplied) {
    261             for (Entry<Integer, Map<Integer, Boolean>> to : connTagLanes.entrySet()) {
    262                 int fromLane = to.getKey();
    263                 for (Entry<Integer, Boolean> lane : to.getValue().entrySet()) {
    264                     if (lane.getKey() != null && fromLane != lane.getKey()) {
    265                         connImplied = false;
    266                         break;
    267                     }
    268                 }
    269                 if (!connImplied)
    270                     break;
    271             }
    272         }
     258        boolean connImplied = checkMemberTagsForImpliedConnectivity(relation, roleLanes) && !checkForIntersectionAtMembers(relation)
     259                // Check if connectivity tag implies default connectivity
     260                && connTagLanes.entrySet().stream()
     261                .noneMatch(to -> {
     262                    int fromLane = to.getKey();
     263                    return to.getValue().entrySet().stream()
     264                            .anyMatch(lane -> lane.getKey() != null && fromLane != lane.getKey());
     265                });
    273266
    274267        if (connImplied) {
     
    293286            List<Way> parentWays = viaNode.getParentWays();
    294287            if (parentWays.size() > 2) {
    295                 for (Way thisWay : parentWays) {
    296                     if (!relationMembers.contains(thisWay) && thisWay.hasTag("highway")) {
    297                         return true;
    298                     }
    299                 }
     288                return parentWays.stream()
     289                        .anyMatch(thisWay -> !relationMembers.contains(thisWay) && thisWay.hasTag("highway"));
    300290            }
    301291        } else if (viaPrim.getType() == OsmPrimitiveType.WAY) {
    302292            Way viaWay = (Way) viaPrim;
    303             for (Node thisNode : viaWay.getNodes()) {
    304                 List<Way> parentWays = thisNode.getParentWays();
    305                 if (parentWays.size() > 2) {
    306                     for (Way thisWay : parentWays) {
    307                         if (!relationMembers.contains(thisWay) && thisWay.hasTag("highway")) {
    308                             return true;
    309                         }
    310                     }
    311                 }
    312             }
     293            return viaWay.getNodes().stream()
     294                    .map(Node::getParentWays).filter(parentWays -> parentWays.size() > 2)
     295                    .flatMap(Collection::stream)
     296                    .anyMatch(thisWay -> !relationMembers.contains(thisWay) && thisWay.hasTag("highway"));
    313297        }
    314298        return false;
     
    380364        necessaryRoles.add(VIA);
    381365        necessaryRoles.add(TO);
    382 
    383         List<String> roleList = new ArrayList<>();
    384         for (RelationMember relationMember: relation.getMembers()) {
    385             roleList.add(relationMember.getRole());
    386         }
    387 
    388         return !roleList.containsAll(necessaryRoles);
     366        return !relation.getMemberRoles().containsAll(necessaryRoles);
    389367    }
    390368
  • trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

    r15961 r16445  
    1313import java.util.Objects;
    1414import java.util.Set;
     15import java.util.stream.Collectors;
    1516
    1617import org.openstreetmap.josm.data.coor.EastNorth;
     
    240241            Set<String> s1 = getBoundaryTags(w1);
    241242            Set<String> s2 = getBoundaryTags(w2);
    242             for (String type : s1) {
    243                 if (s2.contains(type))
    244                     return false;
    245             }
    246             return true;
     243            return s1.stream().noneMatch(s2::contains);
    247244        }
    248245
     
    421418     */
    422419    public static List<List<WaySegment>> getSegments(Map<Point2D, List<WaySegment>> cellSegments, EastNorth n1, EastNorth n2) {
    423         List<List<WaySegment>> cells = new ArrayList<>();
    424         for (Point2D cell : ValUtil.getSegmentCells(n1, n2, OsmValidator.getGridDetail())) {
    425             cells.add(cellSegments.computeIfAbsent(cell, k -> new ArrayList<>()));
    426         }
    427         return cells;
     420        return ValUtil.getSegmentCells(n1, n2, OsmValidator.getGridDetail()).stream()
     421                .map(cell -> cellSegments.computeIfAbsent(cell, k -> new ArrayList<>()))
     422                .collect(Collectors.toList());
    428423    }
    429424
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateNode.java

    r16332 r16445  
    1010import java.util.Collections;
    1111import java.util.HashMap;
    12 import java.util.HashSet;
    1312import java.util.Iterator;
    1413import java.util.LinkedHashSet;
     
    1615import java.util.Map;
    1716import java.util.Map.Entry;
     17import java.util.Objects;
    1818import java.util.Set;
    1919import java.util.stream.Collectors;
     
    135135            // multiple nodes at the same position -> check if all nodes have a distinct elevation
    136136            List<Node> nodes = (List<Node>) v;
    137             Set<String> eles = new HashSet<>();
    138             for (Node n : nodes) {
    139                 String ele = n.get("ele");
    140                 if (ele != null) {
    141                     eles.add(ele);
    142                 }
    143             }
     137            Set<String> eles = nodes.stream()
     138                    .map(n -> n.get("ele"))
     139                    .filter(Objects::nonNull)
     140                    .collect(Collectors.toSet());
    144141            if (eles.size() == nodes.size()) {
    145142                // All nodes at this position have a distinct elevation.
     
    310307    @Override
    311308    public Command fixError(TestError testError) {
    312         final Set<Node> nodes = testError.getPrimitives().stream()
    313                 .filter(Node.class::isInstance)
    314                 .map(Node.class::cast)
     309        final Set<Node> nodes = testError.primitives(Node.class)
    315310                // Filter nodes that have already been deleted (see #5764 and #5773)
    316311                .filter(n -> !n.isDeleted())
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateRelation.java

    r15375 r16445  
    247247    public Command fixError(TestError testError) {
    248248        if (testError.getCode() == SAME_RELATION) return null;
    249         Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
    250         Set<Relation> relFix = new HashSet<>();
    251 
    252         for (OsmPrimitive osm : sel) {
    253             if (osm instanceof Relation && !osm.isDeleted()) {
    254                 relFix.add((Relation) osm);
    255             }
    256         }
     249        Set<Relation> relFix = testError.primitives(Relation.class)
     250                .filter(r -> !r.isDeleted())
     251                .collect(Collectors.toSet());
    257252
    258253        if (relFix.size() < 2)
     
    308303
    309304        // We fix it only if there is no more than one relation that is relation member.
    310         Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
    311         Set<Relation> rels = new HashSet<>();
    312 
    313         for (OsmPrimitive osm : sel) {
    314             if (osm instanceof Relation) {
    315                 rels.add((Relation) osm);
    316             }
    317         }
     305        Set<Relation> rels = testError.primitives(Relation.class)
     306                .collect(Collectors.toSet());
    318307
    319308        if (rels.size() < 2)
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateWay.java

    r14654 r16445  
    1414import java.util.Set;
    1515import java.util.stream.Collectors;
     16import java.util.stream.IntStream;
    1617
    1718import org.openstreetmap.josm.command.ChangeCommand;
     
    227228                }
    228229            }
    229             for (int i = lowestIndex; i < wNodes.size()-1; i++) {
    230                 wNodesToUse.add(wNodes.get(i));
    231             }
     230            IntStream.range(lowestIndex, wNodes.size() - 1)
     231                    .mapToObj(wNodes::get)
     232                    .forEach(wNodesToUse::add);
    232233            for (int i = 0; i < lowestIndex; i++) {
    233234                wNodesToUse.add(wNodes.get(i));
     
    238239        }
    239240        // Build the list of lat/lon
    240         List<LatLon> wLat = new ArrayList<>(wNodesToUse.size());
    241         for (Node node : wNodesToUse) {
    242             wLat.add(node.getCoor());
    243         }
    244         return wLat;
     241
     242        return wNodesToUse.stream()
     243                .map(Node::getCoor)
     244                .collect(Collectors.toList());
    245245    }
    246246
     
    250250    @Override
    251251    public Command fixError(TestError testError) {
    252         Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
    253         Set<Way> wayz = new HashSet<>();
    254 
    255         for (OsmPrimitive osm : sel) {
    256             if (osm instanceof Way && !osm.isDeleted()) {
    257                 wayz.add((Way) osm);
    258             }
    259         }
     252        Set<Way> wayz = testError.primitives(Way.class)
     253                .filter(w -> !w.isDeleted())
     254                .collect(Collectors.toSet());
    260255
    261256        if (wayz.size() < 2)
     
    315310
    316311        // We fix it only if there is no more than one way that is relation member.
    317         Collection<? extends OsmPrimitive> sel = testError.getPrimitives();
    318         Set<Way> wayz = new HashSet<>();
    319 
    320         for (OsmPrimitive osm : sel) {
    321             if (osm instanceof Way) {
    322                 wayz.add((Way) osm);
    323             }
    324         }
    325 
     312        Set<Way> wayz = testError.primitives(Way.class).collect(Collectors.toSet());
    326313        if (wayz.size() < 2)
    327314            return false;
    328315
    329         int waysWithRelations = 0;
    330         for (Way w : wayz) {
    331             List<Relation> rel = w.referrers(Relation.class).collect(Collectors.toList());
    332             if (!rel.isEmpty()) {
    333                 ++waysWithRelations;
    334             }
    335         }
     316        long waysWithRelations = wayz.stream()
     317                .filter(w -> w.referrers(Relation.class).anyMatch(x -> true))
     318                .count();
    336319        return waysWithRelations <= 1;
    337320    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/MapCSSTagChecker.java

    r16360 r16445  
    1616import java.util.HashSet;
    1717import java.util.Iterator;
    18 import java.util.LinkedList;
    1918import java.util.List;
    2019import java.util.Map;
     
    2726import java.util.regex.Matcher;
    2827import java.util.regex.Pattern;
     28import java.util.stream.Collectors;
    2929import java.util.stream.Stream;
    3030
     
    463463            try {
    464464                final Selector matchingSelector = whichSelectorMatchesPrimitive(p);
    465                 Collection<Command> cmds = new LinkedList<>();
    466                 for (FixCommand fixCommand : fixCommands) {
    467                     cmds.add(fixCommand.createCommand(p, matchingSelector));
    468                 }
     465                Collection<Command> cmds = fixCommands.stream()
     466                        .map(fixCommand -> fixCommand.createCommand(p, matchingSelector))
     467                        .collect(Collectors.toList());
    469468                if (deletion && !p.isDeleted()) {
    470469                    cmds.add(new DeleteCommand(p));
  • trunk/src/org/openstreetmap/josm/data/validation/tests/MultipolygonTest.java

    r16406 r16445  
    1616import java.util.Map.Entry;
    1717import java.util.Set;
     18import java.util.stream.Collectors;
     19import java.util.stream.IntStream;
    1820
    1921import org.openstreetmap.josm.command.ChangeCommand;
     
    191193                    .build());
    192194        }
    193         Map<Long, RelationMember> wayMap = new HashMap<>();
    194         for (int i = 0; i < r.getMembersCount(); i++) {
    195             RelationMember mem = r.getMember(i);
    196             if (!mem.isWay())
    197                 continue;
    198             wayMap.put(mem.getWay().getUniqueId(), mem); // duplicate members were checked before
    199         }
     195
     196        Map<Long, RelationMember> wayMap = r.getMembers().stream()
     197                .filter(RelationMember::isWay)
     198                .collect(Collectors.toMap(mem -> mem.getWay().getUniqueId(), mem -> mem, (a, b) -> b));
     199        // duplicate members were checked before
    200200        if (wayMap.isEmpty())
    201201            return;
     
    230230            }
    231231        }
    232         boolean checkRoles = true;
    233         for (int i = oldErrorsSize; i < errors.size(); i++) {
    234             if (errors.get(i).getSeverity() != Severity.OTHER) {
    235                 checkRoles = false;
    236                 break;
    237             }
    238         }
     232        boolean checkRoles = IntStream.range(oldErrorsSize, errors.size())
     233                .noneMatch(i -> errors.get(i).getSeverity() != Severity.OTHER);
    239234        if (checkRoles) {
    240235            // we found no intersection or crossing between the polygons and they are closed
     
    251246     */
    252247    private static boolean hasIntersectionWay(PolyData pd, Set<Way> intersectionWays) {
    253         for (Way w : intersectionWays) {
    254             if (pd.getWayIds().contains(w.getUniqueId())) {
    255                 return true;
    256             }
    257         }
    258         return false;
     248        return intersectionWays.stream().anyMatch(w -> pd.getWayIds().contains(w.getUniqueId()));
    259249    }
    260250
     
    874864         */
    875865        private Node getNonIntersectingNode(PolyData pd1, PolyData pd2) {
    876             for (Node n : pd2.getNodes()) {
    877                 if (!sharedNodes.contains(n) || !pd1.getNodes().contains(n))
    878                     return n;
    879             }
    880             return null;
     866            return pd2.getNodes().stream()
     867                    .filter(n -> !sharedNodes.contains(n) || !pd1.getNodes().contains(n))
     868                    .findFirst().orElse(null);
    881869        }
    882870    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/PowerLines.java

    r14477 r16445  
    9090    public void endTest() {
    9191        for (TestError e : potentialErrors) {
    92             e.getPrimitives().stream()
    93                     .map(Node.class::cast)
     92            e.primitives(Node.class)
    9493                    .filter(n -> !isInPowerStation(n))
    9594                    .findAny()
  • trunk/src/org/openstreetmap/josm/data/validation/tests/RelationChecker.java

    r15719 r16445  
    9797        }
    9898        for (TaggingPreset p : TaggingPresets.getTaggingPresets()) {
    99             for (TaggingPresetItem i : p.data) {
    100                 if (i instanceof Roles) {
    101                     relationpresets.add(p);
    102                     break;
    103                 }
     99            if (p.data.stream().anyMatch(i -> i instanceof Roles)) {
     100                relationpresets.add(p);
    104101            }
    105102        }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java

    r16406 r16445  
    637637            EnumSet<TaggingPresetType> presetTypes = EnumSet.of(presetType);
    638638
    639             Collection<TaggingPreset> matchingPresets = new LinkedHashSet<>();
    640             for (Entry<TaggingPreset, List<TaggingPresetItem>> e : presetIndex.entrySet()) {
    641                 if (TaggingPresetItem.matches(e.getValue(), tags)) {
    642                     matchingPresets.add(e.getKey());
    643                 }
    644             }
     639            Collection<TaggingPreset> matchingPresets = presetIndex.entrySet().stream()
     640                    .filter(e -> TaggingPresetItem.matches(e.getValue(), tags))
     641                    .map(Entry::getKey)
     642                    .collect(Collectors.toCollection(LinkedHashSet::new));
    645643            Collection<TaggingPreset> matchingPresetsOK = matchingPresets.stream().filter(
    646644                    tp -> tp.typeMatches(presetTypes)).collect(Collectors.toList());
  • trunk/src/org/openstreetmap/josm/data/validation/tests/UnclosedWays.java

    r16379 r16445  
    99import java.util.HashSet;
    1010import java.util.Set;
     11import java.util.stream.Collectors;
    1112
    1213import org.openstreetmap.josm.data.osm.OsmUtils;
     
    168169     */
    169170    public Set<String> getCheckedKeys() {
    170         Set<String> keys = new HashSet<>();
    171         for (UnclosedWaysCheck c : checks) {
    172             keys.add(c.key);
    173         }
    174         return keys;
     171        return Arrays.stream(checks).map(c -> c.key).collect(Collectors.toSet());
    175172    }
    176173
  • trunk/src/org/openstreetmap/josm/data/validation/tests/WayConnectedToArea.java

    r14563 r16445  
    3535        }
    3636
    37         boolean hasway = false;
    3837        List<OsmPrimitive> r = w.firstNode().getReferrers();
    39         for (OsmPrimitive p : r) {
    40             if (p != w && p.hasKey(HIGHWAY)) {
    41                 hasway = true;
    42                 break;
    43             }
    44         }
     38        boolean hasway = r.stream().anyMatch(p -> p != w && p.hasKey(HIGHWAY));
    4539        if (!hasway) {
    4640            for (OsmPrimitive p : r) {
     
    4842            }
    4943        }
    50         hasway = false;
    5144        r = w.lastNode().getReferrers();
    52         for (OsmPrimitive p : r) {
    53             if (p != w && p.hasKey(HIGHWAY)) {
    54                 hasway = true;
    55                 break;
    56             }
    57         }
     45        hasway = r.stream().anyMatch(p -> p != w && p.hasKey(HIGHWAY));
    5846        if (!hasway) {
    5947            for (OsmPrimitive p : r) {
     
    7058            addPossibleError(w, wayNode, p, p);
    7159        } else {
    72             for (OsmPrimitive r : p.getReferrers()) {
    73                 if (r instanceof Relation
    74                         && r.hasTag("type", "multipolygon")
    75                         && isArea(r)) {
    76                     addPossibleError(w, wayNode, p, r);
    77                     break;
    78                 }
    79             }
     60            p.referrers(Relation.class)
     61                    .filter(r -> r.isMultipolygon() && isArea(r))
     62                    .findFirst()
     63                    .ifPresent(r -> addPossibleError(w, wayNode, p, r));
    8064        }
    8165    }
  • trunk/test/unit/org/openstreetmap/josm/data/osm/DefaultNameFormatterTest.java

    r14138 r16445  
    1313import java.util.Comparator;
    1414import java.util.List;
     15import java.util.stream.Collectors;
     16import java.util.stream.IntStream;
    1517
    1618import org.junit.Rule;
     
    146148                DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(new Node(1)));
    147149
    148         List<Node> nodes = new ArrayList<>(10);
    149         for (int i = 1; i <= 10; i++) {
    150             nodes.add(new Node(i, 1));
    151         }
     150        List<Node> nodes = IntStream.rangeClosed(1, 10).mapToObj(i -> new Node(i, 1))
     151                .collect(Collectors.toList());
    152152        assertEquals("<ul><li>1</li><li>2</li><li>3</li><li>4</li><li>...</li></ul>",
    153153                DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(nodes, 5));
  • trunk/test/unit/org/openstreetmap/josm/data/osm/history/HistoryWayTest.java

    r12663 r16445  
    66import static org.junit.Assert.fail;
    77
    8 import java.util.ArrayList;
    98import java.util.Date;
    109import java.util.HashMap;
     10import java.util.List;
    1111import java.util.Map;
    1212
     
    9797        way.addNode(1);
    9898        way.addNode(2);
    99         ArrayList<Long> ids = new ArrayList<>();
    100         for (long id : way.getNodes()) {
    101             ids.add(id);
    102         }
     99        List<Long> ids = way.getNodes();
    103100
    104101        assertEquals(2, ids.size());
  • trunk/test/unit/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitorTest.java

    r12812 r16445  
    3131        if (primitives == null) return null;
    3232        if (name == null) return null;
    33         for (OsmPrimitive primitive: primitives) {
    34             if (name.equals(primitive.get("name")))
    35                 return primitive;
    36         }
    37         return null;
     33        return primitives.stream()
     34                .filter(primitive -> name.equals(primitive.get("name")))
     35                .findFirst().orElse(null);
    3836    }
    3937
  • trunk/test/unit/org/openstreetmap/josm/data/projection/ProjectionRegressionTest.java

    r16436 r16445  
    1212import java.security.SecureRandom;
    1313import java.util.ArrayList;
    14 import java.util.HashMap;
    1514import java.util.List;
    1615import java.util.Map;
     
    5958        setUp();
    6059
    61         Map<String, Projection> supportedCodesMap = new HashMap<>();
    62         for (String code : Projections.getAllProjectionCodes()) {
    63             supportedCodesMap.put(code, Projections.getProjectionByCode(code));
    64         }
     60        Map<String, Projection> supportedCodesMap = Projections.getAllProjectionCodes().stream()
     61                .collect(Collectors.toMap(code -> code, Projections::getProjectionByCode));
    6562
    6663        List<TestData> prevData = new ArrayList<>();
     
    6865            prevData = readData();
    6966        }
    70         Map<String, TestData> prevCodesMap = new HashMap<>();
    71         for (TestData data : prevData) {
    72             prevCodesMap.put(data.code, data);
    73         }
    74 
    75         Set<String> codesToWrite = new TreeSet<>();
    76         for (TestData data : prevData) {
    77             if (supportedCodesMap.containsKey(data.code)) {
    78                 codesToWrite.add(data.code);
    79             }
    80         }
    81         for (String code : supportedCodesMap.keySet()) {
    82             if (!codesToWrite.contains(code)) {
    83                 codesToWrite.add(code);
    84             }
    85         }
     67        Map<String, TestData> prevCodesMap = prevData.stream()
     68                .collect(Collectors.toMap(data -> data.code, data -> data));
     69
     70        Set<String> codesToWrite = new TreeSet<>(supportedCodesMap.keySet());
     71        prevData.stream()
     72                .filter(data -> supportedCodesMap.containsKey(data.code)).map(data -> data.code)
     73                .forEach(codesToWrite::add);
    8674
    8775        Random rand = new SecureRandom();
  • trunk/test/unit/org/openstreetmap/josm/data/validation/tests/SelfIntersectingWayTest.java

    r12564 r16445  
    44import java.util.ArrayList;
    55import java.util.List;
     6import java.util.stream.Collectors;
     7import java.util.stream.IntStream;
    68
    79import org.junit.Assert;
     
    2931
    3032    private static List<Node> createNodes() {
    31         List<Node> nodes = new ArrayList<>();
    32         for (int i = 0; i < 6; i++) {
    33             nodes.add(new Node(i+1));
    34         }
     33        List<Node> nodes = IntStream.range(0, 6).mapToObj(i -> new Node(i + 1)).collect(Collectors.toList());
    3534        nodes.get(0).setCoor(new LatLon(34.2680, 133.563));
    3635        nodes.get(1).setCoor(new LatLon(34.2509, 133.548));
  • trunk/test/unit/org/openstreetmap/josm/data/validation/tests/TagCheckerTest.java

    r16226 r16445  
    77
    88import java.io.IOException;
    9 import java.util.ArrayList;
    109import java.util.List;
    1110import java.util.function.Consumer;
     11import java.util.stream.Collectors;
    1212
    1313import org.junit.Assert;
     
    201201    @Test
    202202    public void testIgnoredTagsNotInPresets() throws IOException {
    203         List<String> errors = new ArrayList<>();
    204203        new TagChecker().initialize();
    205         for (Tag tag : TagChecker.getIgnoredTags()) {
    206             if (TagChecker.isTagInPresets(tag.getKey(), tag.getValue())) {
    207                 errors.add(tag.toString());
    208             }
    209         }
     204        List<String> errors = TagChecker.getIgnoredTags().stream()
     205                .filter(tag -> TagChecker.isTagInPresets(tag.getKey(), tag.getValue()))
     206                .map(Tag::toString)
     207                .collect(Collectors.toList());
    210208        assertTrue(errors.toString(), errors.isEmpty());
    211209    }
Note: See TracChangeset for help on using the changeset viewer.