我要到HashSet中添加10000个不同的数组，能指教下吗？

Question

我要到HashSet中添加10000个不同的数组，那个能帮助下？提供下思路，最好能搞点代码什么的？

Answer 1

楼上你看这里http://topic.csdn.net/u/20110831/18/601e1eca-1ea1-4994-819e-b3a1570178ea.html，是问题的关键，我想你知道的

Answer 2

你认为数组内容相同，就表述数组相同？，如果是这样的话，你得重写hashcode方法

Answer 3

- -不是已经说的很明白了 
重写hashCode和equals方法保证如果内容相同的话hashCode相同和equals返回true就行了

Answer 4

就是我随机产生数个长度相同的数组，例如：产生{1,2}{2,1}
上面的数组，不一样，但储存的值是一样，我不想放入HashSet中。怎么避免或过滤？

Answer 5

那就稍微麻烦点。。
hashCode可能好说点，你可以把每个Int值的hashCode得到，然后通过什么样的一堆运算返回一个hashCode值
如果运算没有权重的话那么数组元素相同应该返回的值是相同的
equals方法那你得两个for循环，遍历是否存在，而且你这种要判断相等还有个问题就是相同元素的个数，当然这是你自己制定规则，想怎么实现equals方法得根据你的规则来写

Answer 6

import java.util.HashSet;
public class MySet extends HashSet{
public int hashCode() {
int h = 0;
Iterator<E> i = iterator();
while (i.hasNext()) {
    E obj = i.next();
            if (obj != null)
                h += obj.hashCode();
        }
return h;
    }}
对吗？

Answer 7

大致意思是这样，不过你这里只能传Integer，泛型不支持原生数据类型

Answer 8

这样迭代出来的不是数组吗？
obj.hashCode()不就是某个数组的哈希编码吗？
这样好像不对呀？

Answer 9

给你写了一个实例，这里获取100个 MyArray，里面封装了长度为2的数组数据
你改一下具体的参数就可以了，10000个我电脑跑的很慢
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;//import java.util.Random;/**
 * Created by IntelliJ IDEA.
 * User: Administrator
 * Date: 2011-8-31
 * Time: 20:09:35
 * To change this template use File | Settings | File Templates.
 */
public class MyArray {    public int[] getNum() {
        return num;
    }    private int[] num=null;    public static MyArray getRandomInstance(){
          return  new MyArray();
    }    private MyArray(){
        num=new int[2];
        for(int i=0;i<num.length;i++){
              num[i]= (int)(Math.random()*100);
        }
//        System.out.println(num[0]);
//        System.out.println(num[1]);
//        this.num=num;    }    /**
     * 如果数组长度不是2，可以用这个方法，同时重新toString方法
     * @param aryLength
     */
    private MyArray(int aryLength){
        num=new int[aryLength];
        for(int i=0;i<num.length;i++){
              num[i]= (int)Math.random()*10;
        }    }
    public String toString(){
        return num[0]+","+num[1];
    }    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof MyArray)) return false;        MyArray myArray = (MyArray) o;        if (!Arrays.equals(num, myArray.num)) return false;        return true;
    }    @Override
    public int hashCode() {
        return num != null ? Arrays.hashCode(num) : 0;
    }    public static void main(String[] args){
         Set<MyArray> set=new HashSet<MyArray>();
         for(int i=0;set.size()<=100;i++){
             set.add(MyArray.getRandomInstance());
//             System.out.println(i);
         }        for(MyArray s:set){
              System.out.println(s);
        }
    }
}

Answer 10

迭代出来是数组中的每个对象，如果这些对象在你规则下hashCode值是相同的就行了，你也可以不用这样写撒
不一定非得调用对象的hashCode值，比如如果是Integer你就直接把所有值加起来返回都可以
hashSet里面添加的方法不是仅仅用到hashCode的，还要用equals

Answer 11

