是JDK 1.6中的IntStream类？

Question

Is there any other class which and be use like java.util.stream.IntStream (of java 8) in java 6

I wanted to achieve

  List<Integer> list = IntStream.of(intArray).boxed().collect(Collectors.toList());

how it is possible in java 6 or below

Answer 1

No, there's no simple way to do this in JDK6, that's exactly why they added it in JDK8.

You can either:

1. iterate over the int array and add the numbers one by one to the new collection

    int[] intArray = { 1,2,3 }; List<Integer> ints = new ArrayList<>(intArray.length); for (int i : intArray) { ints.add(i); } 

2. or you can reach out for a library to do this for you. For example, Guava does this pretty well: Ints.asList()

Answer 2

If all you want is to convert an int[] into an List<Integer>

you can either:

create your own ArrayList and add the elements manually

    List<Integer> list = new ArrayList<Integer>(intArray.length);
    for(int value : intArray){
        list.add(value);
    }

Or you can easily write your own class that implements List using an primitive array backing:

public final class IntArrayList extends AbstractList<Integer> implements RandomAccess {

    private final int[] array;


    public IntArrayList(int[] array) {
        this.array = array;
    }

    @Override
    public Integer get(int index) {
        return array[index];
    }

    @Override
    public int size() {
        return array.length;
    }

    @Override
    public Integer set(int index, Integer element) {
        Integer old = array[index];
        array[index] = element.intValue();
        return old;
    }

    public int indexOf(Object o) {
       if(o==null){
           return -1;
       }
       if(!(o instanceof Integer)){
           return -1;
       }
       int val = ((Integer)o).intValue();

        for (int i=0; i<array.length; i++){
            if (val==array[i]){
                return i;
            }
        }
        return -1;
    }

    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }
    /**
     * Optimization of equals since
     * we know we are have an array of ints
     * this should reduce boxing/unboxing
     * on our end at least.
     */
    @SuppressWarnings("rawtypes")
    public boolean equals(Object o) {
        if (o == this){
            return true;
        }
        if (!(o instanceof List)){
            return false;
        }

        int currentOffset=0;
        ListIterator e2 = ((List) o).listIterator();
        while(currentOffset<array.length && e2.hasNext()) {
            Object o2 = e2.next();
            //will return false if o2 is null
            if(!(o2 instanceof Integer)){
                return false;
            }
            if(array[currentOffset] !=((Integer)o2).intValue()){
                return false;
            }
            currentOffset++;
        }
        return !(currentOffset<array.length || e2.hasNext());
        }

        /**
         * Optimization of hashcode since
         * we know we have an array of ints.
         */
        public int hashCode() {
            return Arrays.hashCode(array);
        }

}

And then it's just

 List<Integer> list = new IntArrayList(intArray);