Given an array, such as [7864, 284, 347, 7732, 8498], now you need to splice the numbers in the array to return the "largest possible number."

/**
 *  Give an array , Such as  [7864, 284, 347, 7732, 8498],
 *  Now you need to splice the numbers in the array , If spliced in sequence, it is ：786428434777328498, The number splicing order in the array can be arbitrary ,
 *  Programming , return 「 The most likely number to spell 」.（ Take the above array as an example , return 849878647732347284）
 * @param arrays
 * @return
 */

Their thinking ： Disassemble every number in the array , Store the value on the stack （ Obvious stack data structure ）; Sort （ The idea of bubble sorting is used ） , The sorting process compares the size through the size comparison between the high and low values , such as 8,70, Sort by this 8 Belong to the big one ; Finally, the array is output from the back to the front to complete the splicing

public static String getMaxNum(long[] arrays) {
        if (arrays == null || arrays.length == 0) {
            return "0";
        }

        // Store all disassembled data sets 
        Map<Long, Stack<Integer>> numMaps = Maps.newHashMap();

        for (long tn : arrays) {
            long t = tn;
            Stack<Integer> qu = new Stack<>();
            do {
                qu.push((int) t % 10);
                t = t / 10;
            } while (t > 0);

            numMaps.put(tn, qu);
        }

        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays.length - i - 1; j++) {
                Stack<Integer> f = numMaps.get(arrays[j]);
                Stack<Integer> s = numMaps.get(arrays[j + 1]);
                // Compare the size 
                int fn = f.size() - 1;
                int sn = s.size() - 1;
                do {
                    if (f.get(fn) < s.get(sn)) {
                        break;
                    }

                    if (f.get(fn) > s.get(sn)) {
                        long tn = arrays[j];
                        arrays[j] = arrays[j + 1];
                        arrays[j + 1] = tn;
                        break;
                    }

                    fn--;
                    sn--;
                } while (fn >= 0 && sn >= 0);
                if (fn == -1 || sn == -1) {
                    fn = fn == -1 ? 0 : fn;
                    sn = sn == -1 ? 0 : sn;
                    if (f.get(fn) > s.get(sn)) {
                        long tn = arrays[j];
                        arrays[j] = arrays[j + 1];
                        arrays[j + 1] = tn;
                    }
                }

            }
        }
        StringBuffer sb = new StringBuffer();
        for (int i = arrays.length - 1; i >= 0; i--)
            sb.append(arrays[i]);

        return sb.toString();
    }

  perform Case data

 long a[] = new long[]{764, 76, 77};
 long b[] = new long[]{767, 76, 77};
 long c[] = new long[]{7864, 284, 347, 7732, 8498};

Execution results