Combination generator in Java
Consider the iterator pattern with the methods hasNextCombination() and nextCombination(). Let your implementation follow the implications. Maybe you have to introduce a buffer. The loadCombination()-method inverts the responsibility and let you do strange things like clearing the given list if the client gives you messy data. The standard iterator pattern is the way to go. Pass your list of elements to the constructor of your Iterator. Make defensive copies to avoid side effects. Return the combination of the elements directly. The Client should be responsible to collect them in a list.
Even this suggestion will be obsolete (1.). Do not check for "null" values. If the client gives you "null" then he should expect that the program will not work properly. Giving up the responsibility of the client to not pass null values has serious consequences for your source code. You will end up checking everything for null because you cannot count on anything. There are some exceptions to that which should be known: The parent of the root of a hierarchy may be null, lazy initialization is dealing with null and son find()-methods may return null that has to be evaluated immediatly. In all other cases: Never pass null, never check null and never return null.
Break the generateNextCombination()-method into smaller pieces. If you experience problems then it surely has to do with the multiple return statements. Multiple return statements will hinder you to apply refactorings like "extract method". Furthermore: extending your code is much more predictable. Avoid multiple return statements in a method. Provide a proper control flow until the end of the method.
As a matter of common usage do not use ++k. Use k++ instead. You yourself are switching between suffix and prefix notation. Keep doing one thing consistently to have the least surprise. Do not forget to adapt your breaking conditions.
As it is used in the test, do not take my suggestion too serious here but: Avoid using bit shifting. I do not event know if there is a significant speed up. After all it doesn't matter until your application critical on this. And most of the applications aren't. The reason is you introduce low level language structures in a high level language.