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();
怎麼裝進去就怎麼取出來啊。