ArrayList<String> strlist = new ArrayList<String>();
ArrayList<Integer> intlist = new ArrayList<Integer>();

public <T> void doSomething(T arg){
	// doSomething
}

// TをSomeClassのサブクラスに限定する
public <T extends SomeClass> void notDoAnything(T arg){
	return;
}

public <T extends SomeClass> List<T> getSubClassList(List<SomeClass> list){
	return list
		.stream()
		.filter(value -> value instanceof T) // ここでlistの要素valueがTのインスタンスかどうか判別したい -> error
		.collect(Collectors.toList());
}

public <T extends SomeClass> List<T> getSubClassList2(List<SomeClass> list){
	return list
		.stream()
		.filter(value -> value.getClass() == T.class) // instanceofがだめならclassを取得して判別したい -> error
		.collect(Collectors.toList());
}

public <T> void doSomething(String arg){
	T foo = new T(arg); // T型の新しいインスタンスfooを作りたい -> error
}

// 抽象的なゲーム内エンティティクラス
public abstract class Entity {
	private int x;
	private int y;
	public Entity(int x, int y){
		this.setX(x);
		this.setY(y);
	}
	public int getX() { return x; }
	public void setX(int x) { this.x = x; }
	public int getY() { return y; }
	public void setY(int y) { this.y = y; }

	public abstract void update(EntityManager manager);
}

// なんでもかんでも××Managerという名前を付けるのはやめましょう
public class EntityManager {
	private ArrayList<Entity> all_entities;
	public EntityManager(){
		this.all_entities = new ArrayList<Entity>();
	}
	public void add(Entity e){
		this.all_entities.add(e);
	}
	public ArrayList<Entity> getAll() {
		return new ArrayList<Entity>(this.all_entities);
	}
	public void updateAll(){
		this.all_entities.forEach(e->e.update(this));
	}
}

// あなたです
public class Player extends Entity{
	private int hp; // プレイヤーはヒットポイントを持ちます
	public Player(int x, int y, int hp){
		super(x, y);
		this.setHp(hp);
	}
	public int getHp() { return hp; }
	public void setHp(int hp) { this.hp = hp; }
	@Override
	public void update(EntityManager manager){
		// プレイヤーが動きます
	}
}

// 敵です
public class Enemy extends Entity {
	private int damage; // 敵がプレイヤーに与えることのできるダメージ値です
	public Enemy(int x, int y, int damage){
		super(x, y);
		this.setDamage(damage);
	}
	public int getDamage() { return damage; }
	public void setDamage(int damage) { this.damage = damage; }
	@Override
	public void update() {
		// 敵が動きます
	}
}

// 敵です
public class Enemy extends Entity {
	private int damage; // 敵がプレイヤーに与えることのできるダメージ値です
	public Enemy(int x, int y, int damage){
		super(x, y);
		this.setDamage(damage);
	}
	public int getDamage() { return damage; }
	public void setDamage(int damage) { this.damage = damage; }
	@Override
	public void update(EntityManager manager) {
		// 敵が動きます
		// プレイヤーがいたらダメージを与えます
		manager.getAll().forEach((entity)->{ // 全てのエンティティを調べる
			if(entity instanceof Player){ //  エンティティがプレイヤーなら
				if(this.getX() == entity.getX() && this.getY() == entity.getY()){ // プレイヤーと敵の座標が同じなら
					this.doDamage((Player) entity); // ダメージを与える
				}
			}
		});
	}
	public void doDamage(Player p){
		p.setHp(p.getHp() - this.getDamage()); // プレイヤーのヒットポイントをダメージ値分だけ減らします
	}
}

manager.getAll().forEach((entity)->{
	if(entity instanceof Player){
		if(...){
			...
		}
	}
}

manager.<Player>getAllOfSubClass().forEach((player)->{
	if(...){
		...
	}
}

	public <E extends Entity> E createEntity(List<String> args){ // 可変長引数としてもよい
		return new E(args); // ジェネリクス型はnewできない -> error
	}
	public loadSaveData(SaveData savedata){
		// セーブデータから1行ずつ読み込んでオブジェクトを再生成する
		... {
			entityManager.add(this.createEntity(agrs));
		}
	}

	@SuppressWarnings("unchecked")
	public <E extends Entity> List<E> getAllOfSubClass(Class<E> cls){
		return (List<E>) all_entities.stream()
			.filter(entity -> entity.getClass() == cls)
			.collect(Collectors.toList());
	}

entityManager.getAllOfSubClass(Player.class);

entityManager.<Player>getAllOfSubClass(Player.class);

	@SuppressWarnings("unchecked")
	public <E extends Entity> List<E> getAllOfSubClass(Class<E> cls){
		return (List<E>) all_entities.stream()
			.filter(entity -> cls.isAssignableFrom(entity.getClass()))
			.collect(Collectors.toList());
	}

	public <E extends Entity> E createEntity(Class<E> cls, List<String> args){
		// cls型のString[]を引数にとるコンストラクタを呼び出す
		return cls.getConstructor(new Class<?>[] { String[].class }).newInstance(args);
	}

public <T extends SomeClass> List<T> getSubClassList(List<SomeClass> list, Class<T> cls){
	return list
		.stream()
		.filter(value -> value.getClass() == cls)
		.collect(Collectors.toList());
}

// 呼び出し側
getSubClassList(list, SubClassOfSomeClass.class);

public <T> int getStaticValue(Class<T> cls) throws Exception{ // なにがthrows Exceptionだやる気あんのか
	return (int) cls.getMethod("getStaticValue").invoke(null);
}

// 呼び出し
getStaticValue(SomeClass.class); // SomeClass.getStaticValue() を呼んでいるのと同じになる