Changeset 16436 in josm


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

see #19251 - Java 8: use Stream

Location:
trunk
Files:
1 added
65 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/command/AddPrimitivesCommand.java

    r15735 r16436  
    66import java.util.ArrayList;
    77import java.util.Collection;
    8 import java.util.HashSet;
    98import java.util.List;
    109import java.util.Objects;
     
    2019import org.openstreetmap.josm.data.osm.PrimitiveData;
    2120import org.openstreetmap.josm.tools.CheckParameterUtil;
    22 import org.openstreetmap.josm.tools.JosmRuntimeException;
    2321
    2422/**
     
    160158            return createdPrimitives;
    161159
    162         Collection<OsmPrimitive> prims = new HashSet<>();
    163         for (PrimitiveData d : data) {
    164             prims.add(Optional.ofNullable(getAffectedDataSet().getPrimitiveById(d)).orElseThrow(
    165                     () -> new JosmRuntimeException("No primitive found for " + d)));
    166         }
    167         return prims;
     160        return data.stream()
     161                .map(d -> Objects.requireNonNull(getAffectedDataSet().getPrimitiveById(d), () -> "No primitive found for " + d))
     162                .collect(Collectors.toSet());
    168163    }
    169164
  • trunk/src/org/openstreetmap/josm/command/ChangePropertyCommand.java

    r15905 r16436  
    229229            }
    230230        } else {
    231             boolean allnull = true;
    232             for (Map.Entry<String, String> tag : this.tags.entrySet()) {
    233                 if (tag.getValue() != null && !tag.getValue().isEmpty()) {
    234                     allnull = false;
    235                     break;
    236                 }
    237             }
    238 
    239             if (allnull) {
     231            boolean allNull = this.tags.entrySet().stream()
     232                    .allMatch(tag -> tag.getValue() == null || tag.getValue().isEmpty());
     233
     234            if (allNull) {
    240235                /* I18n: plural form detected for objects only (but value < 2 not possible!), try to do your best for tags */
    241236                text = trn("Deleted {0} tags for {1} object", "Deleted {0} tags for {1} objects", objects.size(), tags.size(), objects.size());
  • trunk/src/org/openstreetmap/josm/command/DeleteCommand.java

    r15874 r16436  
    1010import java.util.Collection;
    1111import java.util.Collections;
    12 import java.util.EnumSet;
    1312import java.util.HashMap;
    1413import java.util.HashSet;
     
    224223    }
    225224
    226     private EnumSet<OsmPrimitiveType> getTypesToDelete() {
    227         EnumSet<OsmPrimitiveType> typesToDelete = EnumSet.noneOf(OsmPrimitiveType.class);
    228         for (OsmPrimitive osm : toDelete) {
    229             typesToDelete.add(OsmPrimitiveType.from(osm));
    230         }
    231         return typesToDelete;
     225    private Set<OsmPrimitiveType> getTypesToDelete() {
     226        return toDelete.stream().map(OsmPrimitiveType::from).collect(Collectors.toSet());
    232227    }
    233228
     
    278273            return null;
    279274        else {
    280             List<PseudoCommand> children = new ArrayList<>(toDelete.size());
    281             for (final OsmPrimitive osm : toDelete) {
    282                 children.add(new DeleteChildCommand(osm));
    283             }
    284             return children;
    285 
     275            return toDelete.stream().map(DeleteChildCommand::new).collect(Collectors.toList());
    286276        }
    287277    }
     
    369359                Collection<OsmPrimitive> referringPrimitives = n.getReferrers();
    370360                referringPrimitives.removeAll(primitivesToDelete);
    371                 int count = 0;
    372                 for (OsmPrimitive p : referringPrimitives) {
    373                     if (!p.isDeleted()) {
    374                         count++;
    375                     }
    376                 }
    377                 if (count == 0) {
     361                if (referringPrimitives.stream().allMatch(OsmPrimitive::isDeleted)) {
    378362                    nodesToDelete.add(n);
    379363                }
  • trunk/src/org/openstreetmap/josm/command/PurgeCommand.java

    r16187 r16436  
    1313import java.util.Objects;
    1414import java.util.Set;
     15import java.util.stream.Collectors;
    1516
    1617import javax.swing.Icon;
     
    2627import org.openstreetmap.josm.data.osm.Relation;
    2728import org.openstreetmap.josm.data.osm.RelationData;
    28 import org.openstreetmap.josm.data.osm.RelationMember;
    2929import org.openstreetmap.josm.data.osm.Storage;
    3030import org.openstreetmap.josm.data.osm.Way;
     
    222222            }
    223223        }
    224         Set<Relation> childlessR = new HashSet<>();
    225         for (Relation r : inR) {
    226             if (numChilds.get(r).equals(0)) {
    227                 childlessR.add(r);
    228             }
    229         }
     224        Set<Relation> childlessR = inR.stream().filter(r -> numChilds.get(r).equals(0)).collect(Collectors.toSet());
    230225
    231226        List<Relation> outR = new ArrayList<>(inR.size());
     
    409404    private static boolean hasOnlyIncompleteMembers(
    410405            Relation r, Collection<OsmPrimitive> toPurge, Collection<? extends OsmPrimitive> moreToPurge) {
    411         for (RelationMember m : r.getMembers()) {
    412             if (!m.getMember().isIncomplete() && !toPurge.contains(m.getMember()) && !moreToPurge.contains(m.getMember()))
    413                 return false;
    414         }
    415         return true;
     406        return r.getMembers().stream()
     407                .allMatch(m -> m.getMember().isIncomplete() || toPurge.contains(m.getMember()) || moreToPurge.contains(m.getMember()));
    416408    }
    417409}
  • trunk/src/org/openstreetmap/josm/command/conflict/TagConflictResolveCommand.java

    r14214 r16436  
    3434     */
    3535    public int getNumDecidedConflicts() {
    36         int n = 0;
    37         for (TagMergeItem item: mergeItems) {
    38             if (item.getMergeDecision() != MergeDecisionType.UNDECIDED) {
    39                 n++;
    40             }
    41         }
    42         return n;
     36        return (int) mergeItems.stream().filter(item -> item.getMergeDecision() != MergeDecisionType.UNDECIDED).count();
    4337    }
    4438
  • trunk/src/org/openstreetmap/josm/data/APIDataSet.java

    r13164 r16436  
    267267        List<Relation> ret = new LinkedList<>();
    268268        for (Relation relation: relations) {
    269             boolean refersToNewRelation = false;
    270             for (RelationMember m : relation.getMembers()) {
    271                 if (m.isRelation() && m.getMember().isNewOrUndeleted()) {
    272                     refersToNewRelation = true;
    273                     break;
    274                 }
    275             }
     269            boolean refersToNewRelation = relation.getMembers().stream()
     270                    .anyMatch(m -> m.isRelation() && m.getMember().isNewOrUndeleted());
    276271            if (!refersToNewRelation) {
    277272                ret.add(relation);
  • trunk/src/org/openstreetmap/josm/data/DataSource.java

    r11634 r16436  
    44import java.awt.geom.Area;
    55import java.awt.geom.Path2D;
    6 import java.util.ArrayList;
    76import java.util.Collection;
    87import java.util.List;
    98import java.util.Objects;
     9import java.util.stream.Collectors;
    1010
    1111import org.openstreetmap.josm.tools.CheckParameterUtil;
     
    104104            return null;
    105105        }
    106         List<Bounds> ret = new ArrayList<>(dataSources.size());
    107         for (DataSource ds : dataSources) {
    108             if (ds.bounds != null) {
    109                 ret.add(ds.bounds);
    110             }
    111         }
    112         return ret;
     106        return dataSources.stream()
     107                .filter(ds -> ds.bounds != null).map(ds -> ds.bounds)
     108                .collect(Collectors.toList());
    113109    }
    114110}
  • trunk/src/org/openstreetmap/josm/data/ImageData.java

    r15352 r16436  
    1010
    1111import org.openstreetmap.josm.data.coor.LatLon;
     12import org.openstreetmap.josm.data.gpx.GpxImageEntry;
    1213import org.openstreetmap.josm.gui.layer.geoimage.ImageEntry;
    1314import org.openstreetmap.josm.tools.ListenerList;
     
    7576     */
    7677    public boolean isModified() {
    77         for (ImageEntry e : data) {
    78             if (e.hasNewGpsData()) {
    79                 return true;
    80             }
    81         }
    82         return false;
     78        return data.stream().anyMatch(GpxImageEntry::hasNewGpsData);
    8379    }
    8480
  • trunk/src/org/openstreetmap/josm/data/StructUtils.java

    r15906 r16436  
    123123        if (l == null)
    124124            return null;
    125         List<Map<String, String>> vals = new ArrayList<>();
    126         for (T struct : l) {
    127             if (struct != null) {
    128                 vals.add(serializeStruct(struct, klass));
    129             }
    130         }
    131         return vals;
     125        return l.stream().filter(Objects::nonNull)
     126                .map(struct -> serializeStruct(struct, klass)).collect(Collectors.toList());
    132127    }
    133128
  • trunk/src/org/openstreetmap/josm/data/Version.java

    r14480 r16436  
    66import java.io.IOException;
    77import java.io.InputStream;
    8 import java.util.Map.Entry;
    98import java.util.Optional;
    109import java.util.Properties;
     10import java.util.stream.Collectors;
    1111
    1212import org.openstreetmap.josm.tools.LanguageInfo;
     
    9494        // the revision info
    9595        //
    96         StringBuilder sb = new StringBuilder();
    97         for (Entry<Object, Object> property: properties.entrySet()) {
    98             sb.append(property.getKey()).append(':').append(property.getValue()).append('\n');
    99         }
    100         releaseDescription = sb.toString();
     96        releaseDescription = properties.entrySet().stream()
     97                .map(property -> property.getKey() + ":" + property.getValue() + "\n")
     98                .collect(Collectors.joining());
    10199    }
    102100
  • trunk/src/org/openstreetmap/josm/data/gpx/GpxData.java

    r15760 r16436  
    380380
    381381    private boolean anySegmentOverlapsWith(GpxTrackSegmentSpan other) {
    382         for (GpxTrackSegmentSpan s : getSegmentSpans()) {
    383             if (s.overlapsWith(other)) {
    384                 return true;
    385             }
    386         }
    387         return false;
     382        return getSegmentSpans().stream().anyMatch(s -> s.overlapsWith(other));
    388383    }
    389384
  • trunk/src/org/openstreetmap/josm/data/gpx/GpxExtension.java

    r15629 r16436  
    136136            return this;
    137137        } else {
    138             for (GpxExtension child : getExtensions()) {
    139                 GpxExtension ext = child.findExtension(sPrefix, sKey);
    140                 if (ext != null) {
    141                     return ext;
    142                 }
    143             }
    144             return null;
     138            return getExtensions().stream()
     139                    .map(child -> child.findExtension(sPrefix, sKey))
     140                    .filter(Objects::nonNull)
     141                    .findFirst().orElse(null);
    145142        }
    146143    }
  • trunk/src/org/openstreetmap/josm/data/gpx/GpxExtensionCollection.java

    r16398 r16436  
    202202     */
    203203    public GpxExtension find(String prefix, String key) {
    204         for (GpxExtension child : this) {
    205             GpxExtension ext = child.findExtension(prefix, key);
    206             if (ext != null) {
    207                 return ext;
    208             }
    209         }
    210         return null;
     204        return this.stream()
     205                .map(child -> child.findExtension(prefix, key)).filter(Objects::nonNull)
     206                .findFirst().orElse(null);
    211207    }
    212208
  • trunk/src/org/openstreetmap/josm/data/gpx/GpxTrack.java

    r15560 r16436  
    33
    44import java.awt.Color;
    5 import java.util.ArrayList;
    65import java.util.Collection;
    76import java.util.Collections;
     
    1514import org.openstreetmap.josm.tools.ListenerList;
    1615import org.openstreetmap.josm.tools.Logging;
     16import org.openstreetmap.josm.tools.StreamUtils;
    1717
    1818/**
     
    3737     */
    3838    public GpxTrack(Collection<Collection<WayPoint>> trackSegs, Map<String, Object> attributes) {
    39         List<IGpxTrackSegment> newSegments = new ArrayList<>();
    40         for (Collection<WayPoint> trackSeg: trackSegs) {
    41             if (trackSeg != null && !trackSeg.isEmpty()) {
    42                 newSegments.add(new GpxTrackSegment(trackSeg));
    43             }
    44         }
    45         this.segments = Collections.unmodifiableList(newSegments);
     39        this.segments = trackSegs.stream()
     40                .filter(trackSeg -> trackSeg != null && !trackSeg.isEmpty())
     41                .map(GpxTrackSegment::new)
     42                .collect(StreamUtils.toUnmodifiableList());
    4643        this.length = calculateLength();
    4744        this.bounds = calculateBounds();
     
    6562
    6663    private double calculateLength() {
    67         double result = 0.0; // in meters
    68 
    69         for (IGpxTrackSegment trkseg : segments) {
    70             result += trkseg.length();
    71         }
    72         return result;
     64        return segments.stream().mapToDouble(IGpxTrackSegment::length).sum();
    7365    }
    7466
  • trunk/src/org/openstreetmap/josm/data/imagery/GetCapabilitiesParseHelper.java

    r15586 r16436  
    55import java.net.MalformedURLException;
    66import java.net.URL;
     7import java.util.Arrays;
    78import java.util.Locale;
    89import java.util.function.BiPredicate;
     
    3536
    3637        static TransferMode fromString(String s) {
    37             for (TransferMode type : TransferMode.values()) {
    38                 if (type.getTypeString().equals(s)) {
    39                     return type;
    40                 }
    41             }
    42             return null;
     38            return Arrays.stream(TransferMode.values())
     39                    .filter(type -> type.getTypeString().equals(s))
     40                    .findFirst().orElse(null);
    4341        }
    4442    }
  • trunk/src/org/openstreetmap/josm/data/imagery/ImageryInfo.java

    r16130 r16436  
    4848import org.openstreetmap.josm.tools.Logging;
    4949import org.openstreetmap.josm.tools.MultiMap;
     50import org.openstreetmap.josm.tools.StreamUtils;
    5051import org.openstreetmap.josm.tools.Utils;
    5152
     
    9596         */
    9697        public static ImageryType fromString(String s) {
    97             for (ImageryType type : ImageryType.values()) {
    98                 if (type.getTypeString().equals(s)) {
    99                     return type;
    100                 }
    101             }
    102             return null;
     98            return Arrays.stream(ImageryType.values())
     99                    .filter(type -> type.getTypeString().equals(s))
     100                    .findFirst().orElse(null);
    103101        }
    104102    }
     
    170168         */
    171169        public static ImageryCategory fromString(String s) {
    172             for (ImageryCategory category : ImageryCategory.values()) {
    173                 if (category.getCategoryString().equals(s)) {
    174                     return category;
    175                 }
    176             }
    177             return null;
     170            return Arrays.stream(ImageryCategory.values())
     171                    .filter(category -> category.getCategoryString().equals(s))
     172                    .findFirst().orElse(null);
    178173        }
    179174    }
     
    403398            if (i.bounds != null) {
    404399                bounds = i.bounds.encodeAsString(",");
    405                 StringBuilder shapesString = new StringBuilder();
    406                 for (Shape s : i.bounds.getShapes()) {
    407                     if (shapesString.length() > 0) {
    408                         shapesString.append(';');
    409                     }
    410                     shapesString.append(s.encodeAsString(","));
    411                 }
    412                 if (shapesString.length() > 0) {
    413                     shapes = shapesString.toString();
     400                String shapesString = Shape.encodeAsString(i.bounds.getShapes());
     401                if (!shapesString.isEmpty()) {
     402                    shapes = shapesString;
    414403                }
    415404            }
     
    10931082     */
    10941083    public static Collection<String> getActiveIds() {
    1095         ArrayList<String> ids = new ArrayList<>();
    10961084        IPreferences pref = Config.getPref();
    1097         if (pref != null) {
    1098             List<ImageryPreferenceEntry> entries = StructUtils.getListOfStructs(
    1099                 pref, "imagery.entries", null, ImageryPreferenceEntry.class);
    1100             if (entries != null) {
    1101                 for (ImageryPreferenceEntry prefEntry : entries) {
    1102                     if (prefEntry.id != null && !prefEntry.id.isEmpty())
    1103                         ids.add(prefEntry.id);
    1104                 }
    1105                 Collections.sort(ids);
    1106             }
    1107         }
    1108         return ids;
     1085        if (pref == null) {
     1086            return Collections.emptyList();
     1087        }
     1088        List<ImageryPreferenceEntry> entries = StructUtils.getListOfStructs(pref, "imagery.entries", null, ImageryPreferenceEntry.class);
     1089        if (entries == null) {
     1090            return Collections.emptyList();
     1091        }
     1092        return entries.stream()
     1093                .filter(prefEntry -> prefEntry.id != null && !prefEntry.id.isEmpty())
     1094                .map(prefEntry -> prefEntry.id)
     1095                .sorted()
     1096                .collect(Collectors.toList());
    11091097    }
    11101098
     
    12301218        this.serverProjections = serverProjections.stream()
    12311219                .map(String::intern)
    1232                 .collect(Collectors.collectingAndThen(Collectors.toList(), Utils::toUnmodifiableList));
     1220                .collect(StreamUtils.toUnmodifiableList());
    12331221    }
    12341222
  • trunk/src/org/openstreetmap/josm/data/imagery/ImageryLayerInfo.java

    r16426 r16436  
    1717import java.util.TreeSet;
    1818import java.util.concurrent.ExecutorService;
     19import java.util.stream.Collectors;
    1920
    2021import org.openstreetmap.josm.data.StructUtils;
     
    266267                    if (def.getId() != null) {
    267268                        newKnownDefaults.add(def.getId());
    268                         for (ImageryInfo i : layers) {
    269                             if (isSimilar(def, i)) {
    270                                 isInUserList = true;
    271                                 break;
    272                             }
    273                         }
     269                        isInUserList = layers.stream().anyMatch(i -> isSimilar(def, i));
    274270                    } else {
    275271                        Logging.error("Default imagery ''{0}'' has no id. Skipping.", def.getName());
     
    362358     */
    363359    public void save() {
    364         List<ImageryPreferenceEntry> entries = new ArrayList<>();
    365         for (ImageryInfo info : layers) {
    366             entries.add(new ImageryPreferenceEntry(info));
    367         }
     360        List<ImageryPreferenceEntry> entries = layers.stream()
     361                .map(ImageryPreferenceEntry::new)
     362                .collect(Collectors.toList());
    368363        StructUtils.putListOfStructs(Config.getPref(), "imagery.entries", entries, ImageryPreferenceEntry.class);
    369364    }
  • trunk/src/org/openstreetmap/josm/data/imagery/OffsetBookmark.java

    r14120 r16436  
    348348     */
    349349    public static OffsetBookmark getBookmarkByName(ImageryLayer layer, String name) {
    350         for (OffsetBookmark b : allBookmarks) {
    351             if (b.isUsable(layer) && name.equals(b.name))
    352                 return b;
    353         }
    354         return null;
     350        return allBookmarks.stream()
     351                .filter(b -> b.isUsable(layer) && name.equals(b.name))
     352                .findFirst().orElse(null);
    355353    }
    356354
  • trunk/src/org/openstreetmap/josm/data/imagery/Shape.java

    r12453 r16436  
    88import java.util.List;
    99import java.util.Objects;
     10import java.util.stream.Collectors;
     11import java.util.stream.Stream;
    1012
    1113import org.openstreetmap.gui.jmapviewer.Coordinate;
     
    4345    }
    4446
     47    /**
     48     * Encodes this as a string so that it may be parsed using {@link #Shape(String, String)}
     49     * @param separator The separator
     50     * @return The string encoded shape
     51     */
    4552    public String encodeAsString(String separator) {
    46         StringBuilder sb = new StringBuilder();
    47         for (Coordinate c : coords) {
    48             if (sb.length() != 0) {
    49                 sb.append(separator);
    50             }
    51             sb.append(c.getLat()).append(separator).append(c.getLon());
    52         }
    53         return sb.toString();
     53        return coords.stream()
     54                .flatMap(c -> Stream.of(c.getLat(), c.getLon()))
     55                .map(String::valueOf)
     56                .collect(Collectors.joining(separator));
     57    }
     58
     59    /**
     60     * Encodes the shapes as a string using {@code ,} and {@code ;} as separators
     61     * @return The string encoded shapes
     62     */
     63    public static String encodeAsString(List<Shape> shapes) {
     64        return shapes.stream()
     65                .map(s -> s.encodeAsString(","))
     66                .collect(Collectors.joining(";"));
    5467    }
    5568
     
    6174        if (latlon == null)
    6275            return false;
    63         List<Node> nodes = new ArrayList<>(coords.size());
    64         for (Coordinate c : coords) {
    65             nodes.add(new Node(new LatLon(c.getLat(), c.getLon())));
    66         }
     76        List<Node> nodes = coords.stream()
     77                .map(c -> new Node(new LatLon(c.getLat(), c.getLon())))
     78                .collect(Collectors.toList());
    6779        return Geometry.nodeInsidePolygon(new Node(latlon), nodes);
    6880    }
  • trunk/src/org/openstreetmap/josm/data/imagery/WMTSTileSource.java

    r16106 r16436  
    856856        if (this.currentLayer != null) {
    857857            this.currentTileMatrixSet = this.currentLayer.tileMatrixSet;
    858             Collection<Double> scales = new ArrayList<>(currentTileMatrixSet.tileMatrix.size());
    859             for (TileMatrix tileMatrix : currentTileMatrixSet.tileMatrix) {
    860                 scales.add(tileMatrix.scaleDenominator * 0.28e-03);
    861             }
     858            Collection<Double> scales = currentTileMatrixSet.tileMatrix.stream()
     859                    .map(tileMatrix -> tileMatrix.scaleDenominator * 0.28e-03)
     860                    .collect(Collectors.toList());
    862861            this.nativeScaleList = new ScaleList(scales);
    863862        }
     
    10611060        Matcher m = Pattern.compile("\\{[^}]*\\}").matcher(url);
    10621061        while (m.find()) {
    1063             boolean isSupportedPattern = false;
    1064             for (String pattern : ALL_PATTERNS) {
    1065                 if (m.group().matches(pattern)) {
    1066                     isSupportedPattern = true;
    1067                     break;
    1068                 }
    1069             }
     1062            boolean isSupportedPattern = Arrays.stream(ALL_PATTERNS).anyMatch(pattern -> m.group().matches(pattern));
    10701063            if (!isSupportedPattern) {
    10711064                throw new IllegalArgumentException(
     
    10891082     */
    10901083    public Collection<String> getSupportedProjections() {
    1091         Collection<String> ret = new LinkedHashSet<>();
    1092         if (currentLayer == null) {
    1093             for (Layer layer: this.layers) {
    1094                 ret.add(layer.tileMatrixSet.crs);
    1095             }
    1096         } else {
    1097             for (Layer layer: this.layers) {
    1098                 if (currentLayer.identifier.equals(layer.identifier)) {
    1099                     ret.add(layer.tileMatrixSet.crs);
    1100                 }
    1101             }
    1102         }
    1103         return ret;
     1084        return this.layers.stream()
     1085                .filter(layer -> currentLayer == null || currentLayer.identifier.equals(layer.identifier))
     1086                .map(layer -> layer.tileMatrixSet.crs)
     1087                .collect(Collectors.toCollection(LinkedHashSet::new));
    11041088    }
    11051089
  • trunk/src/org/openstreetmap/josm/data/projection/CustomProjection.java

    r14058 r16436  
    1414import java.util.regex.Matcher;
    1515import java.util.regex.Pattern;
     16import java.util.stream.IntStream;
    1617
    1718import org.openstreetmap.josm.data.Bounds;
     
    521522            }
    522523        }
    523         boolean isCentric = true;
    524         for (Double param : towgs84Param) {
    525             if (param != 0) {
    526                 isCentric = false;
    527                 break;
    528             }
    529         }
     524        boolean isCentric = towgs84Param.stream().noneMatch(param -> param != 0);
    530525        if (isCentric)
    531526            return Ellipsoid.WGS84.equals(ellps) ? WGS84Datum.INSTANCE : new CentricDatum(null, null, ellps);
    532         boolean is3Param = true;
    533         for (int i = 3; i < towgs84Param.size(); i++) {
    534             if (towgs84Param.get(i) != 0) {
    535                 is3Param = false;
    536                 break;
    537             }
    538         }
     527        boolean is3Param = IntStream.range(3, towgs84Param.size()).noneMatch(i -> towgs84Param.get(i) != 0);
    539528        if (is3Param)
    540529            return new ThreeParameterDatum(null, null, ellps,
  • trunk/src/org/openstreetmap/josm/data/projection/datum/NTV2Proj4DirGridShiftFileSource.java

    r14624 r16436  
    4343    @Override
    4444    public InputStream getNTV2GridShiftFile(String gridFileName) {
    45         File grid = null;
    4645        // Check is the grid is installed in default PROJ.4 directories
    47         for (File dir : Platform.determinePlatform().accept(this)) {
    48             File file = new File(dir, gridFileName);
    49             if (file.exists() && file.isFile()) {
    50                 grid = file;
    51                 break;
    52             }
    53         }
     46        File grid = Platform.determinePlatform().accept(this).stream()
     47                .map(dir -> new File(dir, gridFileName))
     48                .filter(file -> file.exists() && file.isFile())
     49                .findFirst().orElse(null);
    5450        // If not, search into PROJ_LIB directory
    5551        if (grid == null) {
  • trunk/src/org/openstreetmap/josm/data/projection/datum/NTV2SubGrid.java

    r13627 r16436  
    2424import java.io.Serializable;
    2525import java.nio.charset.StandardCharsets;
     26import java.util.Arrays;
    2627
    2728import org.openstreetmap.josm.tools.Logging;
     
    171172     */
    172173    public NTV2SubGrid getSubGridForCoord(double lon, double lat) {
    173         if (isCoordWithin(lon, lat)) {
    174             if (subGrid == null)
    175                 return this;
    176             else {
    177                 for (NTV2SubGrid aSubGrid : subGrid) {
    178                     if (aSubGrid.isCoordWithin(lon, lat))
    179                         return aSubGrid.getSubGridForCoord(lon, lat);
    180                 }
    181                 return this;
    182             }
    183         } else
    184             return null;
     174        return !isCoordWithin(lon, lat)
     175                ? null
     176                : subGrid == null
     177                ? this
     178                : Arrays.stream(subGrid)
     179                .filter(aSubGrid -> aSubGrid.isCoordWithin(lon, lat))
     180                .map(aSubGrid -> aSubGrid.getSubGridForCoord(lon, lat))
     181                .findFirst().orElse(this);
    185182    }
    186183
  • trunk/src/org/openstreetmap/josm/gui/autofilter/AutoFilterManager.java

    r15893 r16436  
    343343     */
    344344    public synchronized AutoFilterRule getAutoFilterRule(String key) {
    345         for (AutoFilterRule r : rules) {
    346             if (key.equals(r.getKey())) {
    347                 return r;
    348             }
    349         }
    350         return null;
     345        return rules.stream()
     346                .filter(r -> Objects.equals(key, r.getKey()))
     347                .findFirst().orElse(null);
    351348    }
    352349
  • trunk/src/org/openstreetmap/josm/gui/conflict/pair/AbstractListMergeModel.java

    r14710 r16436  
    1818import java.util.Map;
    1919import java.util.Set;
     20import java.util.stream.Collectors;
     21import java.util.stream.IntStream;
    2022
    2123import javax.swing.AbstractListModel;
     
    369371
    370372    protected void alertCopyFailedForDeletedPrimitives(List<PrimitiveId> deletedIds) {
    371         List<String> items = new ArrayList<>();
    372         for (int i = 0; i < Math.min(MAX_DELETED_PRIMITIVE_IN_DIALOG, deletedIds.size()); i++) {
    373             items.add(deletedIds.get(i).toString());
    374         }
     373        List<String> items = deletedIds.stream().limit(MAX_DELETED_PRIMITIVE_IN_DIALOG).map(Object::toString).collect(Collectors.toList());
    375374        if (deletedIds.size() > MAX_DELETED_PRIMITIVE_IN_DIALOG) {
    376375            items.add(tr("{0} more...", deletedIds.size() - MAX_DELETED_PRIMITIVE_IN_DIALOG));
     
    422421        getMergedEntries().clear();
    423422
    424         int[] rows = new int[entries.get(source).size()];
    425         for (int i = 0; i < rows.length; i++) {
    426             rows[i] = i;
    427         }
     423        int[] rows = IntStream.range(0, entries.get(source).size()).toArray();
    428424        copy(source, rows, 0);
    429425    }
     
    588584     */
    589585    protected boolean myAndTheirEntriesEqual() {
    590         if (getMyEntriesSize() != getTheirEntriesSize())
    591             return false;
    592         for (int i = 0; i < getMyEntriesSize(); i++) {
    593             if (!isEqualEntry(getMyEntries().get(i), getTheirEntries().get(i)))
    594                 return false;
    595         }
    596         return true;
     586        return getMyEntriesSize() == getTheirEntriesSize()
     587                && IntStream.range(0, getMyEntriesSize()).allMatch(i -> isEqualEntry(getMyEntries().get(i), getTheirEntries().get(i)));
    597588    }
    598589
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r15706 r16436  
    1919import java.util.concurrent.ExecutionException;
    2020import java.util.concurrent.Future;
     21import java.util.stream.Collectors;
    2122
    2223import javax.swing.AbstractAction;
     
    305306            if (ds == null || ids == null)
    306307                return;
    307             Set<OsmPrimitive> sel = new HashSet<>();
    308             for (OsmPrimitive p: ds.allPrimitives()) {
    309                 if (ids.contains(p.getChangesetId())) {
    310                     sel.add(p);
    311                 }
    312             }
     308            Set<OsmPrimitive> sel = ds.allPrimitives().stream()
     309                    .filter(p -> ids.contains(p.getChangesetId()))
     310                    .collect(Collectors.toSet());
    313311            ds.setSelected(sel);
    314312        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManager.java

    r16433 r16436  
    1818import java.awt.event.WindowEvent;
    1919import java.util.Collection;
    20 import java.util.HashSet;
    2120import java.util.List;
    2221import java.util.Objects;
     
    739738            return;
    740739        }
    741         Set<Changeset> toSelect = new HashSet<>();
    742740        ChangesetCache cc = ChangesetCache.getInstance();
    743         for (int id: ids) {
    744             if (cc.contains(id)) {
    745                 toSelect.add(cc.get(id));
    746             }
    747         }
     741        Set<Changeset> toSelect = ids.stream()
     742                .filter(cc::contains)
     743                .map(cc::get)
     744                .collect(Collectors.toSet());
    748745        setSelectedChangesets(toSelect);
    749746    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetCacheManagerModel.java

    r16121 r16436  
    77import java.util.Collection;
    88import java.util.Comparator;
    9 import java.util.HashSet;
    109import java.util.List;
    1110import java.util.Set;
     11import java.util.stream.Collectors;
    1212
    1313import javax.swing.DefaultListSelectionModel;
     
    102102     */
    103103    public Set<Integer> getSelectedChangesetIds() {
    104         Set<Integer> ret = new HashSet<>();
    105         for (Changeset cs: getSelectedChangesets()) {
    106             ret.add(cs.getId());
    107         }
    108         return ret;
     104        return getSelectedChangesets().stream().map(Changeset::getId).collect(Collectors.toSet());
    109105    }
    110106
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetContentPanel.java

    r16216 r16436  
    1212import java.beans.PropertyChangeEvent;
    1313import java.beans.PropertyChangeListener;
    14 import java.util.ArrayList;
    1514import java.util.Collection;
    1615import java.util.Collections;
     
    263262
    264263        protected List<HistoryOsmPrimitive> filterPrimitivesWithUnloadedHistory(Collection<HistoryOsmPrimitive> primitives) {
    265             List<HistoryOsmPrimitive> ret = new ArrayList<>(primitives.size());
    266             for (HistoryOsmPrimitive p: primitives) {
    267                 if (HistoryDataSet.getInstance().getHistory(p.getPrimitiveId()) == null) {
    268                     ret.add(p);
    269                 }
    270             }
    271             return ret;
     264            return primitives.stream()
     265                    .filter(p -> HistoryDataSet.getInstance().getHistory(p.getPrimitiveId()) == null)
     266                    .collect(Collectors.toList());
    272267        }
    273268
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetContentTableModel.java

    r16218 r16436  
    33
    44import java.util.ArrayList;
    5 import java.util.HashSet;
     5import java.util.Arrays;
    66import java.util.Iterator;
    77import java.util.List;
    88import java.util.Set;
     9import java.util.stream.Collectors;
    910
    1011import javax.swing.DefaultListSelectionModel;
     
    6566     */
    6667    public Set<HistoryOsmPrimitive> getSelectedPrimitives(JTable table) {
    67         Set<HistoryOsmPrimitive> ret = new HashSet<>();
    6868        int[] selection = table.getSelectedRows();
    69         for (int i = 0; i < selection.length; i++) {
    70             ret.add(data.get(table.convertRowIndexToModel(selection[i])).getPrimitive());
    71         }
    72         return ret;
     69        return Arrays.stream(selection)
     70                .mapToObj(i -> data.get(table.convertRowIndexToModel(i)).getPrimitive())
     71                .collect(Collectors.toSet());
    7372    }
    7473
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetDetailPanel.java

    r16305 r16436  
    1616import java.util.Collections;
    1717import java.util.Date;
    18 import java.util.HashSet;
    1918import java.util.Set;
     19import java.util.stream.Collectors;
    2020
    2121import javax.swing.AbstractAction;
     
    372372                return;
    373373            }
    374             Set<OsmPrimitive> target = new HashSet<>();
    375             for (OsmPrimitive p: ds.allPrimitives()) {
    376                 if (p.isUsable() && p.getChangesetId() == currentChangeset.getId()) {
    377                     target.add(p);
    378                 }
    379             }
     374            Set<OsmPrimitive> target = ds.allPrimitives().stream()
     375                    .filter(p -> p.isUsable() && p.getChangesetId() == currentChangeset.getId())
     376                    .collect(Collectors.toSet());
    380377            if (target.isEmpty()) {
    381378                alertNoPrimitivesToSelect();
     
    431428                return;
    432429            }
    433             Set<OsmPrimitive> target = new HashSet<>();
    434             for (OsmPrimitive p: ds.allPrimitives()) {
    435                 if (p.isUsable() && p.getChangesetId() == currentChangeset.getId()) {
    436                     target.add(p);
    437                 }
    438             }
     430            Set<OsmPrimitive> target = ds.allPrimitives().stream()
     431                    .filter(p -> p.isUsable() && p.getChangesetId() == currentChangeset.getId())
     432                    .collect(Collectors.toSet());
    439433            if (target.isEmpty()) {
    440434                alertNoPrimitivesToZoomTo();
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetListModel.java

    r14344 r16436  
    55import java.util.Collection;
    66import java.util.Comparator;
    7 import java.util.HashSet;
    87import java.util.List;
    98import java.util.Set;
     9import java.util.stream.Collectors;
     10import java.util.stream.IntStream;
    1011
    1112import javax.swing.DefaultListModel;
    1213import javax.swing.DefaultListSelectionModel;
    1314
     15import org.openstreetmap.josm.data.osm.AbstractPrimitive;
    1416import org.openstreetmap.josm.data.osm.Changeset;
    1517import org.openstreetmap.josm.data.osm.ChangesetCache;
     
    4244     */
    4345    public synchronized Set<Changeset> getSelectedChangesets() {
    44         Set<Changeset> ret = new HashSet<>();
    45         for (int i = 0; i < getSize(); i++) {
    46             if (selectionModel.isSelectedIndex(i)) {
    47                 ret.add(data.get(i));
    48             }
    49         }
    50         return ret;
     46        return IntStream.range(0, getSize()).filter(selectionModel::isSelectedIndex)
     47                .mapToObj(data::get).collect(Collectors.toSet());
    5148    }
    5249
     
    5653     */
    5754    public synchronized Set<Integer> getSelectedChangesetIds() {
    58         Set<Integer> ret = new HashSet<>();
    59         for (int i = 0; i < getSize(); i++) {
    60             if (selectionModel.isSelectedIndex(i)) {
    61                 ret.add(data.get(i).getId());
    62             }
    63         }
    64         return ret;
     55        return IntStream.range(0, getSize()).filter(selectionModel::isSelectedIndex)
     56                .mapToObj(data::get).map(Changeset::getId).collect(Collectors.toSet());
    6557    }
    6658
     
    115107            return;
    116108        }
    117         Set<Changeset> changesets = new HashSet<>(ids.size());
    118         for (int id: ids) {
    119             if (id <= 0) {
    120                 continue;
    121             }
    122             changesets.add(new Changeset(id));
    123         }
     109        Set<Changeset> changesets = ids.stream().mapToInt(id -> id)
     110                .filter(id -> id > 0).mapToObj(Changeset::new).collect(Collectors.toSet());
    124111        setChangesets(changesets);
    125112    }
     
    134121            return;
    135122        }
    136         Set<Changeset> changesets = new HashSet<>();
    137         for (OsmPrimitive p: primitives) {
    138             if (p.getChangesetId() <= 0) {
    139                 continue;
    140             }
    141             changesets.add(new Changeset(p.getChangesetId()));
    142         }
    143         setChangesets(changesets);
     123        initFromChangesetIds(primitives.stream().map(AbstractPrimitive::getChangesetId).collect(Collectors.toList()));
    144124    }
    145125
     
    153133            return;
    154134        }
    155         Set<Changeset> changesets = new HashSet<>();
    156         for (OsmPrimitive p: ds.allPrimitives()) {
    157             if (p.getChangesetId() <= 0) {
    158                 continue;
    159             }
    160             changesets.add(new Changeset(p.getChangesetId()));
    161         }
    162         setChangesets(changesets);
     135        initFromChangesetIds(ds.allPrimitives().stream().map(AbstractPrimitive::getChangesetId).collect(Collectors.toList()));
    163136    }
    164137
     
    192165     */
    193166    public synchronized List<Changeset> getSelectedOpenChangesets() {
    194         List<Changeset> ret = new ArrayList<>();
    195         for (int i = 0; i < getSize(); i++) {
    196             if (selectionModel.isSelectedIndex(i)) {
    197                 Changeset cs = data.get(i);
    198                 if (cs.isOpen()) {
    199                     ret.add(cs);
    200                 }
    201             }
    202         }
    203         return ret;
     167        return IntStream.range(0, getSize())
     168                .filter(selectionModel::isSelectedIndex)
     169                .mapToObj(data::get)
     170                .filter(Changeset::isOpen)
     171                .collect(Collectors.toList());
    204172    }
    205173
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/BasicChangesetQueryPanel.java

    r16075 r16436  
    1010import java.awt.event.ItemEvent;
    1111import java.awt.event.ItemListener;
     12import java.util.Arrays;
    1213import java.util.EnumMap;
    1314import java.util.Map;
     
    178179
    179180    protected BasicQuery getSelectedQuery() {
    180         for (BasicQuery q : BasicQuery.values()) {
    181             if (rbQueries.get(q).isSelected())
    182                 return q;
    183         }
    184         return null;
     181        return Arrays.stream(BasicQuery.values())
     182                .filter(q -> rbQueries.get(q).isSelected())
     183                .findFirst().orElse(null);
    185184    }
    186185
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ChildRelationBrowser.java

    r16189 r16436  
    1414import java.io.IOException;
    1515import java.util.Arrays;
    16 import java.util.HashSet;
    1716import java.util.List;
    1817import java.util.Set;
     
    302301            if (selection == null || selection.length == 0)
    303302                return;
    304             Set<Relation> relations = new HashSet<>();
    305             for (TreePath aSelection : selection) {
    306                 relations.add((Relation) aSelection.getLastPathComponent());
    307             }
     303            Set<Relation> relations = Arrays.stream(selection)
     304                    .map(s -> (Relation) s.getLastPathComponent())
     305                    .collect(Collectors.toSet());
    308306            MainApplication.worker.submit(new DownloadRelationSetTask(getParentDialog(), relations));
    309307        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java

    r15696 r16436  
    479479     */
    480480    public int getNumMembersWithPrimitive(OsmPrimitive primitive) {
    481         int count = 0;
    482         for (RelationMember member : members) {
    483             if (member.getMember().equals(primitive)) {
    484                 count++;
    485             }
    486         }
    487         return count;
     481        return (int) members.stream().filter(member -> member.getMember().equals(primitive)).count();
    488482    }
    489483
  • trunk/src/org/openstreetmap/josm/gui/layer/AbstractTileSourceLayer.java

    r15963 r16436  
    17011701     */
    17021702    private List<Action> getMenuAdditions() {
    1703         final LinkedList<Action> menuAdds = new LinkedList<>();
    1704         for (MenuAddition menuAdd: menuAdditions) {
    1705             if (menuAdd.clazz.isInstance(this)) {
    1706                 menuAdds.add(menuAdd.addition);
    1707             }
    1708         }
     1703        final LinkedList<Action> menuAdds = menuAdditions.stream()
     1704                .filter(menuAdd -> menuAdd.clazz.isInstance(this))
     1705                .map(menuAdd -> menuAdd.addition)
     1706                .collect(Collectors.toCollection(LinkedList::new));
    17091707        if (!menuAdds.isEmpty()) {
    17101708            menuAdds.addFirst(SeparatorLayerAction.INSTANCE);
  • trunk/src/org/openstreetmap/josm/gui/layer/AutosaveTask.java

    r14746 r16436  
    178178        while (true) {
    179179            String filename = getFileName(layer.layer.getName(), index);
    180             boolean foundTheSame = false;
    181             for (AutosaveLayerInfo<?> info: layersInfo) {
    182                 if (info != layer && filename.equals(info.layerFileName)) {
    183                     foundTheSame = true;
    184                     break;
    185                 }
    186             }
    187 
     180            boolean foundTheSame = layersInfo.stream().anyMatch(info -> info != layer && filename.equals(info.layerFileName));
    188181            if (!foundTheSame) {
    189182                layer.layerFileName = filename;
  • trunk/src/org/openstreetmap/josm/gui/layer/gpx/ChooseTrackVisibilityAction.java

    r16398 r16436  
    1414import java.awt.event.MouseListener;
    1515import java.io.Serializable;
    16 import java.util.ArrayList;
    1716import java.util.Arrays;
    1817import java.util.Comparator;
     
    2120import java.util.Objects;
    2221import java.util.Optional;
     22import java.util.stream.Collectors;
    2323
    2424import javax.swing.AbstractAction;
     
    297297            protected void buttonAction(int buttonIndex, ActionEvent evt) {
    298298                if (buttonIndex == 0) {
    299                     List<IGpxTrack> trks = new ArrayList<>();
    300                     for (int i : table.getSelectedRows()) {
    301                         Object trk = content[i][5];
    302                         if (trk != null && trk instanceof IGpxTrack) {
    303                             trks.add((IGpxTrack) trk);
    304                         }
    305                     }
     299                    List<IGpxTrack> trks = Arrays.stream(table.getSelectedRows())
     300                            .mapToObj(i -> content[i][5])
     301                            .filter(trk -> trk instanceof IGpxTrack)
     302                            .map(IGpxTrack.class::cast)
     303                            .collect(Collectors.toList());
    306304                    showColorDialog(trks);
    307305                } else {
  • trunk/src/org/openstreetmap/josm/gui/mappaint/Cascade.java

    r16252 r16436  
    1010import java.util.TreeSet;
    1111import java.util.regex.Pattern;
     12import java.util.stream.Collectors;
    1213
    1314import org.openstreetmap.josm.gui.mappaint.mapcss.CSSColors;
     
    240241    @Override
    241242    public String toString() {
    242         StringBuilder res = new StringBuilder("Cascade{ ");
    243243        // List properties in alphabetical order to be deterministic, without changing "prop" to a TreeMap
    244244        // (no reason too, not sure about the potential memory/performance impact of such a change)
     
    257257            props.add(sb.toString());
    258258        }
    259         for (String s : props) {
    260             res.append(s);
    261         }
    262         return res.append('}').toString();
     259        return props.stream().collect(Collectors.joining("", "Cascade{ ", "}"));
    263260    }
    264261
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionManager.java

    r15736 r16436  
    1616import java.util.Set;
    1717import java.util.function.Function;
     18import java.util.stream.Collectors;
    1819
    1920import org.openstreetmap.josm.data.osm.DataSet;
     
    233234
    234235    protected Collection<String> getUserInputKeys() {
    235         List<String> keys = new ArrayList<>();
    236         for (UserInputTag tag : USER_INPUT_TAG_CACHE) {
    237             if (!tag.defaultKey) {
    238                 keys.add(tag.key);
    239             }
    240         }
     236        List<String> keys = USER_INPUT_TAG_CACHE.stream()
     237                .filter(tag -> !tag.defaultKey)
     238                .map(tag -> tag.key)
     239                .collect(Collectors.toList());
    241240        Collections.reverse(keys);
    242241        return new LinkedHashSet<>(keys);
     
    255254
    256255    protected static Collection<String> getUserInputValues(String key) {
    257         List<String> values = new ArrayList<>();
    258         for (UserInputTag tag : USER_INPUT_TAG_CACHE) {
    259             if (key.equals(tag.key)) {
    260                 values.add(tag.value);
    261             }
    262         }
     256        List<String> values = USER_INPUT_TAG_CACHE.stream()
     257                .filter(tag -> Objects.equals(key, tag.key))
     258                .map(tag -> tag.value)
     259                .collect(Collectors.toList());
    263260        Collections.reverse(values);
    264261        return new LinkedHashSet<>(values);
  • trunk/src/org/openstreetmap/josm/io/Capabilities.java

    r13901 r16436  
    218218     */
    219219    public boolean isOnImageryBlacklist(String url) {
    220         if (url != null && imageryBlacklist != null) {
    221             for (String blacklistRegex : imageryBlacklist) {
    222                 if (url.matches(blacklistRegex))
    223                     return true;
    224             }
    225         }
    226         return false;
     220        return url != null && imageryBlacklist.stream().anyMatch(url::matches);
    227221    }
    228222
  • trunk/src/org/openstreetmap/josm/io/CertificateAmendment.java

    r16120 r16436  
    288288            throws KeyStoreException, InvalidAlgorithmParameterException {
    289289        PKIXParameters params = new PKIXParameters(keyStore);
    290         String id = crt.getSubjectX500Principal().getName();
    291         for (TrustAnchor ta : params.getTrustAnchors()) {
    292             X509Certificate cert = ta.getTrustedCert();
    293             if (Objects.equals(id, cert.getSubjectX500Principal().getName()))
    294                 return false;
    295         }
    296         return true;
     290        return params.getTrustAnchors().stream()
     291                .map(TrustAnchor::getTrustedCert)
     292                .noneMatch(c -> Objects.equals(crt.getSubjectX500Principal().getName(), c.getSubjectX500Principal().getName()));
    297293    }
    298294}
  • trunk/src/org/openstreetmap/josm/io/OsmServerUserInfoReader.java

    r14159 r16436  
    55
    66import java.time.DateTimeException;
    7 import java.util.LinkedList;
    87import java.util.List;
     8import java.util.stream.Collectors;
     9import java.util.stream.IntStream;
    910
    1011import javax.xml.xpath.XPath;
     
    109110            NodeList xmlNodeList = (NodeList) xpath.compile("/osm/user[1]/languages[1]/lang/text()").evaluate(document, XPathConstants.NODESET);
    110111            if (xmlNodeList != null) {
    111                 List<String> languages = new LinkedList<>();
    112                 for (int i = 0; i < xmlNodeList.getLength(); i++) {
    113                     languages.add(xmlNodeList.item(i).getNodeValue());
    114                 }
     112                List<String> languages = IntStream.range(0, xmlNodeList.getLength())
     113                        .mapToObj(i -> xmlNodeList.item(i).getNodeValue())
     114                        .collect(Collectors.toList());
    115115                userInfo.setLanguages(languages);
    116116            }
  • trunk/src/org/openstreetmap/josm/io/nmea/NmeaReader.java

    r15496 r16436  
    1010import java.text.SimpleDateFormat;
    1111import java.util.ArrayList;
     12import java.util.Arrays;
    1213import java.util.Collection;
    1314import java.util.Collections;
     
    295296     */
    296297    static boolean isSentence(String address, Sentence formatter) {
    297         for (TalkerId talker : TalkerId.values()) {
    298             if (address.equals('$' + talker.name() + formatter.name())) {
    299                 return true;
    300             }
    301         }
    302         return false;
     298        return Arrays.stream(TalkerId.values())
     299                .anyMatch(talker -> address.equals('$' + talker.name() + formatter.name()));
    303300    }
    304301
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/AddTagsDialog.java

    r16328 r16436  
    1515import java.util.HashSet;
    1616import java.util.Map;
    17 import java.util.Map.Entry;
    1817import java.util.Set;
     18import java.util.stream.Collectors;
    1919
    2020import javax.swing.AbstractAction;
     
    104104        @Override
    105105        public String toString() {
    106             StringBuilder sb = new StringBuilder();
    107             for (String k: valueCount.keySet()) {
    108                 if (sb.length() > 0) sb.append(", ");
    109                 sb.append(k);
    110             }
    111             return sb.toString();
     106            return String.join(", ", valueCount.keySet());
    112107        }
    113108
    114109        private String getToolTip() {
    115             StringBuilder sb = new StringBuilder(64);
    116             sb.append("<html>")
    117               .append(tr("Old values of"))
    118               .append(" <b>")
    119               .append(tag)
    120               .append("</b><br/>");
    121             for (Entry<String, Integer> e : valueCount.entrySet()) {
    122                 sb.append("<b>")
    123                   .append(e.getValue())
    124                   .append(" x </b>")
    125                   .append(e.getKey())
    126                   .append("<br/>");
    127             }
    128             sb.append("</html>");
    129             return sb.toString();
     110            return valueCount.entrySet().stream()
     111                    .map(e -> "<b>" + e.getValue() + " x </b>" + e.getKey() + "<br/>")
     112                    .collect(Collectors.joining("", "<html>" + tr("Old values of") + " <b>" + tag + "</b><br/>", "</html>"));
    130113        }
    131114    }
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/ImageryHandler.java

    r15720 r16436  
    4949
    5050    protected static ImageryInfo findBingEntry() {
    51         for (ImageryInfo i : ImageryLayerInfo.instance.getDefaultLayers()) {
    52             if (ImageryType.BING == i.getImageryType()) {
    53                 return i;
    54             }
    55         }
    56         return null;
     51        return ImageryLayerInfo.instance.getDefaultLayers().stream()
     52                .filter(i -> ImageryType.BING == i.getImageryType())
     53                .findFirst().orElse(null);
    5754    }
    5855
  • trunk/src/org/openstreetmap/josm/io/session/ImagerySessionImporter.java

    r12851 r16436  
    55
    66import java.io.IOException;
    7 import java.util.HashMap;
    87import java.util.Map;
     8import java.util.stream.Collectors;
     9import java.util.stream.IntStream;
    910
    1011import org.openstreetmap.josm.data.StructUtils;
     
    8788
    8889    private static Map<String, String> readProperties(Element elem) {
    89         Map<String, String> attributes = new HashMap<>();
    9090        NodeList nodes = elem.getChildNodes();
    91         for (int i = 0; i < nodes.getLength(); ++i) {
    92             Node node = nodes.item(i);
    93             if (node.getNodeType() == Node.ELEMENT_NODE && node.getChildNodes().getLength() <= 1) {
    94                 Element e = (Element) node;
    95                 attributes.put(e.getTagName(), e.getTextContent());
    96             }
    97         }
    98         return attributes;
     91        return IntStream.range(0, nodes.getLength()).mapToObj(nodes::item)
     92                .filter(node -> node.getNodeType() == Node.ELEMENT_NODE && node.getChildNodes().getLength() <= 1)
     93                .map(node -> (Element) node)
     94                .collect(Collectors.toMap(Element::getTagName, Node::getTextContent, (a, b) -> b));
    9995    }
    10096}
  • trunk/src/org/openstreetmap/josm/io/session/SessionReader.java

    r15077 r16436  
    2424import java.util.Map.Entry;
    2525import java.util.TreeMap;
     26import java.util.stream.Collectors;
     27import java.util.stream.IntStream;
    2628import java.util.zip.ZipEntry;
    2729import java.util.zip.ZipException;
     
    651653        Element parametersEl = getElementByTagName(projectionChoiceEl, "parameters");
    652654        if (parametersEl == null) return null;
    653         Collection<String> parameters = new ArrayList<>();
    654655        NodeList paramNl = parametersEl.getElementsByTagName("param");
    655656        int length = paramNl.getLength();
    656         for (int i = 0; i < length; i++) {
    657             Element paramEl = (Element) paramNl.item(i);
    658             parameters.add(paramEl.getTextContent());
    659         }
     657        Collection<String> parameters = IntStream.range(0, length)
     658                .mapToObj(i -> (Element) paramNl.item(i)).map(Node::getTextContent)
     659                .collect(Collectors.toList());
    660660        return new SessionProjectionChoiceData(id, parameters);
    661661    }
  • trunk/src/org/openstreetmap/josm/spi/preferences/AbstractPreferences.java

    r14147 r16436  
    77import java.util.Map.Entry;
    88import java.util.TreeMap;
     9import java.util.stream.Collectors;
    910
    1011import org.openstreetmap.josm.tools.Logging;
     
    158159     */
    159160    public Map<String, String> getAllPrefix(String prefix) {
    160         final Map<String, String> all = new TreeMap<>();
    161         for (final Entry<String, Setting<?>> e : getAllSettings().entrySet()) {
    162             if (e.getKey().startsWith(prefix) && (e.getValue() instanceof StringSetting)) {
    163                 all.put(e.getKey(), ((StringSetting) e.getValue()).getValue());
    164             }
    165         }
    166         return all;
     161        return getAllSettings().entrySet().stream()
     162                .filter(e -> e.getKey().startsWith(prefix) && (e.getValue() instanceof StringSetting))
     163                .collect(Collectors.toMap(Entry::getKey, e -> ((StringSetting) e.getValue()).getValue(), (a, b) -> b, TreeMap::new));
    167164    }
    168165
     
    173170     */
    174171    public List<String> getAllPrefixCollectionKeys(String prefix) {
    175         final List<String> all = new LinkedList<>();
    176         for (Entry<String, Setting<?>> entry : getAllSettings().entrySet()) {
    177             if (entry.getKey().startsWith(prefix) && entry.getValue() instanceof ListSetting) {
    178                 all.add(entry.getKey());
    179             }
    180         }
    181         return all;
     172        return getAllSettings().entrySet().stream()
     173                .filter(entry -> entry.getKey().startsWith(prefix) && entry.getValue() instanceof ListSetting)
     174                .map(Entry::getKey)
     175                .collect(Collectors.toCollection(LinkedList::new));
    182176    }
    183177}
  • trunk/src/org/openstreetmap/josm/spi/preferences/ListListSetting.java

    r12882 r16436  
    44import java.util.ArrayList;
    55import java.util.Collection;
    6 import java.util.Collections;
    76import java.util.List;
     7import java.util.stream.Collectors;
     8
     9import org.openstreetmap.josm.tools.StreamUtils;
     10import org.openstreetmap.josm.tools.Utils;
    811
    912/**
     
    2932    public static ListListSetting create(Collection<Collection<String>> value) {
    3033        if (value != null) {
    31             List<List<String>> valueList = new ArrayList<>(value.size());
    32             for (Collection<String> lst : value) {
    33                 valueList.add(new ArrayList<>(lst));
    34             }
     34            List<List<String>> valueList = value.stream()
     35                    .map(ArrayList::new)
     36                    .collect(Collectors.toList());
    3537            return new ListListSetting(valueList);
    3638        }
     
    4345            return new ListListSetting(null);
    4446
    45         List<List<String>> copy = new ArrayList<>(value.size());
    46         for (Collection<String> lst : value) {
    47             List<String> lstCopy = new ArrayList<>(lst);
    48             copy.add(Collections.unmodifiableList(lstCopy));
    49         }
    50         return new ListListSetting(Collections.unmodifiableList(copy));
     47        List<List<String>> copy = value.stream()
     48                .map(Utils::toUnmodifiableList)
     49                .collect(StreamUtils.toUnmodifiableList());
     50        return new ListListSetting(copy);
    5151    }
    5252
  • trunk/src/org/openstreetmap/josm/spi/preferences/MapListSetting.java

    r14827 r16436  
    22package org.openstreetmap.josm.spi.preferences;
    33
    4 import java.util.ArrayList;
    5 import java.util.Collections;
    64import java.util.LinkedHashMap;
    75import java.util.List;
    86import java.util.Map;
    97import java.util.SortedMap;
     8
     9import org.openstreetmap.josm.tools.StreamUtils;
     10import org.openstreetmap.josm.tools.Utils;
    1011
    1112/**
     
    2829        if (value == null)
    2930            return new MapListSetting(null);
    30         List<Map<String, String>> copy = new ArrayList<>(value.size());
    31         for (Map<String, String> map : value) {
    32             Map<String, String> mapCopy = new LinkedHashMap<>(map);
    33             copy.add(Collections.unmodifiableMap(mapCopy));
    34         }
    35         return new MapListSetting(Collections.unmodifiableList(copy));
     31        List<Map<String, String>> copy = value.stream()
     32                .map(LinkedHashMap::new)
     33                .map(Utils::toUnmodifiableMap)
     34                .collect(StreamUtils.toUnmodifiableList());
     35        return new MapListSetting(copy);
    3636    }
    3737
  • trunk/src/org/openstreetmap/josm/tools/Geometry.java

    r16056 r16436  
    760760     */
    761761    public static double multipolygonArea(Relation multipolygon) {
    762         double area = 0.0;
    763762        final Multipolygon mp = MultipolygonCache.getInstance().get(multipolygon);
    764         for (Multipolygon.PolyData pd : mp.getCombinedPolygons()) {
    765             area += pd.getAreaAndPerimeter(Projections.getProjectionByCode("EPSG:54008")).getArea();
    766         }
    767         return area;
     763        return mp.getCombinedPolygons().stream()
     764                .mapToDouble(pd -> pd.getAreaAndPerimeter(Projections.getProjectionByCode("EPSG:54008")).getArea())
     765                .sum();
    768766    }
    769767
     
    10531051                    ? nodeInsidePolygon(nodes.get(0), out.nodes)
    10541052                    : PolygonIntersection.FIRST_INSIDE_SECOND == polygonIntersection(a1, out.area)) {
    1055                 boolean insideInner = false;
    10561053                // If inside an outer, check it is not inside an inner
    1057                 for (JoinedPolygon in : outerInner.b) {
    1058                     if (a1 == null ? nodeInsidePolygon(nodes.get(0), in.nodes)
    1059                             : in.area.getBounds2D().contains(a1.getBounds2D())
    1060                                     && polygonIntersection(a1, in.area) == PolygonIntersection.FIRST_INSIDE_SECOND
    1061                                     && polygonIntersection(in.area, out.area) == PolygonIntersection.FIRST_INSIDE_SECOND) {
    1062                         insideInner = true;
    1063                         break;
    1064                     }
    1065                 }
     1054                boolean insideInner = outerInner.b.stream().anyMatch(in -> a1 == null
     1055                        ? nodeInsidePolygon(nodes.get(0), in.nodes)
     1056                        : in.area.getBounds2D().contains(a1.getBounds2D())
     1057                        && polygonIntersection(a1, in.area) == PolygonIntersection.FIRST_INSIDE_SECOND
     1058                        && polygonIntersection(in.area, out.area) == PolygonIntersection.FIRST_INSIDE_SECOND);
    10661059                if (!insideInner) {
    10671060                    // Final check using predicate
     
    11841177            } else if (p.isMultipolygon()) {
    11851178                Multipolygon mp = new Multipolygon((Relation) p);
    1186                 boolean inside = true;
    11871179                // a (valid) multipolygon is inside multiPolygon if all outer rings are inside
    1188                 for (PolyData outer : mp.getOuterPolygons()) {
    1189                     if (!outer.isClosed() || !isPolygonInsideMultiPolygon(outer.getNodes(), outerInner, null)) {
    1190                         inside = false;
    1191                         break;
    1192                     }
    1193                 }
     1180                boolean inside = mp.getOuterPolygons().stream()
     1181                        .allMatch(outer -> outer.isClosed() && isPolygonInsideMultiPolygon(outer.getNodes(), outerInner, null));
    11941182                if (inside) {
    11951183                    res.add(p);
  • trunk/src/org/openstreetmap/josm/tools/ImageProvider.java

    r16318 r16436  
    5353import java.util.regex.Matcher;
    5454import java.util.regex.Pattern;
     55import java.util.stream.IntStream;
    5556import java.util.zip.ZipEntry;
    5657import java.util.zip.ZipFile;
     
    19671968
    19681969    private static Color parseRGB(String... s) {
    1969         int[] rgb = new int[3];
    19701970        try {
    1971             for (int i = 0; i < 3; i++) {
    1972                 rgb[i] = Integer.parseInt(s[i]);
    1973             }
     1971            int[] rgb = IntStream.range(0, 3).map(i -> Integer.parseInt(s[i])).toArray();
    19741972            return new Color(rgb[0], rgb[1], rgb[2]);
    19751973        } catch (IllegalArgumentException e) {
  • trunk/src/org/openstreetmap/josm/tools/ReflectionUtils.java

    r14978 r16436  
    77import java.util.Collection;
    88import java.util.function.Function;
     9import java.util.stream.IntStream;
    910
    1011import org.openstreetmap.josm.plugins.PluginHandler;
     
    6364    private static <T extends Object> T findCaller(Function<StackTraceElement, T> getter, Collection<T> exclusions) {
    6465        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
    65         for (int i = 3; i < stack.length; i++) {
    66             T t = getter.apply(stack[i]);
    67             if (exclusions == null || !exclusions.contains(t)) {
    68                 return t;
    69             }
    70         }
    71         return null;
     66        return IntStream.range(3, stack.length)
     67                .mapToObj(i -> getter.apply(stack[i]))
     68                .filter(t -> exclusions == null || !exclusions.contains(t))
     69                .findFirst().orElse(null);
    7270    }
    7371}
  • trunk/src/org/openstreetmap/josm/tools/StreamUtils.java

    r15732 r16436  
    66import java.util.StringJoiner;
    77import java.util.stream.Collector;
     8import java.util.stream.Collectors;
    89import java.util.stream.IntStream;
    910import java.util.stream.Stream;
     
    5859        );
    5960    }
     61
     62    /**
     63     * Creates a new Collector that collects the items in an unmodifiable list
     64     * @param <T> the type of the input elements
     65     * @return a new Collector that collects the items in an unmodifiable list
     66     * @see Utils#toUnmodifiableList
     67     * @since xxx
     68     */
     69    public static <T> Collector<T, ?, List<T>> toUnmodifiableList() {
     70        // Java 10: use java.util.stream.Collectors.toUnmodifiableList
     71        return Collectors.collectingAndThen(Collectors.toList(), Utils::toUnmodifiableList);
     72    }
    6073}
  • trunk/src/org/openstreetmap/josm/tools/Utils.java

    r16330 r16436  
    4848import java.util.Locale;
    4949import java.util.Map;
     50import java.util.Objects;
    5051import java.util.Optional;
    5152import java.util.concurrent.ExecutionException;
     
    156157    @SafeVarargs
    157158    public static <T> T firstNonNull(T... items) {
    158         for (T i : items) {
    159             if (i != null) {
    160                 return i;
    161             }
    162         }
    163         return null;
     159        return Arrays.stream(items).filter(Objects::nonNull)
     160                .findFirst().orElse(null);
    164161    }
    165162
     
    586583        List<T> sorted = new ArrayList<>();
    587584        for (int i = 0; i < size; ++i) {
    588             T parentless = null;
    589             for (T key : deps.keySet()) {
    590                 if (deps.get(key).isEmpty()) {
    591                     parentless = key;
    592                     break;
    593                 }
    594             }
     585            T parentless = deps.keySet().stream()
     586                    .filter(key -> deps.get(key).isEmpty())
     587                    .findFirst().orElse(null);
    595588            if (parentless == null) throw new JosmRuntimeException("parentless");
    596589            sorted.add(parentless);
     
    723716     */
    724717    public static String firstNotEmptyString(String defaultString, String... candidates) {
    725         for (String candidate : candidates) {
    726             if (!Utils.isStripEmpty(candidate)) {
    727                 return candidate;
    728             }
    729         }
    730         return defaultString;
     718        return Arrays.stream(candidates)
     719                .filter(candidate -> !Utils.isStripEmpty(candidate))
     720                .findFirst().orElse(defaultString);
    731721    }
    732722
     
    739729     */
    740730    public static boolean isStripEmpty(String str) {
    741         if (str != null) {
    742             for (int i = 0; i < str.length(); i++) {
    743                 if (!isStrippedChar(str.charAt(i), null)) {
    744                     return false;
    745                 }
    746             }
    747         }
    748         return true;
     731        return str == null || IntStream.range(0, str.length()).allMatch(i -> isStrippedChar(str.charAt(i), null));
    749732    }
    750733
  • trunk/src/org/openstreetmap/josm/tools/WikiReader.java

    r15293 r16436  
    55import java.io.IOException;
    66import java.net.URL;
     7import java.util.stream.Collectors;
    78
    89import org.openstreetmap.josm.spi.preferences.Config;
     
    103104    }
    104105
    105     private static String readNormal(BufferedReader in, boolean html) throws IOException {
    106         StringBuilder b = new StringBuilder();
    107         for (String line = in.readLine(); line != null; line = in.readLine()) {
    108             if (!line.contains("[[TranslatedPages]]")) {
    109                 b.append(line.replace(" />", ">")).append('\n');
    110             }
    111         }
    112         return html ? "<html>" + b + "</html>" : b.toString();
     106    private static String readNormal(BufferedReader in, boolean html) {
     107        String string = in.lines()
     108                .filter(line -> !line.contains("[[TranslatedPages]]"))
     109                .map(line -> line.replace(" />", ">") + '\n').collect(Collectors.joining());
     110        return html ? "<html>" + string + "</html>" : string;
    113111    }
    114112
  • trunk/src/org/openstreetmap/josm/tools/XmlUtils.java

    r16069 r16436  
    44import java.io.IOException;
    55import java.io.InputStream;
     6import java.util.stream.IntStream;
    67
    78import javax.xml.XMLConstants;
     
    171172    public static Element getFirstChildElement(Node parent) {
    172173        NodeList children = parent.getChildNodes();
    173         for (int i = 0; i < children.getLength(); i++) {
    174             Node child = children.item(i);
    175             if (child instanceof Element) {
    176                 return (Element) child;
    177             }
    178         }
    179         return null;
     174        return (Element) IntStream.range(0, children.getLength())
     175                .mapToObj(children::item)
     176                .filter(child -> child instanceof Element)
     177                .findFirst().orElse(null);
    180178    }
    181179}
  • trunk/src/org/openstreetmap/josm/tools/template_engine/CompoundTemplateEntry.java

    r14098 r16436  
    33
    44import java.util.Arrays;
     5import java.util.stream.Collectors;
    56
    67/**
     
    4142    @Override
    4243    public boolean isValid(TemplateEngineDataProvider dataProvider) {
    43         for (TemplateEntry te: entries) {
    44             if (!te.isValid(dataProvider))
    45                 return false;
    46         }
    47         return true;
     44        return Arrays.stream(entries).allMatch(te -> te.isValid(dataProvider));
    4845    }
    4946
    5047    @Override
    5148    public String toString() {
    52         StringBuilder result = new StringBuilder();
    53         for (TemplateEntry te: entries) {
    54             result.append(te);
    55         }
    56         return result.toString();
     49        return Arrays.stream(entries).map(String::valueOf).collect(Collectors.joining());
    5750    }
    5851
  • trunk/src/org/openstreetmap/josm/tools/template_engine/Condition.java

    r14093 r16436  
    4646    @Override
    4747    public boolean isValid(TemplateEngineDataProvider dataProvider) {
    48 
    49         for (TemplateEntry entry: entries) {
    50             if (entry.isValid(dataProvider))
    51                 return true;
    52         }
    53 
    54         return false;
     48        return entries.stream().anyMatch(entry -> entry.isValid(dataProvider));
    5549    }
    5650
  • trunk/src/org/openstreetmap/josm/tools/template_engine/ContextSwitchTemplate.java

    r14093 r16436  
    88import java.util.Collections;
    99import java.util.List;
     10import java.util.stream.Collectors;
     11import java.util.stream.Stream;
    1012
    1113import org.openstreetmap.josm.data.osm.Node;
     
    9496            }
    9597
    96             List<OsmPrimitive> result = new ArrayList<>();
    97             for (OsmPrimitive child: children) {
    98                 for (OsmPrimitive parent: child.getReferrers(true)) {
    99                     if (condition == null || condition.match(parent)) {
    100                         result.add(parent);
    101                     }
    102                 }
    103             }
    104             return result;
     98            return children.stream()
     99                    .flatMap(child -> child.getReferrers(true).stream())
     100                    .filter(parent -> condition == null || condition.match(parent))
     101                    .collect(Collectors.toList());
    105102        }
    106103
     
    205202        @Override
    206203        List<OsmPrimitive> getPrimitives(OsmPrimitive root) {
    207             List<OsmPrimitive> result = new ArrayList<>();
    208             for (OsmPrimitive o: lhs.getPrimitives(root)) {
    209                 if (condition == null || condition.match(o)) {
    210                     result.add(o);
    211                 }
    212             }
    213             for (OsmPrimitive o: rhs.getPrimitives(root)) {
    214                 if (condition == null || (condition.match(o) && !result.contains(o))) {
    215                     result.add(o);
    216                 }
    217             }
    218             return result;
     204            return Stream.concat(lhs.getPrimitives(root).stream(), rhs.getPrimitives(root).stream())
     205                    .filter(o -> condition == null || condition.match(o))
     206                    .distinct()
     207                    .collect(Collectors.toList());
    219208        }
    220209
     
    265254        @Override
    266255        List<OsmPrimitive> getPrimitives(OsmPrimitive root) {
    267             List<OsmPrimitive> result = new ArrayList<>();
    268256            List<OsmPrimitive> lhsList = lhs.getPrimitives(root);
    269             for (OsmPrimitive o: rhs.getPrimitives(root)) {
    270                 if (lhsList.contains(o) && (condition == null || condition.match(o))) {
    271                     result.add(o);
    272                 }
    273             }
    274             return result;
     257            return rhs.getPrimitives(root).stream()
     258                    .filter(lhsList::contains)
     259                    .filter(o -> condition == null || condition.match(o))
     260                    .collect(Collectors.toList());
    275261        }
    276262
  • trunk/test/unit/org/openstreetmap/josm/data/osm/ChangesetTest.java

    r13813 r16436  
    1313import java.util.HashMap;
    1414import java.util.Map;
     15import java.util.stream.Collectors;
     16import java.util.stream.IntStream;
    1517
    1618import org.junit.Assert;
     
    6567        // Add a map with too long values => IllegalArgumentException
    6668        keys = new HashMap<>();
    67         StringBuilder b = new StringBuilder(MAX_CHANGESET_TAG_LENGTH + 1);
    68         for (int i = 0; i < MAX_CHANGESET_TAG_LENGTH + 1; i++) {
    69            b.append("x");
    70         }
    71         keys.put("test", b.toString());
     69        // Java 11: use String.repeat
     70        keys.put("test", IntStream.range(0, MAX_CHANGESET_TAG_LENGTH + 1).mapToObj(i -> "x").collect(Collectors.joining()));
    7271        try {
    7372            cs.setKeys(keys);
  • trunk/test/unit/org/openstreetmap/josm/data/projection/ProjectionRegressionTest.java

    r16099 r16436  
    1313import java.util.ArrayList;
    1414import java.util.HashMap;
    15 import java.util.HashSet;
    1615import java.util.List;
    1716import java.util.Map;
     
    1918import java.util.Set;
    2019import java.util.TreeSet;
     20import java.util.stream.Collectors;
    2121
    2222import org.junit.BeforeClass;
     
    160160    public void testNonRegression() throws IOException {
    161161        List<TestData> allData = readData();
    162         Set<String> dataCodes = new HashSet<>();
    163         for (TestData data : allData) {
    164             dataCodes.add(data.code);
    165         }
     162        Set<String> dataCodes = allData.stream().map(data -> data.code).collect(Collectors.toSet());
    166163
    167164        StringBuilder fail = new StringBuilder();
  • trunk/test/unit/org/openstreetmap/josm/io/GeoJSONReaderTest.java

    r16311 r16436  
    1515import java.util.List;
    1616import java.util.Optional;
     17import java.util.stream.IntStream;
    1718
    1819import org.junit.Rule;
     
    160161            return false;
    161162        }
    162         for (int i = 0; i < ((Way) p1).getNodes().size(); i++) {
    163             if (!areEqualNodes(((Way) p1).getNode(i), ((Way) p2).getNode(i))) {
    164                 return false;
    165             }
    166         }
    167         return true;
     163        return IntStream.range(0, ((Way) p1).getNodes().size())
     164                .allMatch(i -> areEqualNodes(((Way) p1).getNode(i), ((Way) p2).getNode(i)));
    168165    }
    169166}
  • trunk/test/unit/org/openstreetmap/josm/io/remotecontrol/RemoteControlTest.java

    r15469 r16436  
    1313import java.security.GeneralSecurityException;
    1414import java.security.KeyStore.TrustedCertificateEntry;
     15import java.util.stream.Collectors;
    1516
    1617import org.junit.After;
     
    8889        try (InputStream is = connection.getErrorStream()) {
    8990            // TODO this code should be refactored somewhere in Utils as it is used in several JOSM classes
    90             StringBuilder responseBody = new StringBuilder();
     91            String responseBody;
    9192            try (BufferedReader in = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
    92                 String s;
    93                 while ((s = in.readLine()) != null) {
    94                     responseBody.append(s);
    95                     responseBody.append("\n");
    96                 }
     93                responseBody = in.lines().collect(Collectors.joining("\n"));
    9794            }
    98             assert responseBody.toString().contains(RequestProcessor.getUsageAsHtml());
     95            assert responseBody.contains(RequestProcessor.getUsageAsHtml());
    9996        }
    10097    }
Note: See TracChangeset for help on using the changeset viewer.