得到最长连续递增序列

今天作死，看到别人发出来的笔试题就开干了，这tmd还理解错题目了，连续递增序列理解成上一个=下一个-1了。

这是我的成果，撸了4个多小时的：

public class Test12 {
    public  static void main(String[] args){
        /**
         * 需求：找出最长的连续递增序列
         * 步骤：
         *  1、找出所有连续序列可能结果，删除不是连续递增序列的，加入集合
         *  2、集合排序，取第一个
         *
         * 方式2：
         *  0、默认len为数组长度
         *  1、找出数组中长度为len的序列，判断是否是连续递增序列，是的话加入集合
         *  2、如果前面找出来了，直接返回，否则len = len - 1，继续走1
         *  3、取出集合中的第一个返回
         */
        Integer [] ints = new Integer[]{89,2,73,4,5,6,7,8,10,12,15,4,5,6,8,9,10,2};

       System.out.println(Arrays.toString(findMaxCre(ints)));
        System.out.println(Arrays.toString(findMaxCre1(ints)));

    }

    public static boolean isCreSeq(Integer[] numbers){
       boolean flag = true;
       for(int i = 0; i < numbers.length - 1; i ++){
           if(numbers[i+1] <= numbers[i]){
               flag = false;
               break;
           }
       }
        return flag;
    }

    public static Integer[] findMaxCre1(Integer[] ints){
      List<Integer[]> lists =  getChildLists1(ints);
      return lists.get(0);
    }

    public static List<Integer[]> getChildLists1(Integer[] ints){
        List<Integer[]> lists = new ArrayList<Integer[]>();
        if(ints == null || ints.length <= 1){
            return lists;
        }
        int len = ints.length;
        for(int i = len; i > 0; i--){
            boolean hasValue = false;
            for(int j = 0; j < len; j++){
                if(j + i < len){
                    Integer[] nums = new Integer[i];
                    nums = Arrays.copyOfRange(ints, j, j + i);
                    if(isCreSeq(nums)){
                        lists.add(nums);
                        hasValue = true;
                    }
                }
            }
            if(hasValue){
                break;
            }
        }
        return lists;
    }

    public static Integer[] findMaxCre(Integer[] ints){
        List<Integer[]> allQue = new ArrayList<Integer[]>();
        allQue.addAll(getChildLists(ints));
        Collections.sort(allQue, new Comparator<Integer[]>() {
            public int compare(Integer[] o1, Integer[] o2) {
                return o2.length - o1.length;
            }
        });
        return allQue.get(0);
    }

    public static List<Integer[]> getChildLists(Integer[] ints){
        List<Integer[]> lists = new ArrayList<Integer[]>();
        if(ints == null || ints.length <= 1){
            return lists;
        }
        int len = ints.length;
        for(int i = 0; i < len ; i++){
            Integer[] row = new Integer[len - i];
            row = Arrays.copyOfRange(ints, i, len);
            int rowLength = row.length;
            for(int j = 1; j <= rowLength; j++){
                Integer[] nums = new Integer[j];
                nums = Arrays.copyOfRange(row, 0, j);
                if(isCreSeq(nums)){
                    lists.add(nums);
                }
            }
        }
        return lists;
    }
}

我的思想是怎么转化为代码的呢？

这个我使用了画图的方式，依据你图纸的步骤，你可以更清晰的写出代码，不容易混乱掉！