How to convert an object array into a custom type array (involving Array List)

Question

What I am trying to do is to find the intersection of two sets using a custom type IntSet . The code is compiling fine, however when I run it, it throws an ArrayStoreException . From what I gather, the problem is trying to convert the object array into IntSet . Here is the code:

    public IntSet[] intersection(Integer[] s1, Integer[] s2) {
    Arrays.sort(s1);//sort arrays
    Arrays.sort(s2);
    IntSet[] s3;
    int s1index = 0;//initalise index and counters
    int s2index = 0;

    while (s1index < s1.length && s2index < s2.length) {
        if (s1[s1index] == s2[s2index]) {//if present in both arrays
            al.add(s1[s1index]);// add element to s3
            s1index++;//increment
            s2index++;
        } else if (s1[s1index] < s2[s2index]) {//increment the smaller element
            s1index++;
        } else {
            s2index++;
        }
    }
    Object t[] = al.toArray();//convert to array
    **s3 = Arrays.copyOf(t, t.length, IntSet[].class);**//convert to intSet//exception thrown here
    return s3;

Full code here:

public class IntSet {

/**
 * @param args the command line arguments
 */
/*
 * SPECIFICATIONS: 1.addElement(elem) adds a new element to the set Pre:
 * integer elem != any other element in the set Post: NUMBER_ADDED returned
 * if not already present, NUMBER_ALREADY_IN_SET if it is.
 *
 * 2.removeElement(elem) removes an element from the set Pre: integer elem
 * is already in set Post: NUMBER_REMOVED returned if present,
 * NUMBER_NOT_IN_SET if not.
 *
 * 3.intersection(s1,s2) returns the intersection of two sets Pre: two
 * integer arrays s1 and s2 Post: array containing the elements common to
 * the two sets, empty set if there is nothing in common
 *
 * 4.union(s1,s2) returns the union of two sets Pre: two integer arrays s1
 * and s2 Post: array of non-duplicate elements present in both arrays.
 *
 * 5.difference(s1,s2) returns elements that are in s1 but not in s2 Pre:
 * two integer arrays s1 and s2 Post: random double number D generated,
 * where min < D < max
 *
 */
public static final int NUMBER_ADDED = 0;
public static final int NUMBER_ALREADY_IN_SET = 1;
public static final int NUMBER_REMOVED = 2;
public static final int NUMBER_NOT_IN_SET = 3;
private ArrayList<Integer> al = new ArrayList<Integer>();//creates new array list

IntSet(ArrayList<Integer> source) {
    al.addAll(source);
}

/**
 * Adds an element to a set see top for specifications
 *
 * @param elem element to be added
 * @return NUMBER_ADDED if valid, NUMBER_ALREADY_IN_SET if not
 */
public int addElement(int elem) {
    if (!al.contains(elem)) {
        return NUMBER_ALREADY_IN_SET;
    }
    al.add(elem);
    return NUMBER_ADDED;
}

/**
 * Removes the element from the set See top for specification
 *
 * @param elem element to be removed
 * @return NUMBER_REMOVED if valid, NUMBER_NOT_IN_SET if not
 */
public int removeElement(int elem) {

    if (!al.contains(elem)) {
        return NUMBER_NOT_IN_SET;
    }
    al.remove(elem);
    return NUMBER_ADDED;
}

/**
 * Finds the intersection of two arrays see top for ADT specification
 *
 * @param s1 first array
 * @param s2 second array
 * @return s3 combined array
 */
public IntSet intersection(Integer[] s1, Integer[] s2) {
    Arrays.sort(s1);//sort arrays
    Arrays.sort(s2);
    IntSet s3;
    ArrayList<Integer> intersect = new ArrayList<Integer>();
    int s1index = 0;//initalise index and counters
    int s2index = 0;

    while (s1index < s1.length && s2index < s2.length) {
        if (s1[s1index] == s2[s2index]) {//if present in both arrays
            al.add(s1[s1index]);// add element to s3
            s1index++;//increment
            s2index++;
        } else if (s1[s1index] < s2[s2index]) {//increment the smaller element
            s1index++;
        } else {
            s2index++;
        }
    }
    s3 = new IntSet(al);
    return s3;

}

/**
 * Finds the union of two arrays see top for ADT specification
 *
 * @param s1 first array
 * @param s2 second array
 * @return united array (s4)
 */
public IntSet union(Integer[] s1, Integer[] s2) {
    Arrays.sort(s1);//sort arrays
    Arrays.sort(s2);
    IntSet s3;//initialise arrays
    ArrayList<Integer> union = new ArrayList<Integer>();//creates new array list
    int counter = 0;


    for (int i = 0; i < s1.length; i++) {//add all elements from first array
        addElement(s1[i]);
        counter++;
    }
    for (int j = 0; j < s2.length; j++) {//check second array...
        boolean contains = false;
        for (int i = 0; i < s1.length; i++) { //...with first 
            if (union.contains(s2[j])) { //if you have found a match   
                contains = true; //flag it  
                break; //and break  
            }
        } //end i  
        //if a match has not been found, print out the value  
        if (!contains) {
            addElement(s2[j]);
            counter++;
        }


    }//end j  
    s3 = new IntSet(al);
    return s3;
}//end method 

/**
 * Returns elements of first array not present in the second See top for ADT
 * specification
 *
 * @param s1 first array
 * @param s2 second array
 * @return difference array
 */
public IntSet difference(Integer[] s1, Integer[] s2) {

    IntSet result = intersection(s1, s2);//get intersection array
    IntSet s3;
    Arrays.sort(s1);//sort arrays
    ArrayList<Integer> difference = new ArrayList<Integer>();//creates new array list
    for(int i = 0; i < s1.length; i++)
    {
        difference.add(s1[i]);
    }
    for (int i = 0; i < s1.length; i++) {
        if (!difference.contains(result)) {//if not present in second array
            removeElement(s1[i]);//add value to output array
        }
    }
    s3 = new IntSet(al);
    return s3;
}

}

Answer 1

Assuming al is an ArrayList<IntSet> , you could try this:

IntSet[] t = al.toArray(new IntSet[al.size()]);
s3 = Arrays.copyOf(t, t.length);

But t is already a copy, so you could just have

return al.toArray(new IntSet[al.size()]);

---

EDIT : After seeing the rest of your code and thinking more carefully about what you're trying to do...

You probably shouldn't be returning an IntSet[] but rather a single IntSet representing the intersection. ie

return new IntSet(al, new Integer[al.size()]);  // based on constructor you
                                                // provided in IntSet class

Answer 2

From what I can understand of your code, you are trying to create a Set structure of Int, called IntSet . The first problem is the signature of your method. The union of two Integer[] will give you an IntSet not an array of IntSet.

public IntSet intersection(Integer[] s1, Integer[] s2)

The second problem is that you cannot "copy" elements from an array into an IntSet. You need to construct your IntSet object using the class constructor.

At the end of your intersect method, you should have something like this:

IntSet s3 = new IntSet(al);

I don't understand what the array parameter does in the IntSet constructor and why the provided list is copied to it. Your IntSet has its own container. This is the al list of ints that is instantiated with each instance of the class.

Your construction should be something like this:

IntSet(ArrayList<Integer> source) {
    al.addAll(source);
}

---

PS: After reading some of your code, I can advice you to rethink your approach. What you are asked to do is to implement a Set using a List as backing structure. Your conversion from/to array is redundant. For example, using list and list methods, you can implement add like this:

public int addElement(int elem) {
   if (!a1.contains(elem)) return  NUMBER_ALREADY_IN_SET;
   a1.add(elem);
   return NUMBER_ADDED;
} 

Please review the other methods.

Answer 3

IntSet替换为Integer ，一切正常。