Java 如何比较集合中的点对象？

我在做一个练习，我将这些点（x，y）存储在一个集合中，并将这些集合存储在一个HashMap中，点的类型作为键

HashMap.

现在我要做的是比较集合中的点，找到3个或更多垂直或水平对齐的点，并且彼此相邻。如果点A（2,3），点B（2,4）和点C（2,5）满足这个条件。我想把这些通过测试的要点放在另一个列表中。有什么办法吗？谢谢你的帮助

Stephen建议使用嵌套循环

for(Map.Entry<String,ArrayList<Point>> e : grid.entrySet()){
   if (e.getValue().size() > 3){
   for(Point p1 : e.getValue()){
      for(Point p2 : e.getValue()){
         if (neighborCheck(p1,p2) == true){
            System.out.println(p1 + " " + p2);
         }
      }
   }
}

public boolean neighborCheck (Point p1, Point p2){
        boolean neighbor = false;
        if((p1.getX()==p2.getX()+1 && p1.getY()==p2.getY()) || 
           (p1.getX()==p2.getX()-1 && p1.getY()==p2.getY()) ||
           (p1.getX()==p2.getX() && p1.getY()==p2.getY()+1) ||
           (p1.getX()==p2.getX() && p1.getY()==p2.getY()-1)) {
            neighbor = true;
        }
        return neighbor;
    }

for（Map.Entry e:grid.entrySet（））{
如果（如getValue（）.size（）>3）{
对于（点p1:e.getValue（））{
对于（点p2:e.getValue（））{
如果（相邻检查（p1，p2）=真）{
系统输出打印项次（p1+“”+p2）；
}
}
}
}
公共布尔邻域检查（点p1、点p2）{
布尔邻居=假；
如果（（p1.getX（）==p2.getX（）+1&&p1.getY（）==p2.getY（））|
（p1.getX（）==p2.getX（）-1&&p1.getY（）==p2.getY（））||
（p1.getX（）==p2.getX（）&&p1.getY（）==p2.getY（）+1）||
（p1.getX（）==p2.getX（）&&p1.getY（）==p2.getY（）-1））{
邻居=真；
}
返回邻居；
}

产出：

java.awt.Point[x=3，y=4]java.awt.Point[x=4，y=4] java.awt.Point[x=4，y=4]java.awt.Point[x=3，y=4] java.awt.Point[x=0，y=4]java.awt.Point[x=1，y=4] java.awt.Point[x=1，y=4]java.awt.Point[x=0，y=4] java.awt.Point[x=3，y=2]java.awt.Point[x=4，y=2] java.awt.Point[x=4，y=1]java.awt.Point[x=4，y=2] java.awt.Point[x=4，y=2]java.awt.Point[x=3，y=2] java.awt.Point[x=4，y=2]java.awt.Point[x=4，y=1]

---

它适用于2个点，但这肯定不是解决方案，因为要检查3个点，我需要嵌套3个循环等等。我不能继续嵌套更多的循环，因为我不知道这些点将如何对齐，我需要比较3个或更多，还有其他想法吗？

在hashmap中迭代。取一个集合，比较其值（x，y）通过为hashmap创建另一个迭代器来使用其他集合。如果您的条件满足，只需将其存储在另一个列表中。

这可以通过以下方式完成：

    Map<String, Set<Point>> mapSets = new HashMap<String, Set<Point>>();
    Set<Point> p1 = new HashSet<Point>();
    p1.add(new Point(2, 3));
    p1.add(new Point(2, 4));
    p1.add(new Point(2, 5));
    p1.add(new Point(3, 1));
    p1.add(new Point(4, 1));
    p1.add(new Point(5, 1));

    mapSets.put("p1", p1);

    Map<Double, List<Point>> horMap = new HashMap<Double, List<Point>>();
    Map<Double, List<Point>> verMap = new HashMap<Double, List<Point>>();

    for ( Point p : p1 )
    {
      List<Point> presList = horMap.get(p.getX());
      if ( presList == null )
      {
        presList = new ArrayList<Point>();
        presList.add(p);
      }
      else
      {
        presList.add(p);
      }
      horMap.put(p.getX(), presList);
    }

    for ( Point p : p1 )
    {
      List<Point> presList = verMap.get(p.getY());
      if ( presList == null )
      {
        presList = new ArrayList<Point>();
        presList.add(p);
      }
      else
      {
        presList.add(p);
      }
      verMap.put(p.getY(), presList);
    }

    // boolean hNe = checkHorNeighbor(horMap);
    // boolean vNe = checkVerNeighbor(verMap);

    for ( Entry<Double, List<Point>> point : horMap.entrySet() )
    {
      if ( point.getValue().size() >= 3 )
      {
        Collections.sort(point.getValue(), new Comparator<Point>()
        {
          @Override
          public int compare(Point o1, Point o2)
          {
            return Double.valueOf(o1.getY()).compareTo(Double.valueOf(o2.getY()));
          }
        });

        int count = 0;
        for ( int i = 0; i < point.getValue().size(); i++ )
        {
          if ( point.getValue().get(i).getY() + 1 == point.getValue().get(i +
                                                                          1).getY() )
          {
            count++;
          }
          if ( count >= 2 )
          {
            System.out.println("Found horizontal pair");
            count = 0;
            break;
          }
        }

      }
    }
  }

Map-mapSets=newhashmap（）；
Set p1=新的HashSet（）；
p1.增加（新的第（2，3）点）；
p1.增加（新的第（2，4）点）；
p1.增加（新的第（2，5）点）；
p1.增加（新的第（3，1）点）；
p1.增加（新的第（4，1）点）；
p1.增加（新的第（5，1）点）；
地图集。放置（“p1”，p1）；
Map horMap=newhashmap（）；
Map verMap=newhashmap（）；
对于（点p:p1）
{
List-presList=horMap.get（p.getX（））；
if（presList==null）
{
presList=newarraylist（）；
增加（p）；
}
其他的
{
增加（p）；
}
horMap.put（p.getX（），presList）；
}
对于（点p:p1）
{
List-presList=verMap.get（p.getY（））；
if（presList==null）
{
presList=newarraylist（）；
增加（p）；
}
其他的
{
增加（p）；
}
put（p.getY（），presList）；
}
//布尔hNe=checkHorNeighbor（horMap）；
//布尔值vNe=checkVerNeighbor（verMap）；
for（入口点：horMap.entrySet（））
{
如果（point.getValue（）.size（）>=3）
{
Collections.sort（point.getValue（），new Comparator（））
{
@凌驾
公共整数比较（点o1，点o2）
{
返回Double.valueOf（o1.getY（））.compareTo（Double.valueOf（o2.getY（））；
}
});
整数计数=0；
对于（int i=0；i=2）
{
System.out.println（“找到的水平对”）；
计数=0；
打破
}
}
}
}
}