就按LS的思路，重写hashCode和equals，把随机生成的数组做个排序再比较
public class Test {
    public static void main(String[] args) {
        Set<RandomArray> set = new HashSet<RandomArray>();
        while (set.size() < 10000) {
            set.add(new RandomArray(3, 100));
        }
    }
}class RandomArray {
    private int[] array;
    public RandomArray(int len, int seed) {
        array = new int[Math.max(len, 0)];
        for (int i=0; i<len; i++) {
            array[i] = (int)(Math.random()*seed);
        }
    }
    public boolean equals(Object o) {
        if (o != null && 
            o.getClass() == RandomArray.class &&
            o.getArray().length == array.length) {
            int[] a1 = Arrays.copyOf(array, array.length);
            int[] a2 = Arrays.copyOf(o.getArray(), o.getArray().length);
            Arrays.sort(a1);
            Arrays.sort(a2);
            return(Arrays.equals(a1, a2));
        }
        return false;
    }
    public int hashCode() {
        int v = 0;
        for (int i=0; i<array.length; i++) {
            v += array[i];
        }
        return v;
    }
    publit int[] getArray() {return array;}
}
不过10000个，效率可能有问题，用组合的方法把数组组合好，然后随机抽取10000个，可能会好一点
public class Test {
    public static void main(String[] args) {
        List<List<Inteer>> list = combine(100, 3);
        Set<int[]> set = new HashSet<int[]>();
        for (int i=0; i<10000; i++) {
            List<Integer> l = list.remove((int)(Math.random()*list.size()));
            int[] a = new int[l.size()];
            for (int j=0; j<l.size(); j++) {
                a[j] = l.get(j);
            }
            set.add(a);
        }
    }    public static List<List<Integer>> combine(int n, int m) { //从1到n的数中取m个数组合
        if (m > n) {m = n;}
        int[] num = new int[n];
        for (int i=0; i<n; i++) {
           num[i] = i+1;
        }
        int[] dig = new int[num.length];
        for (int i=0; i<num.length; i++) { 
            dig[i] = (i<num.length-m) ? 0 : 1;
        }
        List<List<Integer>> result = new LinkedList<List<Integer>>();
        while (true) { 
            int cnt=0, end=0;
            for (int i=0; i<dig.length; i++) {
                if (dig[i] == 1) {
                    cnt++;
                    if (i<m) {end++;}
                }
            }
            if (cnt == m) { 
                List<Integer> list = new LinkedList<Integer>();
                for (int i=0; i<num.length; i++) {
                    if (dig[i] == 1) {list.add(num[i]);}
                }
                result.add(list);
            }
            if (end == m) {break;}            dig[dig.length-1]++;
            for (int i=dig.length-1; i>0; i--) {
                if (dig[i] == 2) {
                    dig[i] = 0;
                    dig[i-1]++; 
                } else {
                    break; 
                }
            }
        }
        return result;
    }
}

Answer 12

import java.util.*;
class IntArray {
    int[] a;
    public IntArray(int[] a) {
this.a = a;
    }
    public boolean equals(Object o) {//比较规则是：int[]型数组之间的每一个元素对应相等，两数组就相等
if (!(o instanceof IntArray)) {//如果对象类型不同，不是数组
         return false;
}
IntArray temp = (IntArray) o;
if (temp == null || temp.a.length != a.length) {//如果数组对象为空，或者长度不一致
        return false;
}
for (int i = 0; i < a.length; i++)
    if (a[i] != temp.a[i]) {//如果至少有一对整数不相等
return false;
    }
return true;
    }
    public String toString() {
return Arrays.toString(a);
    }
    public int hashCode() {//重写hashcode方法
return a==null ? 0:a.length;
    }
}public class TestOverrideHashcode {
    static Set<IntArray> set = new HashSet<IntArray>();
    static void add(int[] a){
set.add(new IntArray(a));
    }
    static void print() {//打印set中的信息
Iterator<IntArray> it = set.iterator();
while (it.hasNext()) {//现在无任何东西
    System.out.println(it.next());
}
    }
    public static void main(String[] args) {
print();//打印信息为空

add(new int[]{0,1});
add(new int[]{1,3});
add(new int[]{2,1});
add(new int[]{3,4}); //添加四个不同的数组打印信息
System.out.println("第一次打印：");
print();

add(new int[]{0,1});
add(new int[]{1,3});
add(new int[]{2,1});
add(new int[]{3,4});

//添加与上面个“相同”的数组打印信息，这里的相同是数组的内容对应相同，而不是内存地址相同
System.out.println("第二次打印：");
print();//结果跟上面一摸一样 for(int i=0; i<10000;i++) {
    add(new int[]{i,i});
}
System.out.println("此时set中元素个数：" + set.size()); for(int i=0; i<10000;i++) {
    add(new int[]{i,i});
}
System.out.println("添加1000个‘重复元素’后，此时set中元素个数：" + set.size());
    }
}
/*output:
第一次打印：
[3, 4]
[2, 1]
[1, 3]
[0, 1]
第二次打印：
[3, 4]
[2, 1]
[1, 3]
[0, 1]
此时set中元素个数：10004
添加1000个‘重复元素’后，此时set中元素个数：10004
*/

Answer 13

 public boolean equals(Object o) {//比较规则是：int[]型数组之间的每一个元素对应相等，两数组就相等
    if (!(o instanceof IntArray)) {//如果对象类型不同，不是数组
                return false;
    }
    IntArray temp = (IntArray) o;
    if (temp == null || temp.a.length != a.length) {//如果数组对象为空，或者长度不一致
               return false;
    }
Arrays.sort(a);
            Arrays.sort(temp);
    for (int i = 0; i < a.length; i++)
        if (a[i] != temp.a[i]) {//如果至少有一对整数不相等
        return false;
        }    
    return true;
    }
楼上的增加红色部分就可以，过滤数组内容相同，顺序不同的数组了。
谢谢各位了。

Answer 14

Arrays.sort(a);
            Arrays.sort(temp);
修改为Arrays.sort(a);
Arrays.sort(temp.a);

Answer 15

如果你不在乎数组中元素的顺序，你就把红色部分添加到for循环之前吧