for循环定义： 

同过一个简单的表达式，来完成多次重复性的代码功能；格式如下： 

for（变量初始值；变量取值范围；变量自增/自减）{ 

    //代码块； 

} 

一个复杂的for循环中可以嵌套多个同级的for循环，一般表现如下： 

for（变量初始值；变量取值范围；变量自增/自减）{ 

        for（变量初始值；变量取值范围；变量自增/自减）{ 

                //代码块 

    } 

    for（变量初始值；变量取值范围；变量自增/自减）{ 

                //代码块 

    } 

} 

多重for循环的执行顺序是，最外面的for循环执行一次，里面的同层级的for循环就会执行一轮；举个例子，用“*”输出一个4*4的正方形。

“` 

这里写代码片 

package com.for.rumple;

public class ForTest {

public static void main(String[] args) {
//第一层for循环用来控制输出的行数；
    for (int i = 1; i <= 4; i++) {
//第二层for循环用来控制输出的列数；
        for (int j = 1; j <= 4; j++) {
            System.out.print("*");
        }
//外层的for执行一次，就
        System.out.println();
    }
}


}

效果图： 


下面展示一个三层for循环打印的图案： 

源码： 

package com.for.rumple;

public class ForTest01 {

public static void main(String[] args) {
    for (int i = 1; i <= 5; i++) {
        for (int k = 5 - i; k > 0; k--) {
            System.out.print("-");
        }
        for (int j = 1; j < 2 * i; j++) {
            System.out.print("*");
        }
        for (int k = 5 - i; k > 0; k--) {
            System.out.print("-");
        }
        System.out.println();
    }
}


} 

效果图(分两张讲解)： 

跳出单个循环：continue

for (int i = 0; i <5 ; i++) {
			if (i == 3) {
				continue;
			}
			System.out.print(i + " ");
		}

输出：
0 1 2 4


跳出一层for循环：


		for (int i = 0; i <5 ; i++) {
			if (i == 3) {
				break;
			}
			System.out.print(i + " ");
		}

输出：
0 1 2


跳出两层for循环：


		tag:	for (int i = 0; i < 5; i++) {
			for (int j = 0; j < 3; j++) {
				if (i == 2) {
					break tag;
				}
				System.out.println("*****");
			}
		}
		// 这里外层循环执行两次就终止了

输出：
*****
*****
*****
*****
*****
*****


总结：

利用标签，跳出标签所在的循环

实例代码
for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
       for (int k = j + 1; k < n; k++) {
            count++;
       }
    }
}

以上代码中，求count++语句的执行次数。
其实这段代码中求count++语句的执行次数等价于：从n个整数中取出三个整数的组合总共有多少种（不考虑顺序，1,2,3 2,3,1 等算一种）。
求解过程
$n&gt;2时：$
      $当i=0时，j=1\sim (n-1)，count的执行次数为((n-1)-1)+(n-3)+(n-4)+\cdots+2+1$
      $当i=1时，j=2\sim (n-1)，count的执行次数为((n-1)-2)+(n-4)+(n-5)\cdots+2+1$
      $当i=2时，j=3\sim (n-1)，count的执行次数为((n-1)-3)+(n-5)+\cdots+2+1$
                                                $\vdots$
      $当i=n-3时，j=(n-2)\sim (n-1)，count的执行次数为1$
      $当i=n-2时，j=(n-1)，count的执行次数为0$
可以看出，每次i产生变化时，count++语句的执行次数都是一个等差数列，可由等差数列求和公式：

$S_n=\frac{n(a_1+a_n)}{2}=1+2+\cdots+n=\frac{n(1+n)}{2}=\frac{n^2+n}{2}$

count++总执行次数$S_n:$

$S_n=\frac{(n-2)^2+(n-2)}{2}+\frac{(n-3)^2+(n-3)}{2}+\cdots+\frac{2^2+2}{2}+\frac{1^2+1}{2}\\
=\frac{((n-2)^2+(n-3)^2+\cdots+2^2+1^2)+((n-2)+(n-3)+\cdots+2+1)}{2}$

再由公式：

$1^2+2^2+\cdots+n^2=\frac{n(n+1)(2n+1)}{6}$

得：

$S_n=\frac{\frac{(n-2)(n-2+1)(2(n-2)+1)}{6}+\frac{(n-2)^2+(n-2)}{2}}{2}\\
=\frac{n(n-1)(n-2)}{6}$

$0&lt;n&lt;2时：$
count++的执行次数为0，$n&gt;2$的公式仍适用于$0&lt;n&lt;2$的情况。
即：
count++语句的执行次数为$\frac{n(n-1)(n-2)}{6}$
参考文章
一个小问题：计算3层循环的执行次数

这不能解决您的多处理问题，但它可能会使您的进程更快。在
使用嵌套循环构造n-d坐标然后对其进行操作的模式可以使用```numpy.meshgrid````将矢量化d。如果不知道你的实际计算，这种方法是无法测试的。在import numpy as np
a = np.array([0,1,2])
b = np.array([10,11,12])
c = np.array([20,21,22])
x, y, z = np.meshgrid(a,b,c)
>>> x
array([[[0, 0, 0],
[1, 1, 1],
[2, 2, 2]],
[[0, 0, 0],
[1, 1, 1],
[2, 2, 2]],
[[0, 0, 0],
[1, 1, 1],
[2, 2, 2]]])
>>> y
array([[[10, 10, 10],
[10, 10, 10],
[10, 10, 10]],
[[11, 11, 11],
[11, 11, 11],
[11, 11, 11]],
[[12, 12, 12],
[12, 12, 12],
[12, 12, 12]]])
>>> z
array([[[20, 21, 22],
[20, 21, 22],
[20, 21, 22]],
[[20, 21, 22],
[20, 21, 22],
[20, 21, 22]],
[[20, 21, 22],
[20, 21, 22],
[20, 21, 22]]])
>>>
f = x + y + z
>>> f
array([[[30, 31, 32],
[31, 32, 33],
[32, 33, 34]],
[[31, 32, 33],
[32, 33, 34],
[33, 34, 35]],
[[32, 33, 34],
[33, 34, 35],
[34, 35, 36]]])
>>>
还有一种选择是使用meshgrid来创建实际的点，然后使用一个循环来迭代这些点—如果不知道如何重塑结果，则会丢失空间信息。我在SO答案中找到这个https://stackoverflow.com/a/18253506/2823755
^{pr2}$
您可以创建一个函数并将其应用于pointsdef g(point):
x, y, z = point
return x + y + z
result = np.apply_along_axis(g, 1, points)
>>> result
array([30, 31, 32, 31, 32, 33, 32, 33, 34, 31, 32, 33, 32, 33, 34, 33, 34, 35, 32, 33, 34, 33, 34, 35, 34, 35, 36])
>>>
重塑这个例子很简单：>>> result.reshape(3,3,3)
array([[[30, 31, 32],
[31, 32, 33],
[32, 33, 34]],
[[31, 32, 33],
[32, 33, 34],
[33, 34, 35]],
[[32, 33, 34],
[33, 34, 35],
[34, 35, 36]]])
>>>
测试以确保它们都一样>>> np.all(result.reshape(3,3,3) == f)
True
>>>
对于更复杂的数学问题，只需迭代点：result = []
for point in points:
example = some_maths
result.append(example)
result = np.array(result).reshape(shape_of_the_3d_data)