现有一个整形数组，可以重新排列数组中的元素，也可以任意删除元素，使得新数组a按照以下公式：sum = ∑a [i]*(i+1) 计算的和最大。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        String strTemp = scanner.next();
        String strNums[] = strTemp.substring(1, strTemp.length() - 1).split(",");
        int nums[] = new int[strNums.length];
        for (int i = 0; i < strNums.length; i++) {
    
     // 将字符串数组转为整数数组
            nums[i] = Integer.valueOf(strNums[i]);
        }
//        int nums[] = {-2, -5, 0, 4, -7}; // 测试用例
        int val = printDelMax(nums);
        System.out.println(val);
    }

//    /**
//     * 不删除元素，重排序之后选择部分元素（初始思路改变了题意）
//     *
//     * @param nums
//     * @return
//     */
//    private static int printMax(int nums[]) {
    
    
//        Arrays.sort(nums); // 升序出现最大值
//        int dp[][] = new int[nums.length + 1][2];
//        dp[0][0] = 0;
//        dp[0][1] = 0;
//        for (int i = 0; i < nums.length; i++) { // 加或者不加
//            dp[i + 1][0] = dp[i][0] + nums[i] * (i + 1);
//            dp[i + 1][1] = Math.max(dp[i + 1][0], dp[i][0]);
//            dp[i + 1][0] = dp[i + 1][1]; // 每次把值更新一下
            System.out.println(dp[i + 1][1]+"->"); // 用于测试
//        }
//        return dp[nums.length][0];
//    }

    /**
     * 删除元素
     *
     * @param nums
     * @return
     */
    private static int printDelMax(int nums[]) {
    
    
        int val = 0; // 用于返回结果
        Arrays.sort(nums);
        List<Integer> lists = arrToList(nums); // 将数组转为List
        int notZeroIndex = 0;
        /**
         * 说明：最大值一定是所有的非负数都加和，所以这里仅考虑是否需要有负数参与
         */
        for (int i = lists.size() - 1; i >= 0; i--) {
    
     // 记录下最后一个负数位置
            if (lists.get(i) < 0) {
    
    
                notZeroIndex = i;
                break;
            }
        }
        int position = notZeroIndex + 1; // 非负元素加和
        for (int i = notZeroIndex; i >= 0; i--) {
    
     // 加负数之后是否改变了序列求和最大值（val中始终保持最大值）
            val = Math.max(sum(copyList(lists, position)), sum(copyList(lists, notZeroIndex)));
        }
        return val;
    }


    /**
     * 将数组转为List
     *
     * @param nums
     * @return
     */
    private static List<Integer> arrToList(int nums[]) {
    
    
        List<Integer> lists = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
    
    
            lists.add(nums[i]);
        }
        return lists;
    }

    /**
     * 对List求和
     *
     * @param lists
     * @return
     */
    private static int sum(List<Integer> lists) {
    
    
        int sum = 0;
        for (int i = 0; i < lists.size(); i++) {
    
    
            sum += lists.get(i) * (i + 1);
        }
        return sum;
    }

    /**
     * 从index开始复制List
     *
     * @param lists
     * @param index
     * @return
     */
    private static List<Integer> copyList(List<Integer> lists, int index) {
    
    
        List<Integer> listCopy = new ArrayList<>();
        for (int i = 0; i < lists.size() - index; i++) {
    
    
            listCopy.add(lists.get(index + i));
        }
        return listCopy;
    }
}