代码简化探索

class User{

    private int no;
    private String name;

    public User(int no, String name){
        this.no = no;
        this.name = name;
    }

    public int getNo(){
        return no;
    }

    public void setNo(int no){
        this.no = no;
    }

    public String getName(){
        return name;
    }

    @Override
    public String toString(){
        return "User{" +
               "no=" + no +
               ", name='" + name + '\'' +
               '}';
    }

    public void setName(String name){
        this.name = name;
    }
}

public static void main(String[] args){

    List<User> list = new ArrayList<>();
    list.add(new User(1, "zhao"));
    list.add(new User(3, "qian"));
    list.add(null);
    list.add(null);
    list.add(new User(7, "li"));

    for(User user : list){
        if(3 == user.getNo()){
            System.out.println("----------- " + user);
            break;
        }
    }
}

对于 for 循环中的代码，非常的丑陋，也不能扩展

思考1：使用自定义加强的 ArrayList，可以像 Map 一样通过 key 获取到 value

public abstract class EnhanceArrayList<K, E> extends ArrayList<E>{

    public abstract K generateKey(E e);

    private Map<K, E> mMap = new HashMap<>(); // 可以优化为 K,Integer

    public E getE(K k){
        return mMap.get(k);
    }

    @Override
    public boolean add(E e){
        mMap.put(generateKey(e), e);
        return super.add(e);
    }

    @Override
    public void add(int index, E e){
        super.add(index, e);
        mMap.put(generateKey(e), e);
    }

    @Override
    public E remove(int index){
        E remove = super.remove(index);
        mMap.remove(generateKey(remove));
        return remove;
    }

    @Override
    public boolean remove(Object o){
        K k = generateKey((E)o);
        mMap.remove(k);
        return super.remove(o);
    }
}

原理：在已有的 ArrayList 上添加一个 Map 来保存键值对，以通过 key 来获取 value ，从而避免 for 循环

EnhanceArrayList<Integer, User> list = new EnhanceArrayList<Integer, User>(){
    @Override
    public Integer generateKey(User user){
        return user == null ? null : user.getNo();
    }
};
list.add(new User(1, "zhao"));
list.add(new User(3, "qian"));
list.add(null);
list.add(null);
list.add(new User(7, "li"));

System.out.println("------ " + list.getE(3));

需要注意的是具体的实现类中需要对对象进行非空判断。
可以向 list 中 add null，这个知识点给忘记了。

感觉侵入性太强，声明变量时需使用实现类。

思考2：能不能写成工具类？

本来以为对于具体的比较行为工具类不能知道，应该实现不了工具类。突然想到，无法确定的部分抽象给子类去实现就好了。

public abstract class ListUtil<E, K>{

    public abstract boolean isEqual(E e1, K o);

    public E findE(List<E> list, K source){
        if(list != null && !list.isEmpty()){
            for(E e : list){
                if(isEqual(e, source)){
                    return e;
                }
            }
        }
        return null;
    }
}

List<User> list = new ArrayList<>();
list.add(new User(1, "zhao"));
list.add(new User(3, "qian"));
list.add(null);
list.add(null);
list.add(new User(7, "li"));

User user = new ListUtil<User, Integer>(){

    @Override
    public boolean isEqual(User e1, Integer o){
        return e1 != null && e1.getNo() == o;
    }
}.findE(list, 3);

貌似实现了，但是工具类是抽象类，这个总感觉怪怪的，那么是不是可以加个接口来替代抽象类。

思考3：

public final class ListUtil1<E, K>{

    public E findE(List<E> list, K source, Comparator<E, K> comparator){
        if(list != null && !list.isEmpty() && comparator != null){
            for(E e : list){
                if(comparator.isEqual(e, source)){
                    return e;
                }
            }
        }
        return null;
    }

    public interface Comparator<E, K>{

        boolean isEqual(E e1, K o);
    }
}

把上一步的抽象方法放在了接口中，然后把接口放在方法参数中。

List<User> list = new ArrayList<>();
list.add(new User(1, "zhao"));
list.add(new User(3, "qian"));
list.add(null);
list.add(null);
list.add(new User(7, "li"));

User user = new ListUtil1<User, Integer>().findE(list, 3, new ListUtil1.Comparator<User, Integer>(){
    @Override
    public boolean isEqual(User e1, Integer o){
        return e1 != null && e1.getNo() == o;
    }
});
System.out.println("----- " + user);

这儿参考了 Collections.sort(List<T> list, Comparator<? super T> c) 方法

编写第三种代码的时候，总觉得有点 RxJava 的影子。以后详细分析。

总结：
对比以上三种实现，最合理的应该是第三种了，从接口的层面抽象出了代码，但是相对第二种给方法增加了参数，而且实现时需要判断参数是否为 null，且每次都需要 new 一个对象。
虽然第二种怪怪的，但在项目中性能应该较第三种高，个人倾向于使用第二种。

代码简化探索