How to limit number of elements in a stream responsively?Java8 - java-8

Question

The problem I am having is turning this block of code into Java8 streams.Basically I have a list of cells that are either dead(false) or alive(true) and I need to check how many neighbours are alive for a given cell.
private static int checkMyLivingNeighbours(Cell cell,List<Cell> currentcells){
int neighbours = 0;
for (int y = cell.getY() - 1; y <= cell.getY() + 1; y++) {
for (int x = cell.getX() - 1; x <= cell.getX() + 1; x++) {
if(x!=cell.getX() || y!=cell.getY()){
for (Cell nowcell : currentcells) {
if (nowcell.getX() == x && nowcell.getY() == y) {
if (nowcell.getStatus()) {
neighbours++;
}
}
}
}
}
}
return neighbours;
}
I have tried something like this
private static void checkaliveneighbours(Cell cell,List<Cell> generation){
generation.stream().forEach(n->IntStream.range(cell.getY()-1,cell.getY()+1).
forEach(y -> IntStream.range(cell.getX()-1,cell.getX()+1)
.forEach(x->{if(n.getX()==x && n.getY()==y && n.getStatus())System.out.println(n.getDisplaychar());})));;//
}
where I am calling it like such
checkaliveneighbours(generation.get(0),generation);
SO I do get a print for the alive CELL but I actually need the total nr of alive CELLS surrounding the CELL being passed in and not just a print if the cell passed in is alive or not. Therefor the question how to limit number of elements in a stream(just the surrounding cells) responsively(based on the individual cell being passed in).
Here is the cell class
public class Cell {
private int x;
private int y;
private boolean alive;
public Cell(){}
public Cell(String x, String y, boolean alive ) {
this.x = Integer.valueOf(x);
this.y = Integer.valueOf(y);
this.alive = alive;
}
public int getX() {
return x;
}
public void setX(String x) {
this.x = Integer.valueOf(x);
}
public int getY() {
return y;
}
public void setY(String y) {
this.y = Integer.valueOf(y);
}
public boolean getStatus() {
return alive;
}
public void setStatus(boolean status) {
this.alive = status;
}
public char getDisplaychar() {
if(getStatus())
return 'X';
else
return '.';
}
}

Answer 1

If I understand correctly, by "limiting" you mean using Stream.filter() to filter only neighbors. Then you want to sum all living neighbors. I'd begin by defining a method that will return whether a specified cell is a neighboring cell or not:
private static boolean isNeighbor(final Cell cell, final Cell candidate) {
for (int y = cell.getY() - 1; y <= cell.getY() + 1; y++) {
for (int x = cell.getX() - 1; x <= cell.getX() + 1; x++) {
if (x != cell.getX() || y != cell.getY()) {
if (candidate.getX() == x && candidate.getY() == y) {
return true;
}
}
}
}
return false;
}
Then you can easily filter your list and compute the sum like so:
int sum = generation.stream()
.filter(c -> isNeighbor(cell, c))
.mapToInt(c -> c.getStatus() ? 1 : 0)
.sum();
Edit: If you're looking for a pure Java 8 solution for isNeighbor:
private boolean isNeighbor(final Cell cell, final Cell candidate) {
return IntStream.rangeClosed(cell.getX() - 1, cell.getX() + 1)
.anyMatch(x -> IntStream.rangeClosed(cell.getY() - 1, cell.getY() + 1)
.anyMatch(y -> (x != cell.getX() || y != cell.getY()) &&
x == candidate.getX() && y == candidate.getY()));
}