List 实体 根据数组顺序写入Excel

最近在项目中遇到个导出问题，excel格式表头固定，循环这个List<Entity>的时候要求去根据表头的顺序来写入数据,虽然后头需求变了，导致没用到，但还是记录下：

public static void main(String[] args) {
        List<Entity> list = new ArrayList<>();
        Entity  s;
        String[] strArr = {"schoolName", "totalNum", "standardAmount", "totalAmount"};
        Random random = new Random();
        /**
         * 创建10条测试数据
        */
        for (int i = 0; i <10 ; i++) {
            s= new Entity();
            s.setSchoolName("学校名称" + i);
            s.setTotalNum(random.nextInt());
            s.setStandardAmount(random.nextDouble());
            s.setTotalAmount(random.nextDouble());
            list.add(s);
        }
        list.forEach(ss->{
            Field[] fields = ss.getClass().getDeclaredFields();
                for (String s1 : strArr) {
                    for(int i = 0 ; i < fields.length ; i++) {
                        fields[i].setAccessible(true);
                            if(s1.equals(fields[i].getName())){
                                try {
                                    Object ss1 = fields[i].get(ss);
                                    //这里的这个ss1就是根据循环上面自定义的数组以及        
                                    //List<Entity>里的值从List<Entity>中根据数组里循环当前 
                                    //的值而取到的Value，不知道这样说对不对，反正意思是这么个            
                                    //意思
                                    System.out.println(ss1);
                                } catch (IllegalAccessException e) {
                                    e.printStackTrace();
                                }
                            }
                    }
                }
        });
    }

当初在找这个解决办法时，我朋友大神把他项目中类似这样的一个功能算法给了我

大概意思是这样的

[ A, B, C ]
[  B => 1, C => 2, A => 3 ]
需要得到 [3, 1, 2]   这样的结构

 

/**
     * 获取第一个匹配的元素
     * @param collection
     *                  List<实体>
     * @param target
     *                  要匹配的值
     * @param function
     *                  规则怎么从元素中获取参与匹配的值
     * @param <E>
     * @param <R>
     * @return
     */
        public static <E,R> Optional<E> getFirstMatch(@NonNull Collection<E> collection,R target,@NonNull Function<E,R> function){
        for (E item : collection) {
            R value = function.apply(item);
            if(target == null){
                return value == null ? Optional.ofNullable(item) : Optional.empty();
            }else if(target.equals(value)){
                return Optional.ofNullable(item);
            }
        }
        return Optional.empty();
    }

我就觉得这样对我没用，但是可能以后对我有用我就手写下来了

获取全部匹配：

/**
     * 获取全部匹配的元素
     * @param collection
     * @param target
     * @param function
     * @param <E>
     * @param <R>
     * @return
     */
    public static <E,R>List<E> getAllMatch(@NonNull Collection<E> collection,R target,@NonNull Function<E,R> function){
          return collection.stream().filter(item->{
             R value = function.apply(item);
             if(target == null){
                 return value == null;
             }else{
                 return target.equals(value);
             }
          }).collect(Collectors.toList());
    }

 

检查是不是有元素匹配这样的条件：

/**
     * 检查元素
     * @param collection
     * @param target
     * @param function
     * @param <E>
     * @param <R>
     * @return
     */
    public static <E,R>boolean contains (@NonNull Collection<E> collection,R target,@NonNull Function<E,R> function){
        for (E item : collection) {
            R value = function.apply(item);
            if(target == null){
                return value == null;
            }else if(target.equals(value)){
                return true;
            }
        }
        return false;
    }

实现上面例子：

public static void main(String[] args) {
        List<String> list = List.of("A","B","C");
        List<KeyValuePair<String,Integer>> keyValuePairs=List.of(
                new KeyValuePair<>("B",1),
                new KeyValuePair<>("C",2),
                new KeyValuePair<>("A",3)
        );
        list
            .stream()
            .map(item->getFirstMatch(keyValuePairs,item,KeyValuePair::getKey)
                    .map(KeyValuePair::getValue)
                    .orElse(null))
            .forEach(System.out::println);
    }

感觉以后可能用得上，特此记录下，感谢邱大神提供的算法，哈哈哈

他的博客，有兴趣可以去看下