如何浏览数组，检查它们之间的所有元素，以及它们是否符合条件显示它们？

Question

好吧，问题很简单，但我不知道怎么做。我试着逐个检查两个元素，但这不是最好的方法。我有一组圆形物体。数组有位置字段X和Y。我想遍历数组，检查所有元素是否在一条线上（水平或垂直）。我如何通过数组检查圆心是否在同一条线上。

我试着做这样的事情，看看圆圈是否在同一条垂直线上，但我说它需要一个元素与邻居。

void isCenterSameHorizOrVert(Circle[] c) {
    for(int i = 0; i < c.length; i++) {
        for(int j = i + 1; j < c.length - 1; j++) {
            if(c[i].getPlanarX() == c[j].getPlanarX()) {

            }
        }
    }
}

Answer 1

以下是我的方法：

package amedv;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.junit.Test;

class Circle {
    int positionX;
    int positionY;

    public Circle(int positionX, int positionY) {
        super();
        this.positionX = positionX;
        this.positionY = positionY;
    }
    public int getPositionX() {
        return positionX;
    }
    public void setPositionX(int positionX) {
        this.positionX = positionX;
    }
    public int getPositionY() {
        return positionY;
    }
    public void setPositionY(int positionY) {
        this.positionY = positionY;
    }
}

class CircleHM {
    HashMap hmCirlesX;
    HashMap hmCirlesY;

    public HashMap getHmCirlesX() {
        return hmCirlesX;
    }
    public void setHmCirlesX(HashMap hmCirlesX) {
        this.hmCirlesX = hmCirlesX;
    }
    public HashMap getHmCirlesY() {
        return hmCirlesY;
    }
    public void setHmCirlesY(HashMap hmCirlesY) {
        this.hmCirlesY = hmCirlesY;
    }

}

public class CircleTest {

    private Circle[] circles = new Circle[] {new Circle(1,2), new Circle(1,5), new Circle(6,7), new Circle(2,7), new Circle(3,8), new Circle(3,5)};

    private HashMap<Integer, HashMap<Integer, ArrayList<Integer>>> hmCirlesX = new HashMap<Integer, HashMap<Integer, ArrayList<Integer>>>();
    private HashMap<Integer, HashMap<Integer, ArrayList<Integer>>> hmCirlesY = new HashMap<Integer, HashMap<Integer, ArrayList<Integer>>>();

    private boolean findCircleWithCenterSameHorizOrVert(Circle[] cirArr) {
        if (cirArr.length == 0) {
            return false;
        }

        int hashCode = cirArr.hashCode();

        if (!hmCirlesX.containsKey(hashCode) && !hmCirlesY.containsKey(hashCode)) {
            hmCirlesX.put(hashCode, new HashMap<Integer, ArrayList<Integer>>());
            hmCirlesY.put(hashCode, new HashMap<Integer, ArrayList<Integer>>());
        for (int i=0; i<circles.length; i++) {      
            ArrayList arrlCirclesX = hmCirlesX.get(hashCode).containsKey(circles[i].positionX) ? hmCirlesX.get(hashCode).get(circles[i].positionX) : new ArrayList();
            arrlCirclesX.add(circles[i]);
            hmCirlesX.get(hashCode).put(circles[i].positionX, arrlCirclesX);

            ArrayList arrlCirclesY = hmCirlesY.get(hashCode).containsKey(circles[i].positionY) ? hmCirlesY.get(hashCode).get(circles[i].positionY) : new ArrayList();
            arrlCirclesY.add(circles[i]);
            hmCirlesY.get(hashCode).put(circles[i].positionY, arrlCirclesY);
        }
        }

        return (hmCirlesX.size() > 0 && hmCirlesY.size() > 0);      
    }

    private void showCenterSameHorizOrVert(Circle[] cirArr) {
        if (findCircleWithCenterSameHorizOrVert(cirArr)) {
            int hashCode = cirArr.hashCode();

            HashMap<Integer, ArrayList<Integer>> hmX = hmCirlesX.get(hashCode);
            HashMap<Integer, ArrayList<Integer>> hmY = hmCirlesY.get(hashCode);

            Iterator itmX = hmX.entrySet().iterator();
        while (itmX.hasNext()) {
            Map.Entry hmArrListX = (Map.Entry)itmX.next();
            ArrayList cirX = (ArrayList) hmArrListX.getValue();
            System.out.println("Circles on the same X = " + hmArrListX.getKey());
            for (int i=0; i < cirX.size(); i++) {
                Circle c = (Circle) cirX.get(i);
              System.out.println("c.positionX = " + c.positionX + " c.positionY = " + c.positionY);         
            }
            System.out.println("");
        }

        System.out.println("");
        System.out.println("");

        Iterator itmY = hmY.entrySet().iterator();
        while (itmY.hasNext()) {
            Map.Entry hmArrListY = (Map.Entry)itmY.next();
            ArrayList cirY = (ArrayList) hmArrListY.getValue();
            System.out.println("Circles on the same Y = " + hmArrListY.getKey());
            for (int i=0; i < cirY.size(); i++) {
                Circle c = (Circle) cirY.get(i);
              System.out.println("c.positionX = " + c.positionX + " c.positionY = " + c.positionY);         
            }
            System.out.println("");
        }

        }
    }

    @Test
    public void test() {
        System.out.println("circles.length = " + circles.length);
        System.out.println("");
        showCenterSameHorizOrVert(circles);
    }

}

它会给我一个结果：

circles.length = 6

Circles on the same X = 1
c.positionX = 1 c.positionY = 2
c.positionX = 1 c.positionY = 5

Circles on the same X = 2
c.positionX = 2 c.positionY = 7

Circles on the same X = 3
c.positionX = 3 c.positionY = 8
c.positionX = 3 c.positionY = 5

Circles on the same X = 6
c.positionX = 6 c.positionY = 7



Circles on the same Y = 2
c.positionX = 1 c.positionY = 2

Circles on the same Y = 5
c.positionX = 1 c.positionY = 5
c.positionX = 3 c.positionY = 5

Circles on the same Y = 7
c.positionX = 6 c.positionY = 7
c.positionX = 2 c.positionY = 7

Circles on the same Y = 8
c.positionX = 3 c.positionY = 8

我使用X和Y的整数来简化打印输出，请告诉我您需要将其替换为双精度。我将结果存储在基于数组哈希码的HashMap中，以避免每次运行此函数时循环整个数组，并在其中循环整个数组仅一次，并根据X和Y坐标将所有值放入两个HashMaps中（它根据此键对所有值进行分组），然后我只是循环生成具有分组值的HashMaps，以显示基于X或Y的同一行中的哪些对象。希望我的逻辑能帮助您根据需要调整它。