java循环list
1. java 循环一个list
使用容器循环
publicstaticvoidmain(String[]args){
List<String>list=newArrayList();
list.add("123");
list.add("java");
list.add("j2ee");
System.out.println("=========Iterate循环=======");
Iterator<String>iter=list.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
}刚看了修改了问题。感觉写成一个存储过程不就快了。
2. java for循环 怎样把一个list里相同的数据放到一起
通过题主的描述可以看到，其实就是一个List<Integer>的集合数据处理问题，希望把相同的数据放到一起，是一种归类操作，也就是说其实总得需要把List<Integer>形式转化为Map<Integer, List<Integer>>的形式
这种形式map的key也就是当前的这个数字，而这个value就是这个数字对应的所有当前出现此key的集合
List<Integer>list=Arrays.asList(1,1,2,3,4,2,1);
Map<Integer,List<Integer>>map=newHashMap<>();
for(Integernum:list){
//map是否包含此key，若已经包含则添加一个新的数字到对应value集合中
if(map.containsKey(num)){
map.get(num).add(num);
}else{
//map不包含此key，则重新创建一个新集合，并把这个数字添加进集合
//，再把集合放到map中
List<Integer>newList=newArrayList<>();
newList.add(num);
map.put(num,newList);
}
}
System.out.println(map);
输出结果
结果也是一样的，题主可以自行选择
3. java实现两层list循环输出
for(Object object:list){
object.get();
}
4. 关于java list循环的问题
我猜你的想法应该是类似分页的效果，可以根据请求的页数获得数据。
比如：3万行数据，分成6页（当然可以根据每页的数据设置页数），每页5000条数据。
需要第1页的数据，则返回前面的5000条，即 （第1页-1） * 5000 到 第1页 * 5000，这个区间内的数据。依次类推。如果想更加灵活，则动态的设置每页的数据条数。
请求数据的时候，只需要传入相应的页数就好了，即想要那个区间段的数据。
一次一次的请求就可以获得数据了。而且也避免了一次数据过大，占用内存过多。
-----------------------我是华丽的分割线---------------
int all_len = //总数
int page_count = //分页数
int every_page_len = //每页的数据条数
public Map readExcel(int page_index) {
...................
int start = (page_index-1)*every_page_len;
int end = page_index*every_page_len;
for(int i=start ; i<end; i++){
......................
}
return XXX;
-----------------------我是华丽的分割线---------------
思路和简单的实现方式就上面这个样子了，一些错误参数控制什么的，我就不仔细考虑了。
5. java 循环list集合 有几种方法
public static void main(String[] args) {
List<Integer> 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; i<list.size(); i++){
System.out.println(list.get(i));
}
//for each
for(Integer i : list){
System.out.println(i);
}
//iterator
Iterator<Integer> 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; i<array.length; i++){
// System.out.println(array[i]);
// }
for(Integer i : array){
System.out.println(i);
}
}
6. java 定义一个线程池 循环遍历list，进行读写操作
importjava.util.List;
importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;
/**
*并发处理器
*适用于如下场景（举例）：
*一个任务队列，有150个任务需要并发处理，使用此对象，可以每次并发执行20次（可设置），则总共串行执行8次并发，可获取执行结果
*
*@param<T>类型T限制为任务Callable使用的数据对象和返回结果的数据对象为同一个bean
*/
publicclassConcurrentExcutor<T>
{
/**非空，所有任务数组*/
privateCallable<T>[]tasks;
/**非空，每次并发需要处理的任务数*/
privateintnumb;
/**可选，存放返回结果，这里有个限制，泛型T必须为Callable返回的类型T*/
privateList<T>result;
/**
*无参构造
*/
publicConcurrentExcutor()
{
super();
}
/**
*不需要返回结果的任务用此创建对象
*@paramtasks
*@paramnumb
*/
publicConcurrentExcutor(Callable<T>[]tasks,intnumb)
{
super();
this.tasks=tasks;
this.numb=numb;
}
/**
*需要结果集用此方法创建对象
*@paramtasks
*@paramnumb
*@paramresult
*/
publicConcurrentExcutor(Callable<T>[]tasks,intnumb,List<T>result)
{
super();
this.tasks=tasks;
this.numb=numb;
this.result=result;
}
publicvoidexcute()
{
//参数校验
if(tasks==null||numb<1)
{
return;
}
//待处理的任务数
intnum=tasks.length;
if(num==0)
{
return;
}
//第一层循环，每numb条数据作为一次并发
for(inti=0;i<(int)Math.floor(num/numb)+1;i++)
{
//用于记录此次numb条任务的处理结果
Future[]futureArray;
if(numb>num)
{
futureArray=newFuture[num];
}
else
{
futureArray=newFuture[numb];
}
//创建线程容器
ExecutorServicees=Executors.newCachedThreadPool();
//第二层循环，针对这numb条数据进行处理
for(intj=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(intj=0;j<futureArray.length;j++)
{
try
{
if(futureArray[j]!=null)
{
Objecto=futureArray[j].get();
result.add((T)o);
}
}
catch(InterruptedExceptione)
{
System.out.println("处理Future时发生InterruptedException异常，目标Future为："+futureArray[j].toString());
e.printStackTrace();
}
catch(ExecutionExceptione)
{
System.out.println("处理Future时发生ExecutionException异常，目标Future为："+futureArray[j].toString());
e.printStackTrace();
}
}
}
es.shutdown();
}
}
7. java中对集合对象list的几种循环访问总结
List一共有三种遍历方法，如下：
importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;
publicclassMain{
publicstaticvoidmain(String[]args){
List<Integer>list=newArrayList<>();
for(inti=0;i<10;i++){
list.add(i);
}
//for循环遍历
for(inti=0,size=list.size();i<size;i++){
System.out.println(list.get(i));
}
//iterator迭代器遍历
Iterator<Integer>it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//foreach循环
for(Integeri:list){
System.out.println(i);
}
}
}
数据元素是怎样在内存中存放的？
主要有2种存储方式：
1、顺序存储，Random Access（Direct Access）：
这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。
2、链式存储，Sequential Access：
这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。
每个遍历方法的实现原理是什么？
1、传统的for循环遍历，基于计数器的：
遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。
2、迭代器遍历，Iterator：
每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。
3、foreach循环遍历：
根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。
各遍历方式的适用于什么场合？
1、传统的for循环遍历，基于计数器的：
顺序存储：读取性能比较高。适用于遍历顺序存储集合。
链式存储：时间复杂度太大，不适用于遍历链式存储的集合。
2、迭代器遍历，Iterator：
顺序存储：如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题。
链式存储：意义就重大了，平均时间复杂度降为O(n)，还是挺诱人的，所以推荐此种遍历方式。
3、foreach循环遍历：
foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，参考上面两种方式，做一个折中的选择。
8. java关于集合List循环
package com.xxt.lyh;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
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);
}
}
}
9. java代码通过for循环向list存数据,如何避免数据被覆盖
你要知道每次new一个对象就是一个新对象，在循环里new，就是每一次循环都创建一个全新的对象。而在循环外只new了一次，你每次循环只是改变外面new的对象属性值而已。 list集合可以存放多个相同的值
10. 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();
怎么装进去就怎么取出来啊。