Removing an object which is wrapped in another object from a collection
All you need is a (hash) map for mapping a Clip to its ClipHolder. That way you can remove Clips in constant time. I have added a couple of comments directly in the code snippet:

Line.java:

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

class Line {

    private static class Bounds {
        //...
    }

    // Clip is immutable. It is a good idea to override 'hashCode' and 'equals'
    // in order to make sure that we can safely use 'Clip's as keys in a hash
    // map.
    private static class Clip {
        private final String name;

        Clip(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        @Override
        public int hashCode() {
            return name.hashCode();
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Clip)) {
                return false;
            }

            return ((Clip) o).getName().equals(this.getName());
        }

        @Override
        public String toString() {
            return "[Clip: " + name + "]";
        }
    }

    // Keyword 'static' removes an implicit reference to Line from each 
    // 'ClipHolder', thus saving some space. Declare your ClipHolder a 
    // 'Comparable'.
    private static class ClipHolder implements Comparable&lt;ClipHolder&gt; {
        private final Clip clip;
        private final Bounds bounds;

        ClipHolder(Clip clip, Bounds bounds) {
            this.clip = clip;
            this.bounds = bounds;
        }

        @Override
        public int compareTo(ClipHolder o) {
            return this.getClip().getName().compareTo(o.getClip().getName());
        }

        public Clip getClip() {
            return clip;
        }

        public Bounds getBounds() {
            return bounds;
        }
    }

    // 1: Program to interface, not implementation.
    // 2: Since Java 7, you can use diamond inference "&lt;&gt;".
    private final Set&lt;ClipHolder&gt; associatedClips = new TreeSet&lt;&gt;();
    private final Map&lt;Clip, ClipHolder&gt; map = new HashMap&lt;&gt;();

    public void addClip(Clip clip) {
        Bounds bounds = null; // Compute your bounds.
        ClipHolder holder = new ClipHolder(clip, bounds);
        associatedClips.add(holder);
        // Map a clip to its holder.
        map.put(clip, holder);
    }

    public void removeClip(Clip c) {
        associatedClips.remove(map.get(c));
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[Line: ");

        int i = 0;

        for (ClipHolder ch : associatedClips) {
            sb.append(ch.getClip().toString());

            if (i &lt; associatedClips.size() - 1) {
                sb.append(", ");
                ++i;
            }
        }

        return sb.append("]").toString();
    }

    public static void main(String[] args) {
        Line line = new Line();
        line.addClip(new Clip("A"));
        line.addClip(new Clip("B"));
        line.addClip(new Clip("C"));
        line.addClip(new Clip("D"));
        System.out.println(line);

        line.removeClip(new Clip("B"));
        System.out.println(line);
    }
}