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())，因此可以避免上述说到的原因。
