Java集合01----ArrayList的遍历方式及应用

                                             Java集合01----ArrayList的遍历方式及应用

      前面已经学习了ArrayList的源码，为了学以致用，故列举一些ArrayList的遍历方式及应用。JDK源码学习系列04----ArrayList

1.ArrayList的遍历方式

a.一般for循环（随机访问）

Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
    value = (Integer)list.get(i);        
}

b.增强型for循环（for-each）

Integer value = null;
for (Integer intvalue:list) {
    value = intvalue;
}

c.迭代器

Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}

ArrayList三种遍历方式效率分析：

package com.sheepmu;
import java.util.*;
/*
 * @author SheepMu
 */
public class MyTest {
    public static void main(String[] args) 
    {
        List<Integer> list = new ArrayList<Integer>();
        for (int i=0; i<1000000; i++)
            list.add(i);       
        byCommonFor(list) ;
        byForEach(list) ;
        byIterator(list) ;   
    }
 
    public static void byCommonFor(List<Integer> list) {
        long startTime;
        long endTime;
        startTime = System.currentTimeMillis(); 
        for (int i=0; i<list.size(); i++) {
        	 list.get(i) ;        	 
        }
        endTime = System.currentTimeMillis();
        long totalTime = endTime - startTime;
        System.out.println("byCommonFor------>" + totalTime +"   ms");
    }
    public static void byForEach(List<Integer> list) {
        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
       
        for(Integer intvalue:list)
          ; 
        endTime = System.currentTimeMillis();
        long totalTime = endTime - startTime;
        System.out.println("ByFor-Each------>" + totalTime +"   ms");
    }
    
    public static void  byIterator(List<Integer> list) {
        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for(Iterator iter = list.iterator(); iter.hasNext(); ) {
        	              iter.next() ;
        	          }    
        endTime = System.currentTimeMillis();
        long totalTime = endTime - startTime;
        System.out.println("byIterator------>" + totalTime +"   ms");
    }
 
}

byCommonFor------>6   ms
ByFor-Each------>14   ms
byIterator------>10   ms

由此可见：遍历时随机访问的效率是最高的。

但是个人还是推荐使用for-each来进行遍历，也是我最喜欢的遍历方式。因为：foreach代码简洁美观，还有就是相对于下标循环而言的，foreach不必关心下标初始值和终止值及越界等，所以不易出错。 

2.ArrayList的应用例子

  a.ArrayList常用方法举例

package com.sheepmu;

import java.util.ArrayList;
import java.util.List;

/* 
 * @author SheepMu 
 */
public class ArrayListTest {

    public static void main(String[] args) {    
        List<String> list = new ArrayList<String>(); //使用泛型 创建ArrayList   
        list.add("A");//向ArrayList中添加元素
        list.add("B");
        list.add("C");
        list.add("D");
        System.out.println("list-----> "+ list);
        list.add(0, "E"); //  添加到最前面后其他后移
        System.out.println("添加E后的list-----> "+ list);       
        System.out.println("第一个元素-----> "+ list.get(0)); // 获取第1个元素
       
        list.remove("C"); // 删除“C”,后面的会前移
        System.out.println("删除C后的list-----> "+ list);
        System.out.println("Arraylist的大小----> "+ list.size()); // 获取ArrayList的大小 
        list.set(1, "X"); // 设置第2个元素为X
        System.out.println("设置X后的list-----> "+ list);
        
        for(String s:list ) {//用for-each遍历
            System.out.println("ArrayList中的每个元素---> "+s);
        }
 
        list.clear(); // 清空ArrayList    
        System.out.println("ArrayList是否为空----> "+ list.isEmpty()); // 判断ArrayList是否为空
    }
}

list-----> [A, B, C, D]
添加E后的list-----> [E, A, B, C, D]
第一个元素-----> E
删除C后的list-----> [E, A, B, D]
Arraylist的大小----> 4
设置X后的list-----> [E, X, B, D]
ArrayList中的每个元素---> E
ArrayList中的每个元素---> X
ArrayList中的每个元素---> B
ArrayList中的每个元素---> D
ArrayList是否为空----> true

b.ArrayList的应用例子

eg1:输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。 例如:  输入：3+8×2/9-2  输出：2 

