List集合转二维数组以及数组的基本操作

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

/**
 * @author : Li Xiaochangx
 * @date : 2019/12/27
 */
public class TurnArray {
    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        List<String> b = new ArrayList<>();
        for (int i = 1; i < 7; i++) {
            if(i<4){
                a.add("哈"+i);
            }else{
                b.add(i+"");
            }
        }
        System.out.println(a+"-------"+b);

        List<List<String>> list = Arrays.asList(a, b);
        System.out.println("============="+list);

        String[][] temps = new String[list.size()][];
        for (int i = 0; i < temps.length; i++) {
            temps[i] = new String[list.get(i).size()];
            for (int j = 0; j < temps[i].length; j++) {
                temps[i][j] = list.get(i).get(j);
            }
        }

        System.out.println("翻转前：=============");
        visit(temps);

        String[][] reverse = reverse(temps);

        System.out.println("翻转后：=============");
        visit(reverse);

    }

    /**
     * 二维数组转置
     *
     * @param arry
     */
    public static String[][] reverse(String arry[][]) {
        String[][] temps = new String[arry[0].length][arry.length];
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < arry[i].length; j++) {
                temps[j][i] = arry[i][j];
            }
        }
        return temps;
    }

    /**
     * List转数组
     *
     * @param v
     * @return
     */
    public String[][] listToArray(List<List<String>> v) {
        String[][] temps = new String[v.size()][];
        for (int i = 0; i < temps.length; i++) {
            temps[i] = new String[v.get(i).size()];
            for (int j = 0; j < temps[i].length; j++) {
                temps[i][j] = v.get(i).get(j);
            }
        }
        return temps;
    }

    /**
     * 二维数组 每一列的最大值
     *
     * @param v
     * @return
     */
    private Double[] maxValueOfColumn(Double[][] v) {
        Double[] max = new Double[v[0].length];
        for (int i = 0; i < v[0].length; i++) {
            max[i] = v[0][i];
            for (int j = 1; j < v.length; j++) {
                if (max[i] < v[j][i]) {
                    max[i] = v[j][i];
                }
            }
        }
        return max;
    }

    /**
     * 二维数组 每一列的最小值
     *
     * @param v
     * @return
     */
    private Double[] minValueOfColumn(Double[][] v) {
        Double[] min = new Double[v[0].length];
        for (int i = 0; i < v[0].length; i++) {
            min[i] = v[0][i];
            for (int j = 1; j < v.length; j++) {
                if (min[i] > v[j][i]) {
                    min[i] = v[j][i];
                }
            }
        }
        return min;
    }

    /**
     * 二维数组 所有数据的最大值
     *
     * @param v
     * @return
     */
    public Double max(Double[][] v) {
        Double temp = 0.0;
        for (int i = 0; i < v.length; i++) {
            for (int j = 0; j < v[i].length; j++) {
                if (v[i][j] > temp) {
                    temp = v[i][j];
                }
            }
        }
        return temp;
    }

    /**
     * 二维数组 每一列的和
     *
     * @param v
     * @return
     */
    public Double[] sumOfColumn(Double[][] v) {
        Double[] sum = new Double[v[0].length];
        for (int i = 0; i < v[0].length; i++) {
            sum[i] = v[0][i];
            for (int j = 1; j < v.length; j++) {
                sum[i] += v[j][i];
            }
        }
        return sum;
    }

    /**
     * 二维数组 每一行的和
     *
     * @param v
     * @return
     */
    public Double[][] sumOfRow(Double[][] v) {
        for (int i = 0; i < v.length; i++) {
            for (int j = 1; j < v[i].length; j++) {
                v[i][0] += v[i][j];
            }
        }
        Double[][] results = new Double[v.length][1];
        for (int i = 0; i < results.length; i++) {
            results[i][0] = v[i][0];
        }
        return results;
    }

    /**
     * 一维数组 求和
     *
     * @param v
     * @return
     */
    public Double sum(Double[] v) {
        Double sum = 0.0;
        for (int i = 0; i < v.length; i++) {
            sum += v[i];
        }
        return sum;
    }

    /**
     * 取精度 小数点后2位
     *
     * @param v
     * @return
     */
    public String[][] format(Double[][] v) {
        String[][] results = new String[v.length][v[0].length];
        for (int i = 0; i < v.length; i++) {
            for (int j = 0; j < v[i].length; j++) {
                results[i][j] = String.format("%.2f", v[i][j]);
            }
        }
        return results;
    }

    /**
     * 二维数组遍历
     *
     * @param v
     */
    public static void visit(Object[][] v) {
        for (int i = 0; i < v.length; i++) {
            for (int j = 0; j < v[0].length; j++) {
                System.out.print(v[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    /**
     * 一维数组遍历
     *
     * @param v
     */
    public void visit02(Object[] v) {
        for (int i = 0; i < v.length; i++) {
            System.out.print(v[i] + " ");
        }
        System.out.println();
    }
}