Print left view of the tree
Although the algorithms seems fine, there are issues with the choosen abstractions.

LeftView is a factory of lists, which are left views of an inner tree. LeftView is not a data structure itself, but a factory of it, configured by a list, that are converted to a tree -- too much responsability. Keeping in mind @abuzittin gillifirca advice, a good practise is to refactor factory methods in static, public, methods.

public final class BinaryTrees {
    public static List&lt;T&gt; createLeftViewList(BinaryTree&lt;T&gt; tree) { ... }
}


In your code, LeftView had his own tree representation. To better convey the idea of an algorithm, consider start with simple interfaces, followed by the algorithm itself. That way you get better readability and guarantee further reuse in real code.

public interface BinaryTree&lt;T&gt; {
    BinaryTree&lt;T&gt; left();
    BinaryTree&lt;T&gt; right();
    T element();
}


And than we fill it with runnable code.

public class BinaryTree&lt;T&gt; {
    public BinaryTree&lt;T&gt; left() { return left; }
    public BinaryTree&lt;T&gt; right() { return right; }
    public T element() { return element; }

    private BinaryTree&lt;T&gt; left, right;
    private T element;

    public BinaryTree(List&lt;? extends T&gt; bfsRepresentation) {
        final List&lt;? extends T&gt; items;
        items = new ArrayList&lt;&gt;( bfsRepresentation );
        create( items );
    }
    ...
}


The create method assumes that items is always random access list. Well, it is if we consider only the test methods. If it gets called with a very large LinkedList, you will get quadratic performance.

Consider copying the list in an java.util.ArrayList. An array, T[], should do the trick too, and its preferrable.

Last piece of advice, consider parameterized unit tests in JUnit. There's a good example how to use it in their github wiki.