如何在Java 8中应用reduce / collect过滤器，有一个单独的索引？

Question

I'm trying to figure out a way to reduce my data by removing duplicate points that have already been display on the screen.

Here's my code in Java 7

public List<Integer> getFilterIndexes(List<PlotPoint> pixels) {
  List<Integer> indexResults = new ArrayList<Integer>(pixels.size());
  HashSet<Integer> magList = new HashSet<Integer>(pixels.size());
  int pixelStartIndex = 0;

  for (int i=1; i < pixels.size(); i++) {
    if (pixels.get(i).getX() - pixels.get(pixelStartIndex).getX() < widthInterval) {
       int pixelRow = (int) ((pixels.get(i).getY() - minHeight / heightInterval);
       if (!magList.add(pixelRow) {
         continue;
       }
     } else {
       pixelStartIndex = i;
       magList.clear();
     }

     indexResult.add(i);
   }
 }

Is it possible to implement this in Java 8? I've thought about using a Function for the pixelRow to mapToInt(index, pixelRow);

Function<PlotPoint, Integer> pixelRow = (n)->(int) (n.getY()-minHeight/heightInterval);

but didn't understand how to implement a reduce or collect using the current pixel or plotPoint and the previously saved plotPoint.

Any ideas?

Answer 1

Here is your current implementation (with some assumptions)

public class LegacyPixelsContainer {
    private final int widthInterval = 10;
    private final int minHeight = 10;
    private final int heightInterval = 10;
    private final List<PlotPoint> pixels;

    public LegacyPixelsContainer(List<PlotPoint> pixels) {
        this.pixels = Collections.unmodifiableList(pixels);
    }

    public List<Integer> getFilteredIndexes() {
        List<Integer> indexResults = new ArrayList<>(pixels.size());
        HashSet<Integer> magList = new HashSet<>();
        int pixelStartIndex = 0;

        for (int i = 1; i < pixels.size(); i++) {
            if (getPixelAt(i).getX() - getPixelAt(pixelStartIndex).getX() < widthInterval) {
                int pixelRow = getPixelAt(i).getY() - minHeight / heightInterval;

                if (!magList.add(pixelRow)) {
                    continue;
                }
            } else {
                pixelStartIndex = i;
                magList.clear();
            }

            indexResults.add(i);
        }

        return indexResults;
    }

    private PlotPoint getPixelAt(int i) {
        return pixels.get(i);
    }
}

For Java 8 implementation, I changed the returned type to IntStream, so the caller will also get the benefit of streaming instead of pre-loaded List . The caller can still collect the integers as list, if needed, by calling Collectors.toList on the returned stream.

Here is the Java 8 implementation

public class PixelsContainer {
    private final int widthInterval = 10;
    private final int minHeight = 10;
    private final int heightInterval = 10;
    private final List<PlotPoint> pixels;

    public PixelsContainer(List<PlotPoint> pixels) {
        this.pixels = Collections.unmodifiableList(pixels);
    }

    public IntStream getFilteredIndexes() {
        Set<Integer> magList = new HashSet<>();
        AtomicInteger pixelStartIndex = new AtomicInteger(0);

        return IntStream.range(1, pixels.size())
                .mapToObj(i -> processIndex(i, magList, pixelStartIndex))
                .filter(OptionalInt::isPresent)
                .mapToInt(OptionalInt::getAsInt);
    }

    private OptionalInt processIndex(int i, Set<Integer> magList, AtomicInteger pixelStartIndexContainer) {
        int pixelStartIndex = pixelStartIndexContainer.get();

        if (getPixelAt(i).getX() - getPixelAt(pixelStartIndex).getX() < widthInterval) {
            int pixelRow = getPixelAt(i).getY() - minHeight / heightInterval;

            if (!magList.add(pixelRow)) {
                return OptionalInt.empty();
            }
        } else {
            pixelStartIndexContainer.set(i);
            magList.clear();
        }

        return OptionalInt.of(i);
    }

    private PlotPoint getPixelAt(int i) {
        return pixels.get(i);
    }
}