Here is a hint on how to make this much easier and optimize the runtime: Go through the prices array backwards.

Second hint: track the maximum price and the current price. Use that to find your profits.

public static long stockmax(List<int> prices)
{
    var profit = 0L;
    var max = prices.Count()-1;
    while(max > 0){
        var i = max-1;
        while(i >= 0 && prices[i] <= prices[max]){
            profit += prices[max] - prices[i];
            i--;
        }
        max = i;
    }
    return profit;
}

Java O(n)

  public static long stockmax(List<Integer> prices) {
        long maxProfit = 0;
        int maxFuturePrice = 0;

        for (int i = prices.size() - 1; i >= 0; i--) {
            if (prices.get(i) > maxFuturePrice) {
                maxFuturePrice = prices.get(i);
            }
            maxProfit += maxFuturePrice - prices.get(i);
        }

        return maxProfit;
    }

Java 8 solution using Recurssive method calls:

public static long stockmax(List<Integer> prices) {
    // Write your code here
    // Find the max val of the list and find the index. If the index of max val is 0 then no profit can be made and return 0.
    // else profit can be made. Sell the stock at the max index.
    // Corner case, need to check the max index for the remaining sub-list after max index to verify the another opportunity.
    long profit = 0L;

    int maxIndex = prices.indexOf(Collections.max(prices));
    if(maxIndex == prices.size()-1){
        return getProfitFromSubList(prices);
    }
    else{
        List<Integer> subList1 = prices.subList(0,maxIndex+1);
        List<Integer> subList2 = prices.subList(maxIndex+1, prices.size());

        profit = getProfitFromSubList(subList1);
        profit += stockmax(subList2);
    }

    return profit;

}//method

public static long getProfitFromSubList(List<Integer> subList){
    long costPrice = 0L;
    int cnt = 0;

    for(int i =0; i < subList.size()-1; i++){
        costPrice += subList.get(i);
        cnt++;
    }
    long sellPrice = subList.get(subList.size()-1) * cnt;
    return sellPrice-costPrice;
}