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

see #19251 - Java 8: use Stream

Location:
trunk/src/org/openstreetmap/josm/gui
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • 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);
Note: See TracChangeset for help on using the changeset viewer.