Backwards compatibility with Java bytecode editing

import java.util.NoSuchElementException;
// version 1
public final class IntegerIterator {
    private final int[] ints;
    private int i;

    public IntegerIterator(int[] ints) {
        this.ints = ints;
        this.i = 0;
    }

    public int next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return ints[i++];
    }

    public boolean hasNext() {
        return i < ints.length;
    }
}

import java.util.NoSuchElementException;
import java.lang.UnsupportedOperationException;
import java.util.Iterator;
// version 2
public final class IntegerIterator implements Iterator<Integer>{ 
    private final int[] ints;
    private int i;

    public IntegerIterator(int[] ints) {
        this.ints = ints;
        this.i = 0;
    }

    @Override
    public Integer next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return ints[i++];
    }

    @Override
    public boolean hasNext() {
        return i < ints.length;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

public final class Usage1 {
    public static final void main(String[] args) {
        for (IntegerIterator it = new IntegerIterator(new int[]{1, 2, 3}); it.hasNext();) {
            System.out.println(it.next());
        }
    }
}

// version 2.1
public final class IntegerIterator implements Iterator<Integer>{ 
    private final int[] ints;
    private int i;

    public IntegerIterator(int[] ints) {
        this.ints = ints;
        this.i = 0;
    }

    public int next() {
        return next().intValue(); // call to "public Integer next()"
    }

    @Override
    public Integer next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return ints[i++];
    }

    @Override
    public boolean hasNext() {
        return i < ints.length;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

import org.apache.bcel.*;
import org.apache.bcel.classfile.*;
import org.apache.bcel.generic.*;

public final class IntegerIteratorCreator {
    public static final void main(String[] args) throws Exception {  
        JavaClass master = Repository.lookupClass("IntegerIterator"); // version 2

        ClassGen cg = new ClassGen(master);
        InstructionList il = new InstructionList();
        // public int next()
        MethodGen mg = new MethodGen(Constants.ACC_PUBLIC, Type.INT, Type.NO_ARGS, new String[0],
                                     "next", "IntegerIterator", il, cg.getConstantPool());
        InstructionFactory factory = new InstructionFactory(cg);

        // The bytecode instructions for "return next().intValue();"
        // where next() is the next method that returns an Integer.
        il.append(factory.ALOAD_0);
        il.append(factory.createInvoke("IntegerIterator", "next", 
                                       Type.getReturnType("Ljava/lang/Integer;"),
                                       Type.NO_ARGS, Constants.INVOKEVIRTUAL));
        il.append(factory.createInvoke("java.lang.Integer", "intValue",
                                       Type.INT,Type.NO_ARGS, Constants.INVOKEVIRTUAL));
        il.append(factory.createReturn(Type.INT));
        mg.setMaxStack();
        cg.addMethod(mg.getMethod());

        // write out IntegerIterator.class
        String output = master.getClassName() + ".class";
        cg.getJavaClass().dump(output);
    }
}

// version 1
public interface IntegerIterator {
    int next();
    boolean hasNext();
}

import java.lang.UnsupportedOperationException;
import java.util.Iterator;
// version 2
public interface IntegerIterator extends Iterator<Integer> { 
    @Override
    Integer next();

    @Override
    boolean hasNext();

    @Override
    default void remove() {
        throw new UnsupportedOperationException();
    }
}

import java.util.NoSuchElementException;

public final class Usage1 {

    public static final void main(String[] args) {
        for (IntegerIterator it = new IntegerIteratorImpl(new int[]{1, 2, 3}); it.hasNext();) {
            System.out.println(it.next());
        }
    }

    private static final class IntegerIteratorImpl implements IntegerIterator {
        private final int[] ints;
        private int i;

        public IntegerIteratorImpl(int[] ints) {
            this.ints = ints;
            this.i = 0;
        }

        @Override
        public int next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return ints[i++];
        }

        @Override
        public boolean hasNext() {
            return i < ints.length;
        }
    }
}

import java.util.NoSuchElementException;
import java.util.Iterator;
import java.lang.Iterable;
import java.lang.UnsupportedOperationException;

public final class Usage2 {

    public static final void main(String[] args) {
        for (Integer i : foreach(new IntegerIteratorImpl(new int[]{1, 2, 3}))) {
            System.out.println(i);
        }
    }

    private static <E> Iterable<E> foreach(final Iterator<E> iterator) {
        return new Iterable<E>() {
            @Override
            public Iterator<E> iterator() {
                return iterator;
            }
        };
    }

    private static  final class IntegerIteratorImpl implements IntegerIterator {
        private final int[] ints;
        private int i;

        public IntegerIteratorImpl(int[] ints) {
            this.ints = ints;
            this.i = 0;
        }

        @Override
        public Integer next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return ints[i++];
        }

        @Override
        public boolean hasNext() {
            return i < ints.length;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}

import java.lang.UnsupportedOperationException;
import java.util.Iterator;
// version 2.1
public interface IntegerIterator extends Iterator<Integer> { 

    default int next() {
        return next().intValue(); // call to "default Integer next()"
    }

    @Override
    default Integer next() {
        return Integer.valueOf(next()); // call to "default int next()"
    }

    @Override
    boolean hasNext();

    @Override
    default void remove() {
        throw new UnsupportedOperationException();
    }
}

import java.util.*;
import org.apache.bcel.*;
import org.apache.bcel.classfile.*;
import org.apache.bcel.generic.*;

public final class IntegerIteratorCreator {

    public static final void main(String[] args) throws Exception {  
        JavaClass master = Repository.lookupClass("IntegerIterator"); // version 2

        ClassGen cg = new ClassGen(master);

        // Remove existing non-default next method
        for (Method method : cg.getMethods()) {
            if ("next".equals(method.getName())) {
                cg.removeMethod(method);
            }
        }

        Type integerType = Type.getReturnType("Ljava/lang/Integer;");

        // default int next() { return next().intValue(); } (where next() returns Integer)
        {
            InstructionList il = new InstructionList();
            MethodGen mg = new MethodGen(Constants.ACC_PUBLIC, Type.INT, Type.NO_ARGS, new String[0],
                                         "next", "IntegerIterator", il, cg.getConstantPool());
            InstructionFactory factory = new InstructionFactory(cg);
            il.append(factory.ALOAD_0);
            il.append(factory.createInvoke("IntegerIterator", 
                                           "next", 
                                           integerType,
                                           Type.NO_ARGS, 
                                           Constants.INVOKEINTERFACE));
            il.append(factory.createInvoke("java.lang.Integer", 
                                           "intValue",
                                           Type.INT,
                                           Type.NO_ARGS, 
                                           Constants.INVOKEVIRTUAL));
            il.append(factory.createReturn(Type.INT));
            mg.setMaxStack();
            cg.addMethod(mg.getMethod());
        }

        // default Integer next() { return Integer.valueOf(next()); } (where next() returns int)
        {
            InstructionList il = new InstructionList();
            MethodGen mg = new MethodGen(Constants.ACC_PUBLIC, 
                                         integerType,
                                         Type.NO_ARGS, new String[0],
                                         "next", "IntegerIterator", il, cg.getConstantPool());
            InstructionFactory factory = new InstructionFactory(cg);
            il.append(factory.ALOAD_0);
            il.append(factory.createInvoke("IntegerIterator", "next", 
                                           Type.INT,
                                           Type.NO_ARGS, 
                                           Constants.INVOKEINTERFACE));
            il.append(factory.createInvoke("java.lang.Integer", "valueOf",
                                           integerType,
                                           new Type[]{ Type.INT }, 
                                           Constants.INVOKESTATIC));
            il.append(factory.createReturn(integerType));
            mg.setMaxStack();
            cg.addMethod(mg.getMethod());
        }


        // write out IntegerIterator.class
        String output = master.getClassName() + ".class";
        cg.getJavaClass().dump(output);
    }
}