Java 的“foreach”循环是如何工作的？

https://stackoverflow.com/questions/85190

01-07-2019
|

题

考虑：

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList

for (String item : someList) {
    System.out.println(item);
}

相当于什么 for 循环看起来像不使用 对于每个 句法？

解决方案

for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
    String item = i.next();
    System.out.println(item);
}

请注意，如果您需要使用 i.remove(); 在你的循环中，或者以某种方式访问实际的迭代器，你不能使用 for ( : ) 习语，因为实际的迭代器只是推断出来的。

正如 Denis Bueno 所指出的，此代码适用于任何实现 Iterable 界面.

另外，如果右侧 for (:) 成语是一个 array 而不是一个 Iterable 对象，内部代码使用 int 索引计数器并检查 array.length 反而。请参阅 Java语言规范.

其他提示

构造 对于每个 对于数组也有效。例如

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
    // fruit is an element of the `fruits` array.
}

这本质上相当于

for (int i = 0; i < fruits.length; i++) {
    String fruit = fruits[i];
    // fruit is an element of the `fruits` array.
}

所以，总体总结：
[nsayer] 以下是正在发生的事情的较长形式：

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}
请注意，如果您需要使用i.remove（）;在您的循环中，或以某种方式访问实际迭代器，您不能使用for（：：）成语，因为实际的迭代器只是推断。

[丹尼斯·布埃诺]

这是Nsayer的答案所暗示的，但是值得注意的是，当“ somelist”是实现java.lang.lang.iterable.iterable的任何东西时，OP的语法将起作用 - 它不必是列表，或者是一些集合。 java.util。因此，即使您自己的类型也可以与此语法一起使用。

这 foreach 环形, ，添加到爪哇5 （也称为“增强的 for 循环”），相当于使用 java.util.Iterator——它是同一件事的语法糖。因此，在读取每个元素时，一个一个地按顺序读取 foreach 应始终选择迭代器，因为它更方便、更简洁。

foreach

for(int i : intList) {
   System.out.println("An element in the list: " + i);
}

迭代器

Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
   System.out.println("An element in the list: " + intItr.next());
}

在某些情况下您必须使用 Iterator 直接地。例如，尝试在使用时删除元素 foreach 可以（将？）导致 ConcurrentModificationException.

`foreach` 与 `for`: ：基本差异

之间唯一的实际区别 for 和 foreach 问题是，对于可索引对象，您无权访问索引。基本情况下的一个例子 for 需要循环：

for(int i = 0; i < array.length; i++) {
   if(i < 5) {
      // Do something special
   }  else {
      // Do other stuff
   }
}

尽管您可以手动创建一个单独的索引 int 变量 foreach,

int idx = -1;
for(int i : intArray) {
   idx++;
   ...
}

不推荐，因为可变范围并不理想，而且基本 for 循环只是此用例的标准和预期格式。

`foreach` 与 `for`: ：表现

访问集合时， foreach 是明显更快比基本的 for 循环的数组访问。然而，当访问数组时（至少对于原始数组和包装数组而言），通过索引进行访问要快得多。

计时原始 int 数组的迭代器和索引访问之间的差异

索引为 23-40 访问时比迭代器快 % int 或者 Integer 数组。以下是本文底部测试类的输出，它将 100 个元素的 Primitive-int 数组中的数字相加（A 是迭代器，B 是索引）：

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

我也跑了这个 Integer 数组和索引仍然是明显的赢家，但速度只快了 18% 到 25%。

对于集合来说，迭代器比索引更快

为一个 List 的 Integers, 然而，迭代器显然是赢家。只需将测试类中的 int-array 更改为：

List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

并对测试功能进行必要的更改（int[] 到 List<Integer>, length 到 size(), ， ETC。）：

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

在一项测试中，它们几乎是等效的，但对于集合，迭代器获胜。

*这篇文章基于我在 Stack Overflow 上写的两个答案：

更多信息： for-each 循环和迭代器哪个更有效？

完整的测试课程

阅读后，我创建了这个比较做任何两件事所需时间的课程这个问题关于堆栈溢出：

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
 **/
public class TimeIteratorVsIndexIntArray {

