代码简化探索
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 一个对象。
虽然第二种怪怪的，但在项目中性能应该较第三种高，个人倾向于使用第二种。
