有道题目大家帮忙做下吧！

[changml0929]

6个字符串数组对象，每个数组分别存放200个元素，写一个方法找出6个对象中相同的元素并放在一个向量对象中！

[hmsuccess]

我可以给你算法，但是具体还是你自己写，这样才能锻炼自己

[changml0929]

[Quote=引用 7 楼 hmsuccess 的回复:]
我可以给你算法，但是具体还是你自己写，这样才能锻炼自己
[/Quote]
哦！好吧！谢谢！

[michelecindy]

package com.test;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
	
public class jiaoji {
	public static void main(String[] args) throws IOException {
	    Set<Integer> set1 = new HashSet<Integer>();
	    set1.add(1);
	    set1.add(2);
	    set1.add(3);
	    set1.add(4);
	    Set<Integer> set2 = new HashSet<Integer>();
	    set2.add(1);
	    set2.add(2);
	    set2.add(5);
	    set2.add(6);
	    System.out.println("并集");
	    set1.addAll(set2);
	    for (Integer i : set1) {
	      System.out.println(i);
	    }
	    set1 = new HashSet<Integer>();
	    set1.add(1);
	    set1.add(2);
	    set1.add(3);
	    set1.add(4);
	    System.out.println("交集");
	    set1.retainAll(set2);
	    for (Integer i : set1) {
	      System.out.println(i);
	    }
	    set1 = new HashSet<Integer>();
	    set1.add(1);
	    set1.add(2);
	    set1.add(3);
	    set1.add(4);
	    System.out.println("差集");
	    set1.removeAll(set2);
	    for (Integer i : set1) {
	      System.out.println(i);
	    }
	  }	
}

这个你可以参考下

[anqini]

package B;

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

import A.a;

public class b extends a {

    public static void main(String[] args) {
        List<String> l1 = new ArrayList<String>();
        List<String> l2 = new ArrayList<String>();
        List<String> l3 = new ArrayList<String>();
        List<String> l4 = new ArrayList<String>();
        List<String> l5 = new ArrayList<String>();
        List<String> l6 = new ArrayList<String>();
        String[] s1 = {"a", "b", "c", "d"};
        String[] s2 = {"a", "b", "g", "m"};
        String[] s3 = {"a", "j", "v", "d"};
        String[] s4 = {"a", "g", "v", "d"};
        String[] s5 = {"a", "y", "c", "z"};
        String[] s6 = {"a", "d", "e", "v"};
        for (String s : s1) {
            l1.add(s);
        }
        for (String s : s2) {
            l2.add(s);
        }
        for (String s : s3) {
            l3.add(s);
        }
        for (String s : s4) {
            l4.add(s);
        }
        for (String s : s5) {
            l5.add(s);
        }
        for (String s : s6) {
            l6.add(s);
        }
        l1.retainAll(l2);
        l1.retainAll(l3);
        l1.retainAll(l4);
        l1.retainAll(l5);
        l1.retainAll(l6);

        System.out.println(l1);
    }

}

[hmsuccess]

[Quote=引用 5 楼 hmsuccess 的回复:]
Java code
ArrayList[] arrayLists = new ArrayList[6];
ArrayList<String>[] data1 = arrayLists;



然后用二分搜索就可以
[/Quote]
对了，你这个不仅仅是搜索，还的整个遍历，会错意思了，不好意思

[hmsuccess]

二分搜索也必须是对已经排好序的进行搜索比较快，

[huxinyu929]

for循环用Set比较。逐个求交！

。。。。。

[huxinyu929]

void f1（a,b）{
String[] a = {"1","2","3","4"};
String[] b = {"3","4","5","6"};
Set s = new HashSet(Arrays.asList(a));
s.retainAll(Arrays.asList(b));
}

for(.......){
.......
........
......
f1(a,b);
}

[云上飞翔]

[Quote=引用 10 楼 anqini 的回复:]
Java code