    public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

    public static final void main(String[] tryCount_inParamIdx0) {
        int testCount;

        // Get try-count from a command-line parameter
        try {
           testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
        }
        catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
           throw  new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
        }

        //Test proper...START
        int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

        long lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testIterator(intArray);
        }

        long lADuration = outputGetNanoDuration("A", lStart);

        lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testFor(intArray);
        }

        long lBDuration = outputGetNanoDuration("B", lStart);

        outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
    }

    private static final void testIterator(int[] int_array) {
       int total = 0;
       for(int i = 0; i < int_array.length; i++) {
          total += int_array[i];
       }
    }

    private static final void testFor(int[] int_array) {
       int total = 0;
       for(int i : int_array) {
          total += i;
       }
    }
    //Test proper...END

    //Timer testing utilities...START
    public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
        long lDuration = System.nanoTime() - l_nanoStart;
        System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
        return  lDuration;
    }

    public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
        long lDiff = -1;
        double dPct = -1.0;
        String sFaster = null;
        if(l_aDuration > l_bDuration) {
            lDiff = l_aDuration - l_bDuration;
            dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
            sFaster = "B";
        }
        else {
            lDiff = l_bDuration - l_aDuration;
            dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
            sFaster = "A";
        }
        System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
        return  lDiff;
   }

   //Timer testing utilities...END

}

这是一个不假设您了解 Java 迭代器的答案。它不太精确，但对教育很有用。

在编程时，我们经常编写如下所示的代码：

char[] grades = ....
for(int i = 0; i < grades.length; i++) {   // for i goes from 0 to grades.length
    System.out.print(grades[i]);           // Print grades[i]
}

foreach 语法允许以更自然且语法噪音更少的方式编写这种常见模式。

for(char grade : grades) {   // foreach grade in grades
    System.out.print(grade); // print that grade
}

此外，此语法对于不支持数组索引但实现 Java Iterable 接口的对象（例如列表或集合）有效。

Java 中的 for-each 循环使用底层迭代器机制。所以它与以下内容相同：

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}

在 Java 8 功能中你可以使用这个：

List<String> messages = Arrays.asList("First", "Second", "Third");

void forTest(){
    messages.forEach(System.out::println);
}

输出

First
Second
Third

nsayer 的答案暗示了这一点，但值得注意的是，当“someList”为时，OP 的 for(..) 语法将起作用 任何事物 实现了 java.lang.Iterable —— 它不必是一个列表，或者来自 java.util 的某个集合。因此，即使是您自己的类型也可以与此语法一起使用。

foreach 循环语法为：

for (type obj:array) {...}

例子：

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

输出：

Java
Coffe
Is
Cool

警告：您可以使用 foreach 循环访问数组元素，但不能初始化它们。使用原装的 for 为此循环。

警告：您必须将数组的类型与其他对象相匹配。

for (double b:s) // Invalid-double is not String

如果要编辑元素，请使用原始元素 for 像这样循环：

for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
    if (i==1) //1 because once again I say the 0 index
        s[i]="2 is cool";
    else
        s[i] = "hello";
}

现在，如果我们将 s 转储到控制台，我们会得到：

hello
2 is cool
hello
hello

正如定义在吉林森 for-each 循环可以有两种形式：

如果 Expression 的类型是以下类型的子类型 Iterable 那么翻译如下：

List<String> someList = new ArrayList<String>();
someList.add("Apple");
someList.add("Ball");
for (String item : someList) {
    System.out.println(item);
}

// IS TRANSLATED TO:

for(Iterator<String> stringIterator = someList.iterator(); stringIterator.hasNext(); ) {
    String item = stringIterator.next();
    System.out.println(item);
}

如果表达式必须具有数组类型 T[] 然后：

String[] someArray = new String[2];
someArray[0] = "Apple";
someArray[1] = "Ball";

for(String item2 : someArray) {
    System.out.println(item2);
}

// IS TRANSLATED TO:
for (int i = 0; i < someArray.length; i++) {
    String item2 = someArray[i];
    System.out.println(item2);
}

Java 8 引入了通常性能更好的流。我们可以将它们用作：

someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);

Java“for-each”循环构造将允许对两种类型的对象进行迭代：

T[] （任何类型的数组）
java.lang.Iterable<T>

这 Iterable<T> 接口只有一个方法： Iterator<T> iterator(). 。这适用于类型的对象 Collection<T> 因为 Collection<T> 接口扩展 Iterable<T>.

维基百科中提到的 foreach 循环的概念强调如下：

但是，与其他循环结构不同，对于循环，通常要维护 没有明确的计数器: ：他们本质上说“对此集合中的所有事情都这样做”，而不是“做X Times”。这避免了潜力 差一误差 并使代码更易于阅读。

因此，foreach循环的概念描述了该循环不使用任何显式计数器，这意味着不需要使用索引来遍历列表，从而使用户避免了差一错误。为了描述这种差一错误的一般概念，让我们举一个使用索引遍历列表的循环示例。

// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){

}

但假设如果列表以索引 1 开头，则此循环将引发异常，因为它将在索引 0 处找不到元素，并且此错误称为偏一错误。因此，为了避免这种差一错误，使用了 foreach 循环的概念。可能还有其他优点，但这就是我认为使用 foreach 循环的主要概念和优点。

for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}

这是一个等价的表达式。

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}

另请注意，在原始问题中使用“foreach”方法确实有一些限制，例如无法在迭代期间从列表中删除项目。

新的 for 循环更易于阅读，并且无需单独的迭代器，但仅在只读迭代过程中真正可用。

使用较旧的 Java 版本，包括 Java 7 您可以使用 foreach 循环如下。

List<String> items = new ArrayList<>();
        items.add("A");
        items.add("B");
        items.add("C");
        items.add("D");
        items.add("E");

        for(String item : items){
            System.out.println(item);
        }

以下是最新的使用方式 foreach 循环进入 Java 8

（循环一个列表 forEach + lambda 表达式或方法引用）

//lambda
    //Output : A,B,C,D,E
    items.forEach(item->System.out.println(item));


//method reference
    //Output : A,B,C,D,E
    items.forEach(System.out::println);

forEach 的替代方案以避免“for every”：

List<String> someList = new ArrayList<String>();

变体 1（普通）：

someList.stream().forEach(listItem -> {
    System.out.println(listItem);
});

变体 2（并行执行（更快））：

someList.parallelStream().forEach(listItem -> {
    System.out.println(listItem);
});

它通过消除所有基本的循环混乱来为您的代码增添美感。它使您的代码看起来很干净，如下所示。

普通的 for 环形：

void cancelAll(Collection<TimerTask> list) {
    for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
         i.next().cancel();
}

使用 for-each：

void cancelAll(Collection<TimerTask> list) {
    for (TimerTask t : list)
        t.cancel();
}

对于每个 是一个集合上的构造，它实现了 迭代器. 。请记住，您的集合应该实现 迭代器;否则你不能将它与 for-each 一起使用。

以下行读作“对于列表中的每个 TimerTask t。"

for (TimerTask t : list)

在 for-each 的情况下出错的可能性较小。您不必担心初始化迭代器或初始化循环计数器并终止它（在存在错误范围的情况下）。

在 Java 8 中，他们引入了 forEach。使用List、Maps可以循环。

使用 for every 循环列表

List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");

someList.forEach(listItem -> System.out.println(listItem))

或者

someList.forEach(listItem-> {
     System.out.println(listItem); 
});

循环使用 for every 的 Map

Map<String, String> mapList = new HashMap<>();
    mapList.put("Key1", "Value1");
    mapList.put("Key2", "Value2");
    mapList.put("Key3", "Value3");

mapList.forEach((key,value)->System.out.println("Key: " + key + " Value : " + value));

或者

mapList.forEach((key,value)->{
    System.out.println("Key : " + key + " Value : " + value);
});

它看起来像这样。非常粗暴。

for (Iterator<String> i = someList.iterator(); i.hasNext(); )
        System.out.println(i.next());

有一篇很好的文章 对于每个 在里面 Sun 文档.

在 Java 8 之前，您需要使用以下内容：

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

然而，随着 Java 8 中 Streams 的引入，您可以用更少的语法完成同样的事情。例如，对于您的 someList 你可以做：

someList.stream().forEach(System.out::println);

您可以找到有关流的更多信息这里.

正如许多好的答案所说，一个对象必须实现 Iterable interface 如果它想使用 for-each 环形。

我将发布一个简单的示例，并尝试以不同的方式解释如何 for-each 循环有效。

这 for-each 循环示例：

public class ForEachTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");

        for (String str : list) {
            System.out.println(str);
        }
    }
}

那么，如果我们使用 javap 反编译这个类，我们将得到这个字节码样本：

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #16                 // class java/util/ArrayList
         3: dup
         4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
         7: astore_1
         8: aload_1
         9: ldc           #19                 // String 111
        11: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        16: pop
        17: aload_1
        18: ldc           #27                 // String 222
        20: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        25: pop
        26: aload_1
        27: invokeinterface #29,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

从示例的最后一行我们可以看到，编译器会自动转换使用 for-each 关键字的使用 Iterator 在编译时。这可以解释为什么对象没有实现 Iterable interface, ，会抛出一个 Exception 当它尝试使用 for-each 环形。

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}

这 Java for 每个循环（又名增强型 for 循环）是 for 循环的简化版本。优点是需要编写的代码较少，需要管理的变量也较少。缺点是您无法控制步长值，也无法访问循环体内的循环索引。

当步长值是简单的 1 增量并且您只需要访问当前循环元素时，最好使用它们。例如，如果您需要循环遍历数组或集合中的每个元素，而不需要查看当前元素的前方或后方。

没有循环初始化，没有布尔条件，并且步长值是隐式的并且是简单的增量。这就是为什么它们被认为比常规 for 循环简单得多。

增强的 for 循环遵循以下执行顺序：

1）循环体

2) 重复步骤1，直到遍历完整个数组或集合

示例 – 整数数组

int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
  System.out.println(currentValue);
}

currentValue 变量保存 intArray 数组中循环的当前值。请注意，没有明确的步长值 - 它始终以 1 为增量。

冒号可以被认为是“在”的意思。因此，增强的 for 循环声明指出：循环 intArray 并存储当前数组 int 值在当前值变量。

输出：

示例 – 字符串数组

我们可以使用 for-each 循环来迭代字符串数组。循环声明指出：循环 myStrings String 数组并存储当前 String 值在 currentString 变量。

String [] myStrings  = {
  "alpha",
  "beta",
  "gamma",
  "delta"
};

for(String currentString : myStrings) {
  System.out.println(currentString);
}

输出：

alpha
beta
gamma
delta

示例 – 列表

增强的 for 循环还可以用于迭代 java.util.List，如下所示：

List<String> myList = new ArrayList<String>();
myList.add("alpha");
myList.add("beta");
myList.add("gamma");
myList.add("delta");

for(String currentItem : myList) {
  System.out.println(currentItem);
}

循环声明指出：循环遍历 myList 字符串列表并存储当前列表值在当前项目变量。

输出：

alpha
beta
gamma
delta

示例 – 设置

增强的 for 循环还可以用于迭代 java.util.Set，如下所示：

Set<String> mySet = new HashSet<String>();
mySet.add("alpha");
mySet.add("alpha");
mySet.add("beta");
mySet.add("gamma");
mySet.add("gamma");
mySet.add("delta");

for(String currentItem : mySet) {
  System.out.println(currentItem);
}

循环声明指出：循环遍历 mySet 字符串集并存储当前的 Set 值在当前项目变量。请注意，由于这是一个 Set，因此不会存储重复的 String 值。

输出：

alpha
delta
beta
gamma

来源： Java 中的循环 – 终极指南

Java for-each 习惯用法只能应用于数组或类型的对象 *可迭代. 。这个成语是 隐含的 因为它真正由迭代器支持。迭代器由程序员编程，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。从理论上讲，它比常规的 for 循环慢，至少对于数组和列表等“线性”结构来说是这样，但它提供了更好的抽象。

这看起来很疯狂，但是嘿它有效

List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);

这有效。魔法

List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

迭代 Items 表中的所有对象。

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow