在 Java 中，遍历对象的方式主要取决于对象的类型和数据结构。以下是几种常见的遍历方式，以及它们的效率比较：
-
普通的 for 循环：
- 效率：高。使用普通的 for 循环可以直接根据索引来访问元素，适用于数组和实现了
RandomAccess接口的列表，例如ArrayList。 - 适用对象： 数组、
ArrayList等支持随机访问的列表。
ArrayList<String> list = new ArrayList<>(); // 添加元素到 list 中 for (int i = 0; i < list.size(); i++) { String element = list.get(i); // 处理元素 } - 效率：高。使用普通的 for 循环可以直接根据索引来访问元素，适用于数组和实现了
-
增强型 for 循环（foreach 循环）：
- 效率：一般。增强型 for 循环适用于所有实现了
Iterable接口的集合类，它会通过迭代器（iterator）遍历集合元素。 - 适用对象： 所有实现了
Iterable接口的集合类。
ArrayList<String> list = new ArrayList<>(); // 添加元素到 list 中 for (String element : list) { // 处理元素 } - 效率：一般。增强型 for 循环适用于所有实现了
-
迭代器（Iterator）：
- 效率：一般。使用
Iterator显式地控制遍历过程，适合所有实现了Iterable接口的集合类。 - 适用对象： 所有实现了
Iterable接口的集合类。
ArrayList<String> list = new ArrayList<>(); // 添加元素到 list 中 Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String element = iterator.next(); // 处理元素 } - 效率：一般。使用
-
Java 8 中的 Stream API：
- 效率：高（对于并行流，效率更高）。Stream API 提供了丰富的函数式操作，可以处理大量数据，并支持并行处理。
- 适用对象： 所有实现了
Iterable接口的集合类。
ArrayList<String> list = new ArrayList<>(); // 添加元素到 list 中 list.stream().forEach(element -> { // 处理元素 }); -
Java 8 中的并行流：
- 效率：非常高。对于大数据集合，在多核处理器上并行处理能显著提高性能。
- 适用对象： 所有实现了
Iterable接口的集合类。
ArrayList<String> list = new ArrayList<>(); // 添加元素到 list 中 list.parallelStream().forEach(element -> { // 处理元素 });
综上所述，选择合适的遍历方式应该基于具体的数据结构和操作需求。对于小型数据集合，普通的 for 循环可能是最高效的选择；对于大数据集合或需要并行处理的情况，使用 Stream API 或并行流则更合适。
上述内容我是从ai里面查出来的，但是我头铁我不信，我要自己试试，然后我开始了尝试。
import com.test.testmq.service.TestService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
@Controller
public class TestController {
@Resource
TestService testService;
@RequestMapping("/helloword")
@ResponseBody
public String hello() {
return "Hello Word";
}
@RequestMapping("/testinsert")
@ResponseBody
public String testinsert() {
testService.testinsert();
return "Hello Word";
}
@RequestMapping("/testfor")
@ResponseBody
public String testfor() {
testService.testfor();
return "Hello Word";
}
@RequestMapping("/testforeach")
@ResponseBody
public String testforeach() {
testService.testforeach();
return "Hello Word";
}
@RequestMapping("/testIterator")
@ResponseBody
public String testIterator() {
testService.testIterator();
return "Hello Word";
}
@RequestMapping("/testStream")
@ResponseBody
public String testStream() {
testService.testStream();
return "Hello Word";
}
@RequestMapping("/testparallelStream")
@ResponseBody
public String testparallelStream() {
testService.testparallelStream();
return "Hello Word";
}
}
这是对应的controller层
public interface TestService {
public void testfor();
public void testinsert();
public void testforeach();
public void testIterator();
public void testStream();
public void testparallelStream();
}
这是service层
import com.test.testmq.entity.LeaderList;
import com.test.testmq.mapper.TestMapper;
import com.test.testmq.service.TestService;
import lombok.extern.log4j.Log4j;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@Slf4j
@Service
public class TestServiceImpl implements TestService {
@Resource
TestMapper testMapper;
@Override
public void testinsert() {
long start = System.currentTimeMillis();
List<LeaderList> list = new ArrayList<>();
for (int i = 0; i < 90000; i++) {
LeaderList leaderList = new LeaderList();
leaderList.setLeaderNo(i+"");
leaderList.setLeaderName("张三");
list.add(leaderList);
}
testMapper.insert(list);
long end = System.currentTimeMillis();
log.error(String.valueOf(end-start));
}
@Override
public void testforeach() {
long start = System.currentTimeMillis();
List<LeaderList> list = testMapper.list();
List<LeaderList> listret = new ArrayList<>();
for (LeaderList leaderList : list) {
String leaderNo = leaderList.getLeaderNo();
if((Integer.valueOf(leaderNo))%2 == 1){
listret.add(leaderList);
}
}
long end = System.currentTimeMillis();
log.error(String.valueOf(end-start)+"end");
log.error(listret.size()+"size");
}
@Override
public void testIterator() {
long start = System.currentTimeMillis();
List<LeaderList> list = testMapper.list();
List<LeaderList> listret = new ArrayList<>();
Iterator<LeaderList> iterator = list.iterator();
while (iterator.hasNext()){
LeaderList next = iterator.next();
String leaderNo = next.getLeaderNo();
if((Integer.valueOf(leaderNo))%2 == 1){
listret.add(next);
}
}
long end = System.currentTimeMillis();
log.error(String.valueOf(end-start)+"end");
log.error(listret.size()+"size");
}
@Override
public void testStream() {
long start = System.currentTimeMillis();
List<LeaderList> list = testMapper.list();
List<LeaderList> listret = new ArrayList<>();
list.stream().forEach(element -> {
String leaderNo = element.getLeaderNo();
if((Integer.valueOf(leaderNo))%2 == 1){
listret.add(element);
}
// 处理元素
});
long end = System.currentTimeMillis();
log.error(String.valueOf(end-start)+"end");
log.error(listret.size()+"size");
}
@Override
public void testparallelStream() {
long start = System.currentTimeMillis();
List<LeaderList> list = testMapper.list();
List<LeaderList> listret = new ArrayList<>();
list.parallelStream().forEach(element -> {
String leaderNo = element.getLeaderNo();
if((Integer.valueOf(leaderNo))%2 == 1){
listret.add(element);
}
// 处理元素
});
long end = System.currentTimeMillis();
log.error(String.valueOf(end-start)+"end");
log.error(listret.size()+"size");
}
/**
* 用处就是将所有的偶数查询出来
*/
@Override
public void testfor() {
long start = System.currentTimeMillis();
List<LeaderList> list = testMapper.list();
List<LeaderList> listret = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
LeaderList leaderList = list.get(i);
String leaderNo = leaderList.getLeaderNo();
if((Integer.valueOf(leaderNo))%2 == 1){
listret.add(leaderList);
}
}
long end = System.currentTimeMillis();
log.error(String.valueOf(end-start)+"end");
log.error(listret.size()+"size");
}
}
大概就是一个插入的接口，还有就是几种的对比方法，分别是for，foreach，Iterator，Stream，parallelStream
然后插入的数据量大概是9730000
大概是千万不到，插入的时候我插入的是两个字段，实体应该是10多个字段，然后我就一遍一遍的执行看结果，我这边的出来的结果。
1，for 425615end
2，foreach 403837end
3，Iterator 363512end
4，Stream 331943end
5，parallelStream 直接报错了
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1d45091]
19:31:51.865 ERROR --- [http-nio-4399-exec-4] o.a.c.c.C.[.[localhost].[/].[dispatcherServlet] :Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.ArrayIndexOutOfBoundsException] with root cause
java.lang.ArrayIndexOutOfBoundsException: 31618
at java.util.ArrayList.add(ArrayList.java:465)
at com.test.testmq.service.impl.TestServiceImpl.lambda$testparallelStream$1(TestServiceImpl.java:100)
at java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1384)
at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482)
at java.util.stream.ForEachOps$ForEachTask.compute(ForEachOps.java:291)
at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:731)
at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1067)
at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1703)
at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:172)
虽然这个报错我我没去查，但是我认为，是数据量超过了parallelStream 底层的限制，盲猜底层应该是通过数组来控制，当然期间我在mysql也遇到了，批量插入的时候mysql提示我数据量太大了，然后我降到了90000条插入一次，因为mysql 的包有一个大小限制，报错信息没有粘出来，因为报错太明显了，不需要粘出来，基本上一看就懂了，根据我的推测大概是在不考虑位数的情况下，Stream 在数据量大的时候确实是最快的，其次就是Iterator ，其次就是foreach ，最后就是for ，但是尴尬的是，如果你需要找到第几个的情况下，还是需要for，因为他确实可以找到第几个，当然Stream 应该也可以吧，parallelStream 的效率我盲猜应该是比Stream 快，但是数据量太大的情况下可能会收到了影响。
