Derzeit habe ich eine Methode, die die folgende Methode überlädt:

    public boolean isHorizontalOrVertical(Point firstPoint, Point secondPoint) {
        return firstPoint.getFirstComponent() == secondPoint.getFirstComponent()
                || firstPoint.getSecondComponent() == secondPoint.getSecondComponent();
    }

    public boolean isHorizontalOrVertical(List<Point> points) {
        if (points == null || points.size() < 2) {
            throw new IllegalArgumentException("invalid number of points");
        }
        Point start = points.get(0);
        return points.stream()
                .allMatch(p -> isHorizontalOrVertical(start, p));
    }

Die Methode wird benötigt, um zu überprüfen, ob zwei oder drei Punkte vertikal / horizontal zueinander sind . Bei drei Punkten muss lediglich geprüft werden, ob die beiden letzten Punkte horizontal / vertikal zum Startpunkt liegen.

Hat jemand eine Idee, wie ich alles in nur einer Methode zusammenfassen kann?

1
user12881831 22 Feb. 2020 im 14:37

4 Antworten

Beste Antwort

Sie können nur eine Methode wie folgt verwenden:

public boolean isHorizontalOrVertical(List<Point> points) {
    if (points == null || points.size() < 2) {
        throw new IllegalArgumentException("invalid number of points");
    }
    if (points.size() == 2) {
       return points.get(0).getFirstComponent() == points.get(1).getFirstComponent()
                || points.get(0).getSecondComponent() == points.get(1).getSecondComponent();
    } 
    Point start = points.get(0);
    return points.stream()
                .allMatch(p -> isHorizontalOrVertical(List.of(start, p)));
}

Hinweis: Wenn Sie keine Java-Version> = 9 verwenden, verwenden Sie bitte Arrays.asList anstelle von List.of.

1
Arvind Kumar Avinash 22 Feb. 2020 im 12:45

Die Methode könnte folgendermaßen implementiert werden:

public boolean isHorizontalOrVertical(Point firstPoint, Point secondPoint, Point thirdPoint) {
    return isHorizontalOrVertical(Arrays.asList(firstPoint, secondPoint, thirdPoint));
}

Ihre isHorizontalOrVertical(List<Point>) -Methode schlägt fehl, wenn die Liste leer ist, und der Aufruf macht wenig Sinn, wenn die Liste nur ein Element enthält.

Ich denke, ein besserer Weg, dies zu tun, ist mit zwei erforderlichen Parametern plus einem variadischen Parameter, so dass Anrufer mindestens 2 Punkte geben müssen.

private boolean are2PointsHorizontalOrVertical(Point firstPoint, Point secondPoint) {
    return firstPoint.getFirstComponent() == secondPoint.getFirstComponent()
            || firstPoint.getSecondComponent() == secondPoint.getSecondComponent();
}

public boolean arePointsHorizontalOrVertical(Point point1, Point point2, Point... rest) {
    return are2PointsHorizontalOrVertical(point1, point2) &&
        Arrays.stream(rest).allMatch(x -> are2PointsHorizontalOrVertical(point1, x));
}

Dies ist technisch gesehen immer noch "eine Methode", was die öffentliche Schnittstelle betrifft. Sie können den Helfer are2PointsHorizontalOrVertical wieder in die öffentliche Methode einsetzen, wenn Sie wirklich möchten, aber ich sehe keinen Vorteil darin.

0
Sweeper 22 Feb. 2020 im 12:25

Zuallererst muss ich die Tatsache beachten, dass es zumindest für mich keinen Sinn macht, eine Methode zu berechnen, die berechnet, ob zwei Entitäten horizontal oder vertikal und diese Entitäten Punkte . Wie können zwei Punkte horizontal oder vertikal sein?


IsHorizontalOrVertical ist ein schlechter Name

Um dies zu überwinden, können Sie eine einzelne Methode erstellen, die berechnet, ob zwei Punkte horizontal oder vertikal sind.

Ändern Sie den Namen isHorizontalOrVertical , da er redundant ist. Ein besserer Name ist isHorizontal oder isVertical . Die Methode gibt einen Booleschen Wert zurück. Wenn isHorizontal false zurückgibt, ist dies vertikal und umgekehrt. Wahrscheinlich könnte ein besserer Name areTwoPointsHorizontal sein, aber ich habe Probleme, das überhaupt zu schreiben, weil es die falsche Nachricht überträgt, aber Sie können gerne Ihre eigene wählen.

Also die Methode,

    public boolean isHorizontal(Point first, Point second){
        boolean sameFirstComponents = firstPoint.getFirstComponent() == 
                secondPoint.getFirstComponent();
        boolean sameSecondComponents = firstPoint.getSecondComponent() == 
                secondPoint.getSecondComponent();          
        return sameFirstComponents || sameSecondComponents;
    }

Erstellen Sie schließlich eine Methode, die berechnet, ob eine beliebige Anzahl von Punkten in einer Liste alle horizontal oder vertikal zwischen ihnen liegen (vorausgesetzt, wenn Punkt A horizontal mit Punkt B ist, dann ist Punkt C horizontal mit B, ebenso wie mit A. ).

Überladen Sie diese Methode, da sie dasselbe tut und sich nur die Parameter ändern. (Beachten Sie, dass die einfache is Horizontal -Methode von oben verwendet wird.)

   public boolean isHorizontal(List<Point> points){
        boolean allPointsHorizontal = true;
        for (int i=0; i<points.size(); i++) {

            boolean nextPointExists = i<points.size() - 1;
            if (nextPointExists) {
                Point current = points.get(i);
                Point next = points.get(i+1);
                allPointsHorizontal = allPointsHorizontal && isHorizontal(current,next);

                if (!allPointsHorizontal)
                    return false;  
            }
        }

        return allPointsHorizontal;
    }
1
Themelis 22 Feb. 2020 im 13:08

Eigentlich können Sie nur eine Methode haben:

public boolean isHorizontalOrVertical(Point firstPoint, Point secondPoint, Point... others) {
    // check firstPoint, secondPoint for null is ommited
    if (others == null || others.length == 0) {
        return firstPoint.getFirstComponent() == secondPoint.getFirstComponent()
                || firstPoint.getSecondComponent() == secondPoint.getSecondComponent();
    } else {
        // First, create a stream with second point + others elements
        // then match against the first point
        return Stream.of(new Point[]{secondPoint}, others).flatMap(e -> Stream.of(e))
                .allMatch(p -> isHorizontalOrVertical(firstPoint, p));
    }

}
1
Eugen Covaci 22 Feb. 2020 im 13:00