「javalist循环」javalist循环遍历
本篇文章给大家谈谈javalist循环，以及javalist循环遍历对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java 循环list集合 有几种方法
- 2、java 高级循环 出 list里内容
- 3、java关于集合List循环？
- 4、java 循环一个list
- 5、java 定义一个线程池 循环遍历list，进行读写操作
java 循环list集合 有几种方法
public static void main(String[] args) {
ListInteger list = new ArrayList();
list.add(0);
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
//for
for(int i=0; ilist.size(); i++){
System.out.println(list.get(i));
}
//for each
for(Integer i : list){
System.out.println(i);
}
//iterator
IteratorInteger it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//array
Integer[] array = new Integer[list.toArray().length];
list.toArray(array);
// for(int i=0; iarray.length; i++){
// System.out.println(array[i]);
// }
for(Integer i : array){
System.out.println(i);
}
}
java 高级循环 出 list里内容
要循环出 list里内容，就把类封装，通过for循环一层一层往外面拨。
while(rs.next()){
info.setList_id(rs.getString(1));
info.setList_dm(rs.getString(2));
info.setList_sc(rs.getString(3));
list.add(num++, info);
}
StockInfo info = new StockInfo();
怎么装进去就怎么取出来啊。
java关于集合List循环？
package com.xxt.lyh;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
ListString list = new ArrayListString();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
// for循环。
for (int i = 0; i list.size(); i++) {
String name = list.get(i);
System.out.println(name);
}
// 增强型for循环，java5开始引入。
System.out.println();
for (String name : list) {
System.out.println(name);
}
}
}
java 循环一个list
使用容器循环
public static void main(String[] args) {
ListString list = new ArrayList();
list.add("123");
list.add("java");
list.add("j2ee");
System.out.println("=========Iterate循环=======");
IteratorString iter = list.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
}
刚看了修改了问题。感觉写成一个存储过程不就快了。
java 定义一个线程池 循环遍历list，进行读写操作
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* 并发处理器
* 适用于如下场景（举例）：
* 一个任务队列， 有150个任务需要并发处理，使用此对象，可以每次并发执行20次（可设置），则总共串行执行8次并发，可获取执行结果
*
* @param T 类型T限制为任务Callable使用的数据对象和返回结果的数据对象为同一个bean
*/
public class ConcurrentExcutorT
{
/** 非空，所有任务数组 */
private CallableT[] tasks;
/** 非空，每次并发需要处理的任务数 */
private int numb;
/** 可选，存放返回结果，这里有个限制，泛型T必须为Callable返回的类型T */
private ListT result;
/**
* 无参构造
*/
public ConcurrentExcutor()
{
super();
}
/**
* 不需要返回结果的任务用此创建对象
* @param tasks
* @param numb
*/
public ConcurrentExcutor(CallableT[] tasks, int numb)
{
super();
this.tasks = tasks;
this.numb = numb;
}
/**
* 需要结果集用此方法创建对象
* @param tasks
* @param numb
* @param result
*/
public ConcurrentExcutor(CallableT[] tasks, int numb, ListT result)
{
super();
this.tasks = tasks;
this.numb = numb;
this.result = result;
}
public void excute()
{
// 参数校验
if(tasks == null || numb 1)
{
return;
}
// 待处理的任务数
int num = tasks.length;
if(num == 0)
{
return;
}
// 第一层循环，每numb条数据作为一次并发
for(int i=0; i(int)Math.floor(num/numb) + 1; i++)
{
// 用于记录此次numb条任务的处理结果
Future[] futureArray;
if(numb num)
{
futureArray = new Future[num];
}
else
{
futureArray = new Future[numb];
}
// 创建线程容器
ExecutorService es = Executors.newCachedThreadPool();
// 第二层循环，针对这numb条数据进行处理
for(int j=i*numb; j(i+1)*numb; j++)
{
// 如果超出数组长度，退出循环
if(j + 1 num)
{
break;
}
// 执行任务，并设置Future到数组中
futureArray[j%numb] = es.submit(tasks[j]);
}
// 将结果放入result中
if (result != null)
{
for (int j = 0; j futureArray.length; j++)
{
try
{
if(futureArray[j] != null)
{
Object o = futureArray[j].get();
result.add((T)o);
}
}
catch (InterruptedException e)
{
System.out.println("处理Future时发生InterruptedException异常，目标Future为： " + futureArray[j].toString());
e.printStackTrace();
}
catch (ExecutionException e)
{
System.out.println("处理Future时发生ExecutionException异常，目标Future为： " + futureArray[j].toString());
e.printStackTrace();
}
}
}
es.shutdown();
}
}
关于javalist循环和javalist循环遍历的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。