定义集合A:["2007",2008] , B["20071555","20089087","20081234","20200801"],
然后在B中找出前4位与集合A中相同的字符串
将找出的字符串以键值对（A:key,B:value）的方式保存.

循环B集合
拿到B的的各个元素，并截取前4位
判断a集合里是否包含截取出来的字符串，这个ArrayList是有提供方法的
如果存在，就将截取出来的字符串当做key，将直接从b取出的元素作为value，保存进提前定义的HashMap集合中

:o
就是一个嵌套循环，内部插入一个 map集合
遍历 A集合，取字符串，截取前四 记为 stra
{
    遍历b 集合
    {     取键的，截取前四 记为 strb
    判断strb==stra
     是 ( key A , value B )存入map C

     }
}
输出C

1. public static void main(String[] args) {
   
2.                 ArrayList<String> listA = new ArrayList<String>();
   
3.                 listA.add("2008");
   
4.                 listA.add("2007");
   
5.                
   
6.                 ArrayList<String> listB = new ArrayList<String>();
   
7.                 listB.add("20089087");
   
8.                 listB.add("20081234");
   
9.                 listB.add("20200801");
   
10.                 listB.add("20071555");
    
11.                
    
12.                 ListIterator<String> itA = listA.listIterator();
    
13.                 ListIterator<String> itB = listB.listIterator();
    
14.                
    
15.                 HashMap<String, String> C = new HashMap<String, String>();
    
16.                
    
17.                 for(String b :listB){
    
18.                         for(String a :listA){
    
19.                                 if(b.startsWith(a)){
    
20.                                         C.put(a, b);
    
21.                                 }
    
22.                         }
    
23.                 }
    
24.         }

复制代码

但是很奇怪，为什么用迭代器遍历的方式行不通

edithe 发表于 2015-5-29 15:37
但是很奇怪，为什么用迭代器遍历的方式行不通

:o 遍历的List 集合么？

微凉的暮色 发表于 2015-5-29 15:40
遍历的List 集合么？

是的，本来以为是跟String类型的内存结构有关，后来一想又不对，不知道是什么问题

1.                 while(itB.hasNext()){
   
2.                         String B= itB.next();                       
   
3.                         while(itA.hasNext()){
   
4.                                 if(B.startsWith(itA.next())){
   
5.                                         System.out.println(B);
   
6.                                 }
   
7.                         }
   
8.                 }

复制代码

上面这个代码不知道什么问题

1. ArrayList<String> a = new ArrayList<String>();
   
2.                 a.add("2007");
   
3.                 a.add("2008");

复制代码

1. import java.util.ArrayList;
   
2. import java.util.HashMap;
   
3. import java.util.Iterator;
   
4. import java.util.Map;
   
5. import java.util.Map.Entry;
   
6. import java.util.Set;
   
7. 
   
8. /*定义集合A:["2007","2008"] , B["20071555","20089087","20081234","20200801"],
   
9. 然后在B中找出前4位与集合A中相同的字符串
   
10. 将找出的字符串以键值对（A:key,B:value）的方式保存.*/
    
11. public class MapTest0 {
    
12.         public static void main(String[] args){
    
13.                 HashMap<String, String> m = new HashMap<String, String>();
    
14.                 ArrayList<String> a = new ArrayList<String>();
    
15.                 a.add("2007");
    
16.                 a.add("2008");
    
17.                 ArrayList<String> b = new ArrayList<String>();
    
18.                 b.add("20071555");
    
19.                 b.add("20089087");
    
20.                 b.add("20081234");
    
21.                 b.add("20200801");
    
22.                 for (int i = 0; i < 2; i++) {
    
23.                         for (int j = 0; j < 4; j++) {
    
24.                                 if(compareTo(a.get(i), b.get(j))){
    
25.                                         m.put(a.get(i), b.get(j));
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.                 Set entryset = m.entrySet();
    
30.                 Iterator iterator  = entryset.iterator();
    
31.                 for (Object object : entryset) {
    
32.                         Map.Entry entry = (Entry)object;
    
33.                         System.out.println(entry.getKey()+"="+entry.getValue());
    
34.                 }
    
35.                
    
36.         }
    
37.         static boolean compareTo(String s1,String s2){
    
38.                 boolean bl = false ;
    
39.                 if (s1.charAt(0)==s2.charAt(0)&&s1.charAt(1)==s2.charAt(1)&&s1.charAt(2)==s2.charAt(2)&&s1.charAt(3)==s2.charAt(3)) {
    
40.                         bl = true;
    
41.                 }
    
42.                 return bl;
    
43.         }
    
44.        
    
45. }
    

复制代码

结果：
2008=20081234
2007=20071555

edithe 发表于 2015-5-29 15:48
是的，本来以为是跟String类型的内存结构有关，后来一想又不对，不知道是什么问题
上面这个代码不知道什 ...

问题出在嵌套循环里用itA.hasNext(),当B中的第一个元素把A中的所有元素都遍历一次的时候，指针已经到了A集合尾部下个元素为空，必须让指针重新回到A集合头部才可以再次遍历A集合

edithe 发表于 2015-5-29 15:48
是的，本来以为是跟String类型的内存结构有关，后来一想又不对，不知道是什么问题
上面这个代码不知道什 ...

╮(╯▽╰)╭无奈

.......我在另一个帖子里看到了~~~~


ackage jihekuangjia;
import java.util.*;
class jihekuangjia_test1
{
        public static void main(String[] args) {            
            ArrayList<String> listB = new ArrayList<String>();
            listB.add("20089087");
            listB.add("20081234");
            listB.add("20050801");
            listB.add("20071555");

            ListIterator<String> itB = listB.listIterator();
            
            while(itB.hasNext())
            {
                    String B= itB.next();  
                    ArrayList<String> listA = new ArrayList<String>();
                        listA.add("2008");
                        listA.add("2007");
                        ListIterator<String> itA = listA.listIterator();
                    
                    while(itA.hasNext())
                    {
                         String A = itA.next();
                                if(B.startsWith(A))
                               {
                                    System.out.println(B);
                               }
                                
                    }
            }
        }
}

表示应该成功了 输出的结果是三个 ：
20089087
20081234
20071555

这个是用迭代器搞得 后面的应该都差不多了    和楼上说的一样   是指针问题 ，所以我是每次都重新搞了个集合来搞定这个至真问题，也许有专门的方法吧 不过老夫不会 额~~~~~