如何由数组a和数组b得到数组c？
int [] a = {10,20,30};
  int [] b ={10,20,40,50,60};
  int [] c = {30,40,50,60};
谁给写一下啊？？

这么简单，用for循环，把数组A里面的元素和数组B里面的元素挨个进行判断，如果两者没有相等的元素就写入B，否则什么也不做就可以了

这是不是就是去掉A和b中相同的元素ba?可以通过数组的遍历吧

李涛涛 发表于 2012-3-30 14:00
这么简单，用for循环，把数组A里面的元素和数组B里面的元素挨个进行判断，如果两者没有相等的元素就写入B， ...

嗯 我用ArrayList做的 也能做出来 但是挺麻烦的

把数组a和b分别转换成collection集合，然后用retainAll()方法，即可得到数组c的中的所有元素的集合，把这个集合转换成速度就行了

我的思路：
对a来一个循环，每一个元素到b中逐一比较,找到了,将a和b中两位置的值全置为-1.
然后来一次循环,一次将a,b中的非-1值存到一个StringList中,
最后循环取出TStringList中的值,放到数组c中.
希望对你有帮助

李涛涛 发表于 2012-3-30 14:00
这么简单，用for循环，把数组A里面的元素和数组B里面的元素挨个进行判断，如果两者没有相等的元素就写入B， ...

大哥 要不你写下，你说的方法我还是没做出来。。。

retainAll()不合，我用removeAll的：

1. public static void main(String[] args) {
   
2.         Integer [] a = {10,20,30};
   
3.         Integer [] b ={10,20,40,50,60};
   
4.         List la=Arrays.asList(a);               
   
5.         List lb=Arrays.asList(b);
   
6.         List l1 = new ArrayList(la);
   
7.         List l2 = new ArrayList(lb);
   
8.         List l3 = new ArrayList(la);
   
9.         List l4 = new ArrayList(lb);
   
10.         // Collection c1=(Collection)la;
    
11.         // Collection c2=(Collection)lb;
    
12.         l1.removeAll(l2);
    
13.         l4.removeAll(l3);
    
14.         for(Object l:l4)
    
15.                 l1.add(l);
    
16.         System.out.println(l1);
    
17. }

复制代码

黄秋 发表于 2012-3-30 18:35
retainAll()不合，我用removeAll的：

int[]不是integer[]。不过你的代码很简洁。

1. /*
   
2. 思路就是将int数组转为list，然后使用list的将list集合去除两个list集合的交集，以及将两个list集合相结合的方法
   
3. 就是先求a去除a和b的交集10，20后只剩30，b去除和b的交集10，20后只剩40,50,60，然后将两个集合合并，然后再将list转回int数组
   
4. */
   
5. import java.util.*;
   
6. class  ComABC
   
7. {
   
8.         //int数组转list方法
   
9.         public static  ArrayList Int2List(int[] arr)
   
10.         {
    
11.                 ArrayList li=new ArrayList();
    
12. 
    
13.                 for (int x=0;x<arr.length ;x++ )
    
14.                 {
    
15.                         li.add(new Integer(arr[x]));
    
16.                 }       
    
17.                
    
18.                 return li;
    
19.         }
    
20.         //list集合转int数组方法
    
21.         public static  int[] List2Int(List list)
    
22.         {
    
23.                 int[] arr=new int[list.size()];
    
24. 
    
25.                 for (int x=0;x<list.size() ;x++ )
    
26.                 {
    
27.                         arr[x]=(int)list.get(x);
    
28.                 }       
    
29.                
    
30.                 return arr;
    
31.         }
    
32. 
    
33.         public static void main(String[] args)
    
34.         {
    
35.                 int [] a = {10,20,30};
    
36.                 int [] b ={10,20,40,50,60};
    
37. 
    
38.                 /*原来是在转为list后定义list临时集合，但是可能是因为list是对象的引用，
    
39.                 即使将list集合lia赋予临时list集合litemp，但是lia改变后，litemp临时集合随着改变，无法起到临时集合的作用，
    
40.                 所以先在int数组阶段定义一个和a相同的临时数组
    
41.                 */
    
42.                 int [] temp=a;
    
43. 
    
44.                
    
45.                
    
46.                 //数组转list
    
47.                 ArrayList lia=Int2List(a);
    
48.                 ArrayList lib=Int2List(b);
    
49.                 ArrayList litemp=Int2List(temp);
    
50.                
    
51. 
    
52.                
    
53.                 //10,20,30去除交集10,20,变为30
    
54.                 lia.removeAll(lib);
    
55.                 //10,20,40,50,60去除交集10,20,变为40,50,60
    
56.                 lib.removeAll(litemp);
    
57. 
    
58.                 //30和40,50,60结合
    
59.                 lia.addAll(lib);
    
60. 
    
61.                 //list转数组
    
62.                 int[] c=List2Int(lia);
    
63. 
    
64.                 //数组转为字符串
    
65.                 String str=Arrays.toString(c);
    
66.                 //打印
    
67.                 System.out.println(str);
    
68. 
    
69. 
    
70.         }
    
71. 
    
72.        
    
73. 
    
74. }
    

复制代码

我的确实只适用Integer[]，思想都是先转为List（由于我的用了增强型for 循环，所以显得简洁）,再处理，现改写了：

1. public static void main(String[] args) {
   
2.         int[] a = {10,20,30};
   
3.         int[] b ={10,20,40,50,60};
   
4.         List la=new ArrayList();
   
5.         List lb=new ArrayList();
   
6.         for(Object i:a)        la.add(i);
   
7.         for(Object i:b)        lb.add(i);
   
8.        
   
9.         List temp=new ArrayList(la);
   
10.         la.removeAll(lb);
    
11.         lb.removeAll(temp);
    
12.         la.addAll(lb);
    
13.         Object[] arr=la.toArray();
    
14.         System.out.println(Arrays.toString(arr));
    
15. }

复制代码

1.   int [] a = {10,20,30};
   
2.         int [] b ={10,20,40,50,60};
   
3.         int [] c = new int[4];
   
4.         c[0]=a[2];
   
5.         c[1]=b[2];
   
6.         c[2]=b[3];
   
7.         c[3]=b[4];

复制代码

这样不就是从a b 两数组得到c数组吗 不用那么麻烦吧