Plus Finder

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

    /*
     * Complete the 'twoPluses' function below.
     *
     * The function is expected to return an INTEGER.
     * The function accepts STRING_ARRAY grid as parameter.
     */

    public static int twoPluses(List<String> grid) {
    // Write your code here
    char[][] cGrid = cGrid(grid);

    ArrayList<Plus> plusses = new ArrayList<>();

    for (int i = 0; i < cGrid.length; i++){
        for (int j = 0; j < cGrid[i].length; j++){
            if (isGood(cGrid[i][j])){
                Point point = new Point(i, j);
                Plus plus = new Plus();
                plus.add(point);
                plus.increase(1);
                plusses.add(plus);
                int top = i;
                int bottom = i;
                int right = j;
                int left = j;
                while (true){
                    top--;
                    bottom++;
                    right++;
                    left--;
                    try {
                        if (isGood(cGrid[top][j]) &&
                        isGood(cGrid[bottom][j]) &&
                        isGood(cGrid[i][right]) &&
                        isGood(cGrid[i][left])){
                            plus.add(new Point(top, j), new Point(bottom, j), new Point(i, right), new Point(i, left));
                            plus.increase(4);
                            plusses.add(new Plus(plus));
                        } else {
                            break;
                        }
                    } catch (ArrayIndexOutOfBoundsException e) {
                        break;
                    }
                }

            }
        }
    }
    //test
    /*for (Plus plus : plusses){
        System.out.println(plus);
    }*/

    SizeComparator sizeComparator = new SizeComparator();
    Collections.sort(plusses, sizeComparator);

    //test
    /*for (Plus plus : plusses){
        System.out.println(plus.size);
    }*/
    for (int i = plusses.size()-5; i > plusses.size()-8; i--){
        //System.out.println(plusses.get(i));

        for (int j = i-1; j >= plusses.size()-8; j--){
            System.out.println(plusses.get(i).overlap(plusses.get(j)));
        }
    }
    for (Plus p : plusses) {
        if (p.size == 9){
            System.out.println(p);
        }
    }

    int largestArea = 0;

    for (int i = plusses.size()-1; i > 0; i--){
        for (int j = i-1; j >=0; j--){
            if (plusses.get(i).overlap(plusses.get(j))) {
                continue;
            }

            int area = plusses.get(i).size * plusses.get(j).size;
            if (area > largestArea) {
            largestArea = area;
            }
        }
    }

    //test
    /*for (Plus plus : plusses){
        System.out.println(plus);
    }*/

    return largestArea;

    }

    public static char[][] cGrid(List<String> grid){
        char[][] cGrid = new char[grid.size()][grid.get(0).length()];
        for (int i = 0; i < cGrid.length; i++){
            cGrid[i] = grid.get(i).toCharArray();
        }
        return cGrid;
    }

    public static boolean isGood(char c){
        return c == 'G';
    }


    static class SizeComparator implements Comparator<Plus>{
        @Override
        public int compare(Plus first, Plus second){
            return Integer.compare(first.size, second.size);
        }
    }

    public static boolean overlap(int[] first, int[] second){
        return (first[1] >= second[2] || first[2] <= second[1] || first[3] >= second[4] || first[4] <= second[3]);
    }

    public static int area(ArrayList<Plus> plusses){
        try {
            return plusses.get(plusses.size()-1).size * plusses.get(plusses.size()-2).size;
        } catch (ArrayIndexOutOfBoundsException e) {
            return -1;
        }
    }

    static class Point{
        public int y;
        public int x;

        public Point(int y, int x){
            this.y = y;
            this.x = x;
        }

        @Override
        public boolean equals(Object object){
            Point other = (Point) object;
            return (this.y == other.y && this.x == other.x);
        }

        public String toString(){
            return y + " " + x;
        }
    }

    static class Plus{
        int size = 0;
        ArrayList<Point> points = new ArrayList<>();

        public Plus(){}

        public Plus(Plus plus){
            size = plus.size;
            for (Point p : plus.points){
                points.add(p);
            }
        }

        public void increase(int size){
            this.size += size;
        }

        public void add(Point...points){
            for (Point point : points)
                this.points.add(point);
        }

        public boolean overlap(Plus other){
            return (!Collections.disjoint(points, other.points));
        }

        public String points(){
            String s = "";
            for (Point point : points){
                s = s + point +"\n";
            }
            return s;
        }

        public String toString(){
            return "Size: " + size + "\n Points: " + points();
        }
    }

}