Java 如何使用for语句获取数组或arraylist中三个连续元素的所有n个集合？

我正在尝试一种凸包方法，小问题是我需要得到三个连续顶点的所有集合，如下所示：

private void isConvexHull(Ponto[] points) {
        Arrays.sort(points);
        for (int i = 0; i <points.length; i++) {
            isClockWise(points[i],points[i+1],points[i+2]);
        }
     //... 
    }

private void isConvexHull（Ponto[]点）{
数组。排序（点）；
对于（int i=0；i）余数“技巧”
您可以使用
%
的“技巧”（
%
是余数运算符）进行循环索引。在这里，我将使用
字符串
来说明一般思路

    String s = "ABCDE";
    final int L = s.length();
    for (int i = 0; i < L; i++) {
        System.out.format("%c%c%c ",
            s.charAt(i),
            s.charAt((i + 1) % L),
            s.charAt((i + 2) % L)
        );
    } // prints "ABC BCD CDE DEA EAB "

这张照片是：

[s1, s2, s3, s4]
[s2, s3, s4, s5]
[s3, s4, s5, s6]
[s4, s5, s6, s1]
[s5, s6, s1, s2]
[s6, s1, s2, s3]

[s1, s2, s3]
[s2, s3, s4]
[s3, s4, s5]
[s4, s5, s6]
[s5, s6, s1]
[s6, s1, s2]


基于
列表的解决方案
正如《有效Java第二版》所说，第25项：更喜欢列表而不是数组。这里有一个解决方案，它将第一个
K-1
元素冗余存储在
列表的末尾，然后简单地使用
子列表
一次获取
K
元素

    String[] arr = { "s1", "s2", "s3", "s4", "s5", "s6" };

    final int L = arr.length;
    final int K = 3;
    List<String> list = new ArrayList<String>(Arrays.asList(arr));
    list.addAll(list.subList(0, K-1));

    for (int i = 0; i < L; i++) {
        System.out.println(list.subList(i, i + K));
    }

由于
子列表
是一个视图，因此不必像基于数组的解决方案那样进行
O（K）
移位。这还显示了
列表
在数组上的表现力。
只需记住前两点，从最后开始，并在每次迭代中进行移位即可

private static boolean isConvexHull(Ponto[] points)
{
    final int len = points.length;
    if (len < 3) return false;
    Arrays.sort(points);

    Ponto p1 = points[len - 2];
    Ponto p2 = points[len - 1];
    for (Ponto p3 : points)
    {
        if (!isClockWise(p1, p2, p3)) return false;
        p1 = p2;
        p2 = p3;
    }
    return true;
}

private静态布尔值isConvexHull（Ponto[]点）
{
最终整数长度=点长度；
如果（len<3）返回false；
数组。排序（点）；
Ponto p1=点[len-2]；
Ponto p2=点[len-1]；
对于（Ponto p3：分数）
{
如果（！isClockWise（p1、p2、p3））返回false；
p1=p2；
p2=p3；
}
返回true；
}

顺便问一下，你如何对数组进行精确排序？排序标准是什么？
一个迭代器……这是怎么回事？你能演示一下吗？%运算符的速度远不及最后两个元素（序列包装的元素）的速度快。但是，如果您使用特殊情况，请确保单独处理Length==1的情况。@newba:
迭代器
与您讨论的方法基本相同，只是使用
yield return
而不是调用
isclock
。这将三元组生成与三元组处理分离。另一种方法是这样做的（推式与拉式迭代）是传递一个
操作
委托，以便为每个三元组调用。@Ben：是的，
%
效率不高，但我认为这是可以忽略的小无效率（过早优化等）。使用
%
更干净（特殊情况=增加了复杂性！），如果你知道余数语义，就更容易理解。@poly我不想让你做任何事情，只是想让你知道我的想法：）安静。@FredOverflow。我实际上现在没有对它排序，因为这是不必要的。但我有一个实现Comparable的classe Ponto，我让它先按x排序，然后按y排序，“调整”他们在这里帮助我时的对比：
private static boolean isConvexHull(Ponto[] points)
{
    final int len = points.length;
    if (len < 3) return false;
    Arrays.sort(points);

    Ponto p1 = points[len - 2];
    Ponto p2 = points[len - 1];
    for (Ponto p3 : points)
    {
        if (!isClockWise(p1, p2, p3)) return false;
        p1 = p2;
        p2 = p3;
    }
    return true;
}