美文网首页
JAVA基础2021/7/8

JAVA基础2021/7/8

作者: ShawnCaffeine | 来源:发表于2021-06-23 11:16 被阅读0次

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

    相关文章

      网友评论

          本文标题:JAVA基础2021/7/8

          本文链接:https://www.haomeiwen.com/subject/qlqbyltx.html