最近正在做一個專案寫遞迴寫的不少，遞迴真的是Java中非常常見的，但是遞迴寫的好不好也是取決於思維是否清晰。多思考自己的程式碼，儘量讓程式碼變得優雅和可讀性。

按照慣例推薦一首歌曲。我們的時光--趙雷

本文主要介紹三個方面的內容

1.Java中的排列組合

2.集合中的交併差(google Guava 和apache commons collectionsutil 都是可以的)

3.關於寫遞迴時原則

mavne的依賴  

<Dependecy>

<groupId>org.raistlic.lib</groupId>

<artifactId>commons-core</artifactId>

<version>1.4</version>

</Dependecy>

import org.raistlic.common.permutation.Combination;
import org.raistlic.common.permutation.Permutation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * ${DESCRIPTION}
 *
 * @author mengxp
 * @version 1.0
 * @create 2018-01-15 21:05
 **/
public class JoneTest {


    public static final Logger CombineArithmeticLOG = LoggerFactory.getLogger(JoneTest.class);
    public static final String ARITHMETIC_CONNECT_SPLIT = "\\$";
    public static final String ARITHMETIC_CONNECT = "$";


    /**
     * 對集合中的元素進行全排列
     * [1, 2, 3]
      [1, 3, 2]
      [2, 1, 3]
      [2, 3, 1]
      [3, 1, 2]
      [3, 2, 1]
     */
    public void testPermutationAll(){
        Permutation<String> of = Permutation.of(Arrays.asList("1", "2", "3"));
        for (List<String> list : of) {
            System.out.println(list);
        }
    }

    /**
     * 對集合中的任取numberToPick個數進行全排列
     */
    public void testPermutationOfDefine(){
        int cout = 0;
        for (List<Integer> list : Permutation.of(Arrays.asList(1, 2, 3, 4, 5), 3)) {
            cout++;
            System.out.println(list);
        }
        System.out.println(cout);
    }

    /**
     * 取出集合中的任意個數 組合計算
     */
    public void testCombinationOfDefine(){
        for (List<Integer> list : Combination.of(Arrays.asList(1, 2, 3, 4, 5), 3))
            System.out.println(list);
    }


    public static void main(String[] args) {
        HashSet<String> result=new HashSet();
        exeMain(true,2,Arrays.asList("a","b","c"),result);
        System.out.println("xxxx");
    }


    /**
     *
     * @param isFlag        採用排列或者組合的方式
     * @param combieCounter 子集合的組合方式
     * @param sourece       資料來源
     * @param resultSets    返回的結果集
     * @return  mengxp
     */
    public static Set<String> exeMain(boolean isFlag, int combieCounter, List<String> sourece, Set<String> resultSets) {
        if (sourece == null) {
            CombineArithmeticLOG.error("sourece is null...");
            return resultSets;
        }
        if (sourece != null || sourece.size() == 0) {
            if (combieCounter > sourece.size()) {
                CombineArithmeticLOG.error("combineCounter must be < source size...");
                return resultSets;
            }
        }
        if (isFlag) {//TODO 全排列
            List<List<String>> pl = RankArithmetic.pl(sourece);
            for (int i = 0; i < pl.size(); i++) {
                select(combieCounter, pl.get(i), resultSets);
            }
        } else {
            //TODO 全組合
            select(combieCounter, sourece, resultSets);
        }
        return resultSets;
    }

    private static void select(int k, List<String> sources, Set<String> resultSet) {
        String[] result = new String[k];
        subselect(0, 1, result, k, sources, resultSet);
    }

    /**
     * 遞迴演算法
     * @param head
     * @param index
     * @param r
     * @param k
     */
    private static void subselect(int head, int index, String[] r, int k, List<String> sources, Set<String> resultSet) {
        for (int i = head; i < sources.size() + index - k; i++) {
            if (index < k) {
                r[index - 1] = sources.get(i);
                subselect(i + 1, index + 1, r, k, sources, resultSet);
            } else if (index == k) {
                r[index - 1] = sources.get(i);
                String content = "";
                for (int j = 0; j < r.length; j++) {
                    String a = r[j];
                    content = content + ARITHMETIC_CONNECT + a;
                }
                content = content.replaceFirst(ARITHMETIC_CONNECT_SPLIT, "");
                resultSet.add(content);
                subselect(i + 1, index + 1, r, k, sources, resultSet);
            } else {
                return;
            }
        }
    }


}
 

import java.util.LinkedList;
import java.util.List;


