JAVA基础2021/7/8

1.Java.util.HashMap.putAll()是[HashMap]类的内置方法，用于复制操作。该方法将所有元素（即映射）从一个映射复制到另一个映射。

句法：
new_hash_map.putAll(exist_hash_map)

把exist_hash_map的内容复制到new_hash_map中

2.线程池的最大线程数有什么用？

用来缓冲，比如突然有很多的请求打了进来，就能增加一些线程进行处理。

3.iterator和 iterable区别和联系

最近写一个小院查询的需求，发现写的代码看不太懂

public class GetAllSchoolInfosServiceImpl implements BaseService  {

    private static Log log = LogFactory.getLog(GetAllSchoolInfosServiceImpl.class);
    private volatile List<SchoolNode> schoolNodes;//学校信息的缓存

    @Autowired
    private DeliveryBigAiService deliveryBigAiService;
    @Autowired
    private StudentIndexInfoService studentIndexInfoService;

    interface SchoolInfo extends Iterable<SchoolInfo.Entry>  {
        boolean isValid();
        String error();
        interface Entry {
            String getProvince();
            String getCity();
            String getName();
            boolean isValid();
        }
    }

    static class MarketSchoolInfo implements SchoolInfo {
        private BaseEntity<List<SchoolVo>> result;

        MarketSchoolInfo(BaseEntity<List<SchoolVo>> result) {
            this.result = result;
        }

        public boolean isValid() {
            return result != null && result.getResultCode() == 1;
        }

        public String error() {
            return "调用商城校园错误：" + (result == null ? "null" : result.getMessage());
        }

        public Iterator<Entry> iterator() {
            return new Iterator<Entry>() {
                private int i = 0;
                private List<SchoolVo> schoolInfos = result.getData();

                @Override
                public boolean hasNext() {
                    return i < schoolInfos.size();
                }

                @Override
                public Entry next() {
                    final SchoolVo schoolInfo = schoolInfos.get(i++);
                    return new Entry() {
                        @Override
                        public String getProvince() {
                            return schoolInfo.getProvince();
                        }

                        @Override
                        public String getCity() {
                            String city = schoolInfo.getCity();
                            return city.endsWith("市")? city.substring(0, city.length() - 1): city;
                        }

                        @Override
                        public String getName() {
                            return schoolInfo.getSchoolName();
                        }

                        @Override
                        public boolean isValid() {
                            return !Strings.isNullOrEmpty(schoolInfo.getProvince()) &&
                                    !Strings.isNullOrEmpty(schoolInfo.getCity()) &&
                                    !Strings.isNullOrEmpty(schoolInfo.getSchoolName());
                        }
                    };
                }

                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }
    }

    public String execute(Map<String, Object> map, Map<String, Object> resultMap) {
        if (schoolNodes == null) {
            synchronized (GetAllSchoolInfosServiceImpl.class) {
                if (schoolNodes == null) {
                    StudentVerifyInfoRequest request = new StudentVerifyInfoRequest();
                    request.setUserPin("");
                    request.setId(1003L);
                    request.setSecretKey("6835f7ed6dc144cf9ab63db5ed154e84");
                    BaseEntity<List<SchoolVo>> result = studentIndexInfoService.schoolList(request);
                    SchoolInfo schoolInfo = new MarketSchoolInfo(result);
                    if (schoolInfo.isValid()) {
                        List<SchoolNode> root = Lists.newArrayList();
                        for (SchoolInfo.Entry entry : schoolInfo) {
                            if (!entry.isValid()) {
                                continue;
                            }
                            List<SchoolNode> tmp = root;
                            SchoolNode province = new SchoolNode(entry.getProvince(), entry.getProvince(), Lists.<SchoolNode>newArrayList());

                            int i = tmp.indexOf(province);
                            if (i < 0) {
                                tmp.add(province);
                                i = tmp.size() - 1;
                            }

                            tmp = tmp.get(i).children;
                            SchoolNode city = new SchoolNode(entry.getCity(), entry.getCity(), Lists.<SchoolNode>newArrayList());

                            i = tmp.indexOf(city);
                            if (i < 0) {
                                tmp.add(city);
                                i = tmp.size() - 1;
                            }

                            tmp = tmp.get(i).children;
                            SchoolNode school = new SchoolNode(entry.getName(), entry.getName(), null);

                            tmp.add(school);
                        }

                        schoolNodes = root;
                    } else {
                        resultMap.put(ActivityConstants.SUBCODE_FIELD, ActivityConstants.SUBCODE_FAIL);
                        log.error(schoolInfo.error());
                        return schoolInfo.error();
                    }
                }
            }
        }
        resultMap.put("schoolInfos", schoolNodes);
        resultMap.put(ActivityConstants.SUBCODE_FIELD, ActivityConstants.SUBCODE_SUCCESS);
        return "success";

    }

    public static class SchoolNode {
        public String value;
        public String label;
        public List<SchoolNode> children;

        public SchoolNode(String value, String label, List<SchoolNode> children) {
            this.value = value;
            this.label = label;
            this.children = children;
        }

        @Override
        public boolean equals(Object a) {
            return a instanceof SchoolNode && ((SchoolNode)a).value.equals(this.value);
        }

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

其中就使用了增强for循环来遍历一个类。当时理解不了，认为只有容器collection才能for循环，但是是自己没有去深入了解collection。collection就继承了iterable接口，iterable接口中有iterator接口。

iterable:

// 返回一个内部元素为T类型的迭代器（JDK1.5只有这个接口）
Iterator<T> iterator();

// 遍历内部元素，action意思为动作，指可以对每个元素进行操作（JDK1.8添加）
default void forEach(Consumer<? super T> action) {}

// 创建并返回一个可分割迭代器（JDK1.8添加），分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。
default Spliterator<T> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

iterator:

public interface Iterator<E> {
  
    boolean hasNext();

    E next();

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

为什么一定要去实现Iterable这个接口呢？为什么不直接实现Iterator接口呢？
看一下JDK中的集合类，比如List一族或者Set一族，都是实现了Iterable接口，但并不直接实现Iterator接口。 仔细想一下这么做是有道理的。

因为Iterator接口的核心方法next()或者hasNext() 是依赖于迭代器的当前迭代位置的。 如果Collection直接实现Iterator接口，势必导致集合对象中包含当前迭代位置的数据(指针)。 当集合在不同方法间被传递时，由于当前迭代位置不可预置，那么next()方法的结果会变成不可预知。 除非再为Iterator接口添加一个reset()方法，用来重置当前迭代位置。 但即时这样，Collection也只能同时存在一个当前迭代位置。 而Iterable则不然，每次调用都会返回一个从头开始计数的迭代器。 多个迭代器是互不干扰的。

直接继承Iterator，从Iterator接口可以看出需要子类实现next(),hasNext()方法，假设都交给List去实现，那么获取list的Iterator（）时就会出现上面解释那样，而继承Iterable接口，则需要每次List返回一个新的Iterator对象(见ArrayList的new Itr())，因此可以避免上述说到的原因。