详见：华为上机题汇总----java 第二题

package com.sheepmu;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/**** 
 *输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。 
  
    例如:  输入：3+8×2/9-2   
            输出：2   
  
    函数原型  . public int getMyRet(String str)   
 * @author sheepmu 
 * 
 */  
public class ArrayListTest {  
     public static void main(String[] args){  
         String s="3+8×2/9-2 ";  
         int result=getMyRet(s);  
         System.out.println("最后结果："+result);  
     }  
     public static int getMyRet(String s1 ){  
         int len=s1.length();  
          List<String> list=new ArrayList<String>();  
          for(int i=0;i<len;i++)  
              list.add(s1.charAt(i)+"");//!!!!!  
          System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2,  ]  
          for(int j=0;j<list.size();j++){  
                 
              if(list.get(j).equals("×")){  
                     
                  int ji=Integer.parseInt(list.get(j-1))*Integer.parseInt(list.get(j+1));  
                  list.add(j-1,ji+"");//把ji插入到原来x的前一位，原来的后移。从8开始往后移  
                  list.remove(j);//删除8；remove是删除当前位置后后面的前移；故x到了j这个下标位置。  
                  list.remove(j);//删除x  
                  list.remove(j);//删除9  
                  System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2,  ]  
                  j--;//相当于这次循环木有跳动下一个下标，因为马上要对ji参与运算，而不是跳过  
              }  
              else if(list.get(j).equals("/")){  
                    
                  int shang=Integer.parseInt(list.get(j-1))/Integer.parseInt(list.get(j+1));  
                  list.add(j-1,shang+"");   
                  list.remove(j);   
                  list.remove(j);   
                  list.remove(j);   
                  System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2,  ]  
                  j--;  
              }  
          }  
            
          for(int k=0;k<list.size();k++){//这个时候是新的size  
              if(list.get(k).equals("+")){  
                  int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));  
                  list.add(k-1,he+"");   
                  list.remove(k);   
                  list.remove(k);   
                  list.remove(k);   
                  System.out.println("list--+后->"+ list); //list--+后->[4, -, 2,  ]  
                 k--;   
              }  
              if(list.get(k).equals("-")){  
                  int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));  
                  list.add(k-1,cha+"");   
                  list.remove(k);   
                  list.remove(k);   
                  list.remove(k);   
                  System.out.println("list--  -后->"+ list); //list--  -后->[2,  ]  
                 k--;  
              }  
          }  
          int sum=Integer.parseInt(list.get(0));  
         return sum;  
     }  
}  

list--->[3, +, 8, ×, 2, /, 9, -, 2,  ]
list--x后->[3, +, 16, /, 9, -, 2,  ]
list--/后->[3, +, 1, -, 2,  ]
list--+后->[4, -, 2,  ]
list--  -后->[2,  ]
最后结果：2

eg2:加密后的QQ号为“6 3 1 75 8 9 2 4”，现在按照以下规则解密，规则是这样的：首先将第1个数删除，紧接着将第2个数放到这串数的末尾，再将第3个数删除并将第4个数再放到这串数的末尾，再将第5个数删除……直到剩下最后一个数，将最后一个数也删除。按照刚才删除的顺序，把这些删除的数连在一起就是原始QQ号啦，解密后的号码为615947283

package com.sheepmu;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/**** 
 * @author sheepmu 
 
 */  
public class ArrayListTest {  
     public static void main(String[] args){  
         List<Integer> list0=new ArrayList<Integer>();
         List<Integer> list1=new ArrayList<Integer>();
         list0.add(6);
         list0.add(3);
         list0.add(1);
         list0.add(7);
         list0.add(5);    
         list0.add(8);
         list0.add(9);
         list0.add(2);
         list0.add(4);
         while(list0.size()>0){
        	 if(list0.size()==1){//注意只剩一个时的特殊情况，只把它放到原始号码中，已经没有元素再添加到末尾了。
        		 list1.add(list0.remove(0));
        	 }
        	 else{
        		 list1.add(list0.remove(0));
        		 list0.add(list0.remove(0));
        	 }
         }
         System.out.println(list1);
     }  
    
}  

[6, 1, 5, 9, 4, 7, 2, 8, 3]