/**
 * Created by mengxp on 2017/8/18.
 */
public class RankArithmetic {

    /**
     * 得到全排列的方法
     * @param data  存放要排列的各個元素
     * @return List<List<String>> 結果中的每一個List就是一種可能的排列
     */
    public static List<List<String>> pl(List<String> data){

        if(data.size()==1){
            // 如果data中只有一個元素，那麼直接得到它的全排列
            List<List<String>> result= new LinkedList<List<String>>();
            List<String> p = new LinkedList<>();
            p.add(data.get(0));
            result.add(p);
            return result;
        }else{
            // 否則，去除第一個元素，然後得到剩下的 n-1 個元素的全排列，第一個元素插入到每一種排列中的相應位置上就可以得到所有元素的全排列了
            // 也就是說， n-1 個元素的全排列中的每一種排列又可以衍生出 n 種排列
            String first = data.get(0);
            List<String> remainList = data.subList(1, data.size());
            List<List<String>> remainPl = pl(remainList);

            List<List<String>> result= new LinkedList<List<String>>();
            for(int i=0;i<remainPl.size();i++){

                List<String> thisOne = remainPl.get(i);
                for(int j=0;j<=thisOne.size();j++){

                    List<String> copyOne = new LinkedList<>(thisOne);
                    copyOne.add(j,first);
                    result.add(copyOne);
                }
            }
            return result;
        }
    }
}
 

package matrixOnto.deal.Util;


import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * Created by mengxp on 2017/9/27.
 */
public class CollectionPower {
    private static Logger logger = LoggerFactory.getLogger(CollectionPower.class);

    public static void main(String[] args) {
        String[] arrA = new String[100000];
        String[] arrB = new String[100000];
        for (int i=0;i<100000;i++) {
            int i1 = new Random().nextInt(1000000);
            arrA[i]=i1+"";
            int i2 = new Random().nextInt(1000000);
            arrB[i]=i2+"";
        }
   /*     String[] arrA = new String[]{"1", "3", "5", "6"};
        String[] arrB = new String[]{"2", "3", "7", "8"};*/
        long startTime=System.currentTimeMillis()/1000;
        String union = new CollectionPower().collectionUnion(arrA, arrB);
        //String interSection = new CollectionPower().collectionInterSection(arrA, arrB);
        String disjunction = new CollectionPower().collectionDisjunction(arrA, arrB);
        String subtract = new CollectionPower().collectionSubtract(arrA, arrB);
        long endTime=System.currentTimeMillis()/1000;
     /*   System.out.println("union: [" + union + "]");
        System.out.println("interSection: [" + interSection + "]");
        System.out.println("disjunction: [" + disjunction + "]");
        System.out.println("subtract: [" + subtract + "]");*/
        System.out.println("All Spend Time is :["+(endTime-startTime)+"]");
    }


    /**
     * Union action.會去重
     *
     * @param arrayA
     * @param arrayB
     * @return
     */
    public static String collectionUnion(String[] arrayA, String[] arrayB) {
        String arrayC = "";
        try {
            List<String> a = Arrays.asList(arrayA);
            List<String> b = Arrays.asList(arrayB);
            Collection union = CollectionUtils.union(a, b);
            arrayC = union.toString();
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("execute union action failed.....");
        }
        return arrayC;

    }


    /**
     * 交集
     *
     * @param arrayA
     * @param arrayB
     * @return
     */
    public static List<String> collectionInterSection(String[] arrayA, String[] arrayB) {
      List<String> list=new ArrayList<>();
        try {
            List<String> a = Arrays.asList(arrayA);
            List<String> b = Arrays.asList(arrayB);
            Collection union = CollectionUtils.intersection(a, b);
            list.addAll(union);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("execute InterSection action failed.....");
        }
        return list;
    }


    /**
     * union出去交集的集合
     *
     * @param arrayA
     * @param arrayB
     * @return
     */
    public static String collectionDisjunction(String[] arrayA, String[] arrayB) {
        String arrayC = "";
        try {
            List<String> a = Arrays.asList(arrayA);
            List<String> b = Arrays.asList(arrayB);
            Collection union = CollectionUtils.disjunction(a, b);
            arrayC = union.toString();
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("execute Disjunction action failed.....");
        }
        return arrayC;
    }


    /**
     * 集合(A-交集)
     *
     * @param arrayA
     * @param arrayB
     * @return
     */
    public static String collectionSubtract(String[] arrayA, String[] arrayB) {
        String arrayC = "";
        try {
            List<String> a = Arrays.asList(arrayA);
            List<String> b = Arrays.asList(arrayB);
            Collection union = CollectionUtils.subtract(a, b);
            arrayC = union.toString();
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("execute subtract action failed.....");
        }
        return arrayC;
    }
}

package matrixOnto.deal;

import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Lists;
import matrixOnto.preparse.HbaseObj;

import javax.annotation.Nullable;
import java.util.List;

/**
 * Created by mengxp on 2017/12/26.
 */
public class GoogleCollectionsUtils<I,R> {

    public static final String TYPE_VALUE_COMBINE_STR="_";

    /**
     transform.toImmutableList();
     transform.toArray();
     transform.toImmutableSet()
     * @param inputs
     * @param function
     * @param <I>
     * @return 傳入Fucntion進行型別轉化
     */
    public  <I> FluentIterable<R> commonTransFunction(Iterable<I> inputs, Function<I,R> function){
        FluentIterable<R> transform = FluentIterable.from(inputs).transform(function);
        return transform;
    }

    /**
     * 將集合進行拆分
     * @param inputs
     * @param collectionSize 指定每個集合的最大的size
     * @param <I>
     * @return
     */
    public static <I> List<List<I>> listSplit(List<I> inputs,int collectionSize){
        List<List<I>> partition = Lists.partition(inputs, collectionSize);
        return partition;
    }

    public static Function<HbaseObj, String> Function_Type_Value = new Function<HbaseObj, String>() {
            @Nullable
            @Override
            public String apply(@Nullable HbaseObj hbaseObj) {
                String hbaseObjId = hbaseObj.getId();
                String hbaseObjType = hbaseObj.getType();
                String id = Joiner.on(TYPE_VALUE_COMBINE_STR).join(hbaseObjType, hbaseObjId);
                return id;
            }

            @Override
            public boolean equals(@Nullable Object o) {
                return false;
            }
        };



}

1.返回值Void

2.有層次或者無層遞迴

3.寫遞迴時，必須把輸入，輸出定義清楚。

/**
     
     * @param input
     * @param infos
     * @param filterVo
     */
    private void recursionGraphInfos(RecursionExtendVo input, List<GraphInfo> infos, ExtendsFilterVo filterVo) {
        RECURSIONEXTENDANALYSISFUTURELOG.info("Current Run Recursion level {{}} ",filterVo.getRecursionLevel());
        if (filterVo.getRecursionLevel() == levelCondition) {
            //達到了遞迴的次數
            return;
        }
        RecursionExtendVo recursionExtendVo = queryOneByMain(input, infos, filterVo);
        recursionGraphInfos(recursionExtendVo, infos, filterVo);
    }


    /**
     *
     * @param input
     * @param infos
     * @param filterVo
     * @return
     */
    private RecursionExtendVo queryOneByMain(RecursionExtendVo input, List<GraphInfo> infos, ExtendsFilterVo filterVo) {
        filterVo = filterVo.leverDecrease(filterVo);
        HashMultimap<String, String> hashMultimap = input.getHashMultimap();
        Collection<String> values = hashMultimap.values();

        HashMultimap<String, String> recusionMap = HashMultimap.create();
        if (values.size() == 0) {
            return input.setHashMultimap(recusionMap);
        }
        for (String dealNum : values) {
            GraphInfo infoByTimeFilter = getInfoByTimeFilter(dealNum, filterVo, recusionMap);
            infos.add(infoByTimeFilter);
        }
        return input.setHashMultimap(recusionMap);
    }


    private GraphInfo getInfoByTimeFilter(String dhhm, ExtendsFilterVo vo, HashMultimap<String, String> recusionMap) {
        //比如dhhm=A  recusionMap={A->A1,A->A2,A->A3,A->A4}
        String rowKey = BaseQueryBusiness.getMainRowKey("DHHM", dhhm);
        GraphInfo result=new GraphInfo();
        result.setEdgeSet(new HashSet<Edge>()).setVertexSet(new HashSet<Vertex>());
         try {
             result= commonByRecusion(table, gson, RECURSIONEXTENDANALYSISFUTURELOG, Bytes.toBytes(rowKey), OntologyServerConstants.MAIN_STORM_ENEVT, recusionMap,isFilter,vo);
        } catch (IOException e) {
            DealUtils.LogError(e, RECURSIONEXTENDANALYSISFUTURELOG);
        }
        return result;
    }