public static void main(String[] args) {
List<String> l1 = new ArrayList<String>();
List<String> l2 = new ArrayList<String>();
List<String> l3 = new ArrayList<String>();
List<String> l4 = new ArrayList<String>();

l1.retainAll(l2);
l1.retainAll(l3);
l1.retainAll(l4);
l1.retainAll(l5);
l1.retainAll(l6);


[/Quote]
答：使用retainAll（。。。）性能是比较差的。这个程序的做法是这道题许多方法中比较差的一种。反复使用了ArrayList中的retainAll（...），，因为：retainAll()本身是一个双重循环，而且还要在双重循环内部对ArrayList进行元素删除后的前后搬家式移动。

我认为不可取！

[云上飞翔]

[Quote=引用 10 楼 anqini 的回复:]
Java code

public static void main(String[] args) {
List<String> l1 = new ArrayList<String>();
List<String> l2 = new ArrayList<String>();
List<String> l3 = new ArrayList<String>();
List<String> l4 = new ArrayList<String>();

l1.retainAll(l2);
l1.retainAll(l3);
l1.retainAll(l4);
l1.retainAll(l5);
l1.retainAll(l6);


[/Quote]
答：使用retainAll（。。。）性能是比较差的。这个程序的做法是这道题许多方法中比较差的一种。反复使用了ArrayList中的retainAll（...），，因为：retainAll()本身是一个双重循环，而且还要在双重循环内部对ArrayList进行元素删除后的前后搬家式移动。

我认为不可取！

[云上飞翔]

答：对不起。怎么弄了两份出来了？
而且：retainAll()在双重循环内部是对ArrayList进行的无序查找。
我想：程序不仅仅功能达到，性能应该要考虑到。

[y7997883]

List1
List2
List3
List4
List5
List6

List1
List2
中的数据放到List1All中，在放到Set1All中，由于Set1All是Set类型的，List1All-Set1All所得即为List1和List2的公共数据
同理，List2All-Set2All所得即为List3和List4的公共数据
同理，List3All-Set3All所得即为List5和List6的公共数据
List1All，List2All，List3All中剩下的数据，继续上面的步骤，即可得到6个集合的公共数据

[zhu314175802]

String[] s1=new String[200];
String[] s2=new String[200];
String[] s3=new String[200];
String[] s4=new String[200];
String[] s5=new String[200];
String[] s6=new String[200];
// String[] s={"ff","ff","ffd"};
//构造个a来存放所有的元素
List<String> a=new ArrayList<String>();
for(String str:s1){
a.add(str);
}
for(String str:s2){
a.add(str);
}
for(String str:s3){
a.add(str);
}
for(String str:s4){
a.add(str);
}
for(String str:s5){
a.add(str);
}
for(String str:s6){
a.add(str);
}
//对它进行升序排列
Collections.sort(a);
//用来存放相同的元素
Set<String> s=new HashSet<String>();
for(int ii=0;ii<a.size()-1;ii++){
if(a.get(ii).equals(a.get(ii))){
s.add(a.get(ii));
}
}
//把它放到Vector里
Vector<String> v=new Vector<String>(s);

如果在一个数组中已经有相同了的话用交集会不会有点问题 ！！！！

[hmsuccess]

[Quote=引用 17 楼 jiangnaisong 的回复:]
答：对不起。怎么弄了两份出来了？
而且：retainAll()在双重循环内部是对ArrayList进行的无序查找。
我想：程序不仅仅功能达到，性能应该要考虑到。
[/Quote]
这个我同意
就这个题来说，如果先排序，又增加了开销

[qinqinhao]

学习

[sniperhuangwei]

将6个向量全部合成到一个向量中,排续.
然后就做一次遍历,寻找那些存在连续重复的元素.

[sniperhuangwei]

忽略字符串的比较时间,和成一个字符号串的时间复杂度是O(n),排序是o(logn),最后做一次线性查找.总复杂度是o(logn)

[AwL_1124]

up··········

[wangjiajuan]

楼主，你说得是：6个对象数组中都要相同得元素，还是两个相同就算。

[Charlemagne]

[Quote=引用楼主 changml0929 的帖子:]
6个字符串数组对象，每个数组分别存放200个元素，写一个方法找出6个对象中相同的元素并放在一个向量对象中！
[/Quote]

我也贴一个方法：
使用HaspMap，将字符串存放其中。key和value分别对应字符串和字符串的个数。
向map里添加字符串的时候，首先查找一该string为key的pair，如果存在，取出存放该字符串出现次数的Integer，并加1后放回；如果不存在，这说明该string是第一次出现，这把该string和值为1的Integer存入map中。
全部添加完成后，只需遍历map，查找Integer值等于6的pairs即可。

代码如下：

package test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Main {    
    
    private HashMap<String,Integer> map=new HashMap<String,Integer>();
    private String[][] data={{"a", "b", "c", "d"},
                             {"a", "b", "g", "m"},
                             {"a", "j", "b", "d"},
                             {"a", "g", "b", "d"},
                             {"a", "b", "c", "z"},
                             {"a", "b", "e", "v"}};
  
    public void process(){
        String tmp;
        for(int i=0;i<data.length;i++){
            for(int j=0;j<data[0].length;j++){
                tmp=data[i][j];
                Integer count=map.get(tmp);
                if(count==null)
                    map.put(tmp, new Integer(1));
                else{
                    count++;
                    map.put(tmp, count);
                }                
            }
        }
        Set entry=map.keySet();
        Iterator i=entry.iterator();
        while(i.hasNext()){
            String key=(String) i.next();
            Integer count=map.get(key);
            if(count==6){
                System.out.println(key);
            }
        }        
    }   
    public static void main(String[] args) {
        // TODO code application logic here
        Main f=new Main();
        f.process();
    }
}