可以进行类似的运行以获得垂直直线

另一种方法是执行以下操作。它应该更快、更干净

private static boolean checkVerNeighbor(Map<Double, List<Point>> verMap)
  {

    for ( List<Point> ps : verMap.values() )
    {
      NavigableSet<Point> sortedSet = new TreeSet<Point>(new Comparator<Point>()
      {
        @Override
        public int compare(Point o1, Point o2)
        {
          return Double.valueOf(o1.getX()).compareTo(Double.valueOf(o2.getX()));
        }
      });

      sortedSet.addAll(ps);

      for ( Point p : sortedSet )
      {
        Set<Point> triplets = sortedSet.subSet(p, true,
                                               new Point(Double.valueOf(p.getX() + 2).intValue(), Double.valueOf(p.getY())
                                                                                                        .intValue()), true);
        if ( triplets.size() >= 3 )
        {
          System.out.println("Found Triplets + " + p);
          return true;

        }
      }
    }
    return false;
  }

private静态布尔checkVerNeighbor（Map-verMap）
{
对于（列表ps:verMap.values（））
{
NavigableSet sortedSet=新树集（新比较器（）
{
@凌驾
公共整数比较（点o1，点o2）
{
返回Double.valueOf（o1.getX（））.compareTo（Double.valueOf（o2.getX（））；
}
});
分类数据集添加全部（ps）；
用于（p点：分拣数据集）
{
集合三元组=分类集合。子集（p，真，
新点（Double.valueOf（p.getX（）+2.intValue（）），Double.valueOf（p.getY（））
.intValue（）），true）；
如果（triplets.size（）>=3）
{
System.out.println（“发现三联体+”+p）；
返回true；
}
}
}
返回false；
}