HashSet<Integer> hash = new HashSet<>(input);
while (!hash.isEmpty()) {
    hash.remove(hash.iterator().next());
}

class Placement {
    Image image = new BufferedImage(1024, 768); // unused
}

class Colorizer { setDrawDevice(Device), removeDrawDevice(Device)}
// setDisplay(Device, boolean)

class XXXPanel { Panel getPanel(); }
// why not extends Panel

if (input.contains("yes"))
// ???, equals???

void drawTick(Color axisColor) {
    if (color.equals(Color.RED))
        dx++;
    else
        dy++;
}
// Color as key? why not pass enum Axis

class AbstractTableViewRenderer {
    EDA_DIE_ONLY_RENDER dieRender;
}
// don't put your shit on UI library

class AbstractTableView {
     public void with(MouseInterface)
     public void with(TextInterface)
     public void with(IconInterface)
}
// overloading is not for heterogeneous

long degree; // [0, 360)
// oooooooooooooover-size

if (geom instanceof Circle) { renderAsBall((Circle) geom); }
else if (geom instanceof Oblong) { if (type == ball) renderAsCylinder(geom);} // new feature
else renderAsPoly(geom.toPoly());
// fuckup, default as polygon, where is your else

setProperty(Object dbo, String name, Object val) {
  if ("group".equals(name)) Group.set(dbo, val);
}
// where is your else and exception

buttonOK.setOnAction(e -> apply());
void apply() {...; rebuildModel();}
slider.setOnChange(e -> rebuildModel()); // new feature
// our performance is gone by you

void setDisplay(...) {
  fireProperytChange("SetDisplay");
}
// ... property is display, not the method name

Object.requireNotNull(number, "The number is not illegal by " format + " with" + ... context);
// don't compose the error message, construct it on demand.

class ListRenderer {
  void render(ListItem e) {
    ImageIO.read(getImagePath(e.getValue().getType()));
  }
}

String.format("format " + a + "%s", b);

long a = func(x);
long b = func(y);
long dir = mDir;
return (int) a - (int) b;   // SHOULD Long.compare(a, b);
return (int) (a - b) * dir; // SHOULD Long.compare(a, b) * Long.signum(dir);

if ((a == null && b != null) || 
    (a != null && b == null) || 
    !a.equals(b)) {
}
// WAIT, if a == null and b == null ?
// SHOULD Objects.equals(a, b);

class Record {
    boolean merge() {
        return a.setParent(b.getParent().copy());
        // refactor, a.setParent(b.getParent());
    }
}
class Merger {
    void process(Record r) {
        try {
            merge();
        } catch (Exception e) {
            // nothing here
        }
    }
}

class Point {
    Point() {
        throw new UnsupportedOperationException(); // why?
    }
    Point(int x, int y) {...}
}

class Engine {
    private String mFeature = ""; // Why not null ?
}
class DbObj {
    private String mFeature = ""; // Why not null ?
}

Shape shp;
if (shp.getUserName().equals("circle")) // wait, where is your `instanceof`
    return ((Circle) shp).getBound();

void readColRow(int col, int row) {
    Pair p = readPair();
    col = p.first;
    row = p.second;
}

void exec() {
    for (;;) {} // where is throw new UnsupportedOperationException();
}

class MSTAlgorithmEngine {
    JButton mApplyButton; // why, ???
    JPanel mUI;           // why, ???
}
class DiffRecord {
    Action mMergeAction; // why, ???
    Action mShowAction;  // why, ???
}
class Rectangle {
    void normalize() {
        new NormalizeAction().actionPerformed(new ActionEvent(ActionEvent.PERFORMED));
    } // I cannot deal with this shit anymore.
    class NormalizeAction extends AbstractAction {
        // real implementation for model class
    }
}

class Engine {
    private static CacheStructure sCache;
    public void exec() {
        resetCache();
        // fill cache;
    } // but, when will you clear sCache, sCache = null?
}

class Dbo extends DbObject {
    private CacheStructure mCache; // for internal recursion, why this thing is here?
    public Object getSomething() {
        // init cache
        return internalGetSomething(parameters);
    } // but, when will you clear cache, cache = null?
    private Object internalGetSomething(parameters) {
        // ...
    }
}

class OhMyGod {
    public void run() {System.out.println("A");}
    public void run(String t) {System.out.println("B");}
    public <T> void run(T[] t) {System.out.println("C");}
    public <T> void run(T t) {System.out.println("D");}
    public static void run(String... t) {System.out.println("E");}
    public static void main(String[] args) {
        new OhMyGod().run();
        new OhMyGod().run(new String[0]);
        new OhMyGod().run("1");
        new OhMyGod().run("1", "2");
    }
} // AEBE, little strange

class FileIn {
    private boolean isCSV; // why not enum
    private boolean isXML;
    private boolean isJSON;
    public void setIsCSV(boolean e) {isCSV = e;}
    public void setIsXML(boolean e) {isXML = e;}
    public void setIsJSON(boolean e) {isJSON = e;}
    public void import(File file) {
        // why not if-else
        if (isCSV) CSVIn(file); 	//??? 
        if (isXML) XMLIn(file); 	//???
        if (isJSON) JSONIn(file); 	//???
    }
}

Collections.sort(arr, (x, y) -> (int) (x.cost - y.cost));
Collections.sort(arr, (x, y) -> Long.valueOf(x).compareTo(y));
Collections.sort(arr, (x, y) -> (int) Math.round(x.cost - y.cost));
// why not use official methods?
Collections.sort(arr, (x, y) -> Double.compare(x.cost, y.cost));
Collections.sort(arr, (x, y) -> Long.compare(x, y));

class Optimizer {
    private int avgX(ArrayList<Point> pts) {
        ArrayList<Long> x = new ArrayList<>(pts.size());
        for (Point p : pts)
            x.add(p.x);
        return avg(x);
    }
    private int avg(ArrayList<Long> xs) {
        long sum = 0;
        for (Long x : xs)
            sum += x;
        return sum / xs.size();
    }
}
// ... why not merge avg() into avgX()?

class Parser {
    void addChar(char c) {
        try {
            que[index] = c;
        } catch (ArrayIndexOutOfBoundsException e) {
            doubleArray();
            que[index] = c;
        }
        index++;
    }
}
// why not just write if-else statements, it's really hard to maintain your code.
class Parser {
    void addChar(char c) {
        if (index >= que.length)
            doubleArray(index);
        que[index] = c;
        index++;
    }
}

Map<Long, Object> a;
TLongObjectMap<Object> b;

class MMap<T> {
    TLongObjectMap<T> longMap;
    TIntObjectMap<T> intMap;
}

class Scheme {
    K[] keys; // as known, keys.length = 10
    V[] vals; // as known, vals.length = 10
}

class Scheme {
    Object[] keyval; // [key0, key1, ..., val1, val0]
}

Map<T, String> map;
map.put(a, "MARKED");
map.put(b, "UNMARKED");

class T {
    ...
    Object userData;
}

class MSet {
    Object mRaw; // size < 8: LinkedList; otherwise, HashSet
}