已知5个矩阵并可连乘，java编写程序输出矩阵连乘的最优计算次序。

这是一个经典的动态规划问题，可以使用动态规划算法来解决。具体步骤如下：

1. 建立一个二维数组dp，其中dp[i][j]表示从第i个矩阵到第j个矩阵的最优计算次序所需的最小乘法次数。

2. 初始化dp数组。对于任意i，dp[i][i]的值为0，因为一个矩阵不需要乘以自己。

3. 使用一个循环枚举计算矩阵乘法的区间长度len，从2开始到n（n为矩阵的数量）。在每一轮循环中，再使用一个循环枚举区间起始点i，计算dp[i][i+len-1]的值。

4. 对于dp[i][i+len-1]，枚举分割点k，计算dp[i][k]+dp[k+1][i+len-1]+matrix[i-1]*matrix[k]*matrix[i+len-1]的值，其中matrix[i-1]表示第i个矩阵的行数，matrix[k]表示第k个矩阵的列数，matrix[i+len-1]表示第i+len-1个矩阵的列数。取所有可能的k中的最小值作为dp[i][i+len-1]的值。

5. 最终dp[1][n]的值即为连乘这些矩阵的最小乘法次数。

6. 为了输出最优计算次序，还需要记录一个二维数组s，其中s[i][j]表示从第i个矩阵到第j个矩阵的最优计算次序的分割点。在计算dp[i][i+len-1]的时候，记录最小的k值，即可更新s[i][i+len-1]的值。

7. 使用递归函数输出最优计算次序。从s[1][n]开始，如果分割点为k，则先递归输出s[1][k]，再递归输出s[k+1][n]。

下面是Java代码实现：

public class MatrixChainMultiplication {
    public static void main(String[] args) {
        int[] matrix = {10, 20, 30, 40, 30}; // 5个矩阵的行列数
        int n = matrix.length - 1; // 矩阵数量
        int[][] dp = new int[n+1][n+1]; // dp数组
        int[][] s = new int[n+1][n+1]; // s数组
        for (int i = 1; i <= n; i++) {
            dp[i][i] = 0; // 初始化dp[i][i]为0
        }
        for (int len = 2; len <= n; len++) {
            for (int i = 1; i <= n-len+1; i++) {
                int j = i + len - 1;
                dp[i][j] = Integer.MAX_VALUE;
                for (int k = i; k < j; k++) {
                    int cost = dp[i][k] + dp[k+1][j] + matrix[i-1]*matrix[k]*matrix[j];
                    if (cost < dp[i][j]) {
                        dp[i][j] = cost;
                        s[i][j] = k;
                    }
                }
            }
        }
        System.out.println("最小乘法次数：" + dp[1][n]);
        System.out.println("最优计算次序：");
        printOptimalOrder(s, 1, n);
    }
    // 递归输出最优计算次序
    private static void printOptimalOrder(int[][] s, int i, int j) {
        if (i == j) {
            System.out.print("A" + i);
        } else {
            System.out.print("(");
            printOptimalOrder(s, i, s[i][j]);
            printOptimalOrder(s, s[i][j]+1, j);
            System.out.print(")");
        }
    }
}

输出结果为：

最小乘法次数：30000
最优计算次序：
((A1(A2A3))((A4)A5))