我关心的是提高源代码的可读性，它涉及到通过将大型方法分解为更小（简洁）的方法来减小它们的大小。简单地说，我有一个非常单一的方法，可以做很多不同的事情，例如：

public void verHugeMethod(List<Person> people) {
    for (Person person : people) {
        totalAge += person.getAge();
        totalHeight += person.getHeight();
        totalWeight += person.getWeight();
        // More calculations over class variables...
    }
}

我想把方法改成：

public void calculateTotalAge(List<Person> people) {
    for (Person person : people) {
        totalAge += person.getAge();
    }
}

public void calculateTotalHeight(List<Person> people) {
    for (Person person : people) {
        totalHeight += person.getHeight();
    }
}

public void calculateTotalWeight(List<Person> people) {
    for (Person person : people) {
        totalWeight += person.getWeight();
    }
}
// More calculations over class variables...

我关心的是应用这种重构时的性能（时间和内存）。对于一小部分人来说，这当然不是问题，但我担心这个名单会逐渐增长。
例如，对于一个更老式的 for 我可以看到以下影响：

// OPTION 1
public void method1() { // O(1) + O(3n)
    int i = 0; // O(1)
    while (int i < people.size()) { // O(n)
        doSomething(people.get(i)); // O(1)
        doAnotherThing(people.get(i)); // O(1)
        i++; // O(1)
    }
}

// OPTION 2
public void method1() { // O(2) + O(4n)
    method1(); // O(1) + O(2n)
    method2(); // O(1) + O(2n)
}
public void method2() { // O(1) + O(2n)
    int i = 0; // O(1)
    while (int i < people.size()) { // O(n)
        doSomething(people.get(i)); // O(1)
        i++; // O(1)
    }
}
public void method3() { // O(1) + O(2n)
    int i = 0; // O(1)
    while (int i < people.size()) { // O(n)
        doAnotherThing(people.get(i)); // O(1)
        i++; // O(1)
    }
}

我知道java如何将foreach指令转换为 iterables . 因此，我的问题是：
java在执行或编译方面是否有一些优化？
我应该关心这种性能问题吗？
注意：我知道在渐近增长和big-o表示法方面我们应该忽略常量，但我只是想知道这种场景是如何应用于java的。