码农路上

package com.finup.mobileself.cloud.controller;



import java.util.*;

public class Effective {

    //输入一串数字,要输出这些数字组合起来的数里面，比输入数字大的最小数字组合
    //比如输入1241,最终要输出1412

    /**
     * 思路:
     * 1.从右往左(挨着的两个数两两比较,当后一个数大于前一个数的时候,记录前一个数的下标index)
     *    比如 1241,  比较 1 > 4 不成立,  然后比较  4 > 2 成立，这时候记录2的下标为index=1
     *
     * 2.将1241这个列表,从index=1处拆分成两个列表(index包含在后一部分中),prefix= list.subList(0,index) = 1
     *  suffix=list.subList(index,list.size()) = 241
     *
     * 3. 将suffix从小到大排序(241排序后124),从中124里面找到刚好大于list.get(index)的那个值,也就是最终要出现在原先index处的值。
     *    在这里就是从124里面找到刚好大于2的值,就是4
     * 4. 从suffix中删除第3步找到的值,在这里就是4, 所有suffix 原先124 删除4之后变成  12
     *
     * 5. 输出prefix[1]   +  第3不中删除的值[4]   + 第四部的结果[12]    ==1412
     *
     *
     *
     * @param args
     */
    public static void main(String[] args) {
//        main1();
//        if (1==1)return;
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < input.length(); i++) {
            list.add(Integer.parseInt(input.substring(i,i+1)));
        }

        int index = -1; //表示需要变化这个位置
        for (int i = list.size() - 1; i > 0; i--) {
            if (list.get(i) > list.get(i - 1)) {
                index = i-1;
                break;
            }
        }

        if (index == -1) {
            System.out.println("这已经是最大了");
            return;
        }

        List<Integer> prefix = list.subList(0, index);

        System.out.println("1.--------------------------------" + prefix.toString());
        List<Integer> suffix = new ArrayList<>(Arrays.asList(new Integer[list.subList(index, list.size()).size() ]));
        Collections.copy(suffix,list.subList(index, list.size()));
        sort(suffix,"asc");
        Integer replaceValue = -1;
        for (int i = 0; i < suffix.size(); i++) {
            if (suffix.get(i) > list.get(index)) {
                replaceValue = suffix.get(i);
                System.out.println("2.--------------------------------" + replaceValue);
                break;
            }
        }
        System.out.println("3.--------------------------------" + suffix.toString());
        List<Integer> result = new ArrayList<Integer>(Arrays.asList(new Integer[suffix.size()]));
        Collections.copy(result,suffix);
        result.remove(replaceValue);//从后一部分中把刚好大于要替换位置处的值去掉


        //剩下 prefix + replaceValue + suffix就是最后 答案
        System.out.println(prefix.toString());
        System.out.println(replaceValue);
        System.out.println(result.toString());
        System.out.println("=================");

        List<Integer> last = new ArrayList<>();
        last.addAll(prefix);
        last.add(replaceValue);
        last.addAll(result);
        System.out.println(last.toString());

    }

    public static void sort(List<Integer> source,String asc) {
        source.sort(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                if (o1 < o2) {
                    return "asc".equals(asc) ? -1: 1;
                } else if (o1 == o2) {
                    return 0;
                }
                return "asc".equals(asc) ? 1: -1;
            }
        });
    }

    public static void main1() {
        Integer m = 10;
        Integer remove = 1289;
        List<Integer> a = new ArrayList<>();
        a.add(127);
        a.add(128);
        a.add(1289);
        a.add(1289);
        a.remove(remove);
        System.out.println(a);

        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        list.remove(2);
        list.remove(2);
        System.out.println(list.size());
    }
}