一、Java循环的4种写法

普通 fori 循环

普通 for 循环原理很简单，首先获取集合的长度 userList.size()，循环体内根据循环到的下标获取对应的元素， 然后每次循环 +1，达到遍历整个集合的目的。

这种写法在以前非常的常见，现在大多使用 forEach 替代。

List userList = new ArrayList<>();

userList.add(new User(“同学1”, “北京”, 10));

userList.add(new User(“同学2”, “上海”, 15));

userList.add(new User(“同学3”, “广州”, 12));

// 普通 for 循环

for (int i = 0; i < userList.size(); i++) {

    User user = userList.get(i);

    System.out.println(user);

}

输出：

User{name=’同学1′, address=’北京’, age=10}

User{name=’同学2′, address=’上海’, age=15}

User{name=’同学3′, address=’广州’, age=12}

User{name=’同学1′, address=’北京’, age=10}

User{name=’同学2′, address=’上海’, age=15}

User{name=’同学3′, address=’广州’, age=12}

Process finished with exit code 0

但是普通 for 循环有两个不容忽视的优点。

名列前茅，它在循环过程中可以轻松获取下标，比如我们想在循环中寻找符合条件的下标，那就只能使用 fori 循环，

for (int i = 0; i < userList.size(); i++) {

   User user = userList.get(i);

    if(user.age == 15){

        return i;

    }

}

第二点是它并非迭代器实现，也就是说在循环过程中它可以轻松的修改集合内的元素，增删改都没有问题，虽然不推荐这样做，但是这样的需求在实际开发中还是可能遇到。

int size = userList.size();

// 普通 for 循环

for (int i = 0; i < size; i++) {

    size = userList.size();

    User user = userList.get(i);

    if (user.age == 15) {

        userList.remove(2);

    }

}

forEach循环

For-Each 是 Java5 中引入的另一种数组遍历技术，它以类似于常规for循环的关键字开头具有以下特点：

无需声明和初始化循环计数器变量，而是声明一个与数组的基本类型相同类型的变量，然后是冒号，然后是冒号，然后是数组名。

在循环主体中，可以使用创建的循环变量，而不是使用索引数组元素。

它通常用于遍历数组或Collections类（例如ArrayList）

语法

for (type var : array)

{

    statements using var;

}

示例

for (int i=0; i

{

    type var = arr[i];

    statements using var;

}

应用到 fori 的例子

for (User user : userList) {

   System.out.println(user);

}

输出

User{name=’同学1′, address=’北京’, age=10}

User{name=’同学2′, address=’上海’, age=15}

User{name=’同学3′, address=’广州’, age=12}

User{name=’同学1′, address=’北京’, age=10}

User{name=’同学2′, address=’上海’, age=15}

User{name=’同学3′, address=’广州’, age=12}

Process finished with exit code 0

局限性：

当你想要在循环体内修改数组时，for-each 循环不合适，你应该选择普通 fori 循环

for (int num : marks)

{

    // only changes num, not the array element

    num = num*2;

}

forEach 不跟踪索引，内部使用迭代器实现，所以我们在循环过程中没办法获取到索引

for (int num : numbers) {

    if (num == target) {

        return ???;   // do not know the index of num

    }

}

For – each only iterates forward over the array in single steps

// cannot be converted to a for-each loop

for (int i = numbers.length – 1; i > 0; i–) {

    System.out.println(numbers[i]);

}

For – each cannot process two decision making statements at once

// cannot be easily converted to a for-each loop

for (int i = 0; i < numbers.length; i++) {

    if (numbers[i] == arr[i]) { …

    }

}

lambda 表达式 forEach

userList.forEach(e -> {

    System.out.println(e);

});

这种写法相比 forEach 更加的简单，但是存在一个很麻烦的问题，由于 lambda 是基于内部类实现的，所以我们在循环体内如果想修改外部变量，比如这样

int i = 0;

userList.forEach(e -> {

    System.out.println(e);

    i++;

});

代码中的 i++ 就会报错，因为内部类无法直接访问外部资源，Variable used in lambda expression should be final or effectively final，需要我们将变量修改为 Atomic ，如下：

AtomicInteger i = new AtomicInteger();

userList.forEach(e -> {

    System.out.println(e);

    i.set(i.getAndIncrement()+1);

});

迭代器 iterator

迭代器在现在实际开发中使用比较少了，它长这个样子，其实 forEach 的底层就是迭代器实现。

forEach 中对于list编译器会调用 Iterable 接口的 iterator 方法来循环遍历数组的元素，iterator方法中是调用Iterator接口的的 next() 和 hasNext() 方法来做循环遍历。java中有一个叫做迭代器模式的设计模式，这个其实就是对迭代器模式的一个实现。

对于数组，就是转化为对数组中的每一个元素的循环引用

Iterator iterator = userList.iterator();

while (iterator.hasNext()) {

    System.out.println(iterator.next());

}

执行结果

User{name=’同学1′, address=’北京’, age=10}

User{name=’同学2′, address=’上海’, age=15}

User{name=’同学3′, address=’广州’, age=12}

Process finished with exit code

上一篇

怎样创建在线文档?

下一篇

为什么要用Java开发高频交易系统?