如何用java编写一个矩阵的转置？

int a[][] = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4}};

创新互联建站服务紧随时代发展步伐，进行技术革新和技术进步，经过10余年的发展和积累，已经汇集了一批资深网站策划师、设计师、专业的网站实施团队以及高素质售后服务人员，并且完全形成了一套成熟的业务流程，能够完全依照客户要求对网站进行网站制作、成都网站建设、建设、维护、更新和改版，实现客户网站对外宣传展示的首要目的，并为客户企业品牌互联网化提供全面的解决方案。

int b[][] = new int [4][7];

for (int i = 0; i 4; i++) {

for (int j = 0; j 7; j++) {

b[i][j] = a[j][i];

}

}

System.out.println("矩阵a:");

for (int i = 0; i 7; i++) {

for (int j = 0; j 4; j++) {

if (j 3) {

System.out.print(a[i][j] + " ");

} else {

System.out.println(a[i][j] + " ");

}

}

}

System.out.println("矩阵a转置:");

for (int i = 0; i 4; i++) {

for (int j = 0; j 7; j++) {

if (j 6) {

System.out.print(b[i][j] + " ");

} else {

System.out.println(b[i][j] + " ");

}

}

}

代码写得烂不要喷我，我想解决思路就是这样吧！

用Java编程实现矩阵连续相乘问题

代码如下：

//按照步骤查找矩阵相乘结果，i=1表示第一次结果，i=2表示第二次结果，以此类推，如果i不合法则返回null

private static int[][] getMatrixsMultiByStep(int i, int[][]... matrixs) {

MapString, int[][] result = getMatrixsMultiResult(matrixs);

if(i=0 || iresult.size()) {

return null;

}

return result.get("" + i);

}

//对个矩阵相乘，临时结果和最终结果保存在Map中

private static MapString, int[][] getMatrixsMultiResult(int[][]... matrixs) {

MapString, int[][] result = new HashMapString, int[][]();

int[][] param = matrixs[0];

for(int i=1; imatrixs.length; i++) {

int[][] matrix = matrixs[i];

param = getMatrixMultiResult(param, matrix);

if(param == null) {

return null;

}

result.put("" + i, param);

}

return result;

}

//两个矩阵相乘，结果为一个矩阵，返回值为空表示两个矩阵不能相乘

private static int[][] getMatrixMultiResult(int[][] matrix1, int[][] matrix2) {

if(matrix2.length = 0) {

return matrix1;

}

if(matrix1.length=0 || matrix1[0].length!=matrix2.length) {

return null;

}

int[][] result = new int[matrix1.length][matrix2[0].length];

for(int i=0; imatrix1.length; i++) {

for(int j=0; jmatrix2[0].length; j++) {

result[i][j] = 0;

for(int k=0; kmatrix1[0].length; k++) {

result[i][j] += matrix1[i][k]*matrix2[k][j];

}

}

}

return result;

}

测试程序：

public static void main(String[] args) {

int[][] p1 = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};

int[][] p2 = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};

int[][] p3 = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};

int[][] p4 = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};

int[][] value = getMatrixsMultiByStep(2, p1, p2, p3, p4);

if(value != null) {

for(int i=0; ivalue.length; i++) {

for(int j=0; jvalue[0].length; j++) {

System.out.print(value[i][j] + " ");

}

System.out.println();

}

} else {

System.out.println("矩阵无法相乘！");

}

}

输出结果：

218 293 368

412 553 694

509 683 857

PS：JDK要5.0以上，二维数组模拟矩阵，兼容普通矩阵相乘哦

用java：利用二维数组,任意给出一个矩阵,编写实现矩阵转置的代码

借花献佛

/**

* 实现二维数组的转置

* @author HAN

*

*/

public class transposition_Arrays2D_ch6_4 {

final static double PI=3.1415;

public static void main(String[] args) {

/*StaticTest st1=new StaticTest();

StaticTest st2=new StaticTest();

st1.method2("HAN");*/

/*****定义要用于转置的二维数组*******/

int arr2D[][]={{1,2,3},{4,5,6},{7,8,9}};

/*****构造结果新二维数组用于存放转置结果*******/

/*定义结果数组变量，注意 一定要先开辟一个内存，

否则只是地址传递，也就是说两个数组名实际上指向的是同一块内存*/

//而构造二维数组可以为维度来进行，不一定是一个矩阵，即每一行的长度不一定相同

int result_arr[][]=new int[arr2D.length][];//先实现第一维

for(int i=0 ; iarr2D.length;i++){ //再实现第二维

result_arr[i]=new int[arr2D[i].length];

}

// int result_arr[][]=Arrays.copyOf(arr2D, arr2D.length);

//上面这个命令行行不通！

/*****输出用于转置的二维数组*******/

for (int x[]:arr2D){

for(int e:x){

System.out.print(e+" ");

}

System.out.println();

}

System.out.println();

/*******进行元素倒置******/

for(int i=0 ; iarr2D.length;i++){

for(int j=0; jarr2D[i].length;j++){

result_arr[j][i]=arr2D[i][j]; //转置核心

}

}

/*****show the result in the result matrix*******/

for (int x[]:result_arr){

for(int e:x){

System.out.print(e+" ");

}

System.out.println();

}

}

}

//import java.util.Arrays;

//public class transposition_Arrays2D {

//

// public static void main(String[] args) {

// int arr2D[][]={{1,2,3},{4,5,6},{7,8,9}};

// /*定义结果数组变量，注意 一定要先开辟一个内存，

// 否则只是地址传递，也就是说两个数组名实际上指向的是同一块内存*/

// int result_arr[][]=new int[arr2D.length][];

// for(int i=0 ; iarr2D.length;i++){

// result_arr[i]=new int[arr2D[i].length];

// }

//

//        // 进行元素倒置

//        for(int i=0 ; iarr2D.length;i++){

//         for(int j=0; jarr2D[i].length;j++){

//         result_arr[j][i]=arr2D[i][j];

//         }

//        }

//        

//        // show the result in matrix

//        for (int x[]:result_arr){

//         for(int e:x){

//         System.out.print(e);

//         }

//         System.out.println();

//        }

//        

// }

//

//}

用JAVA编写矩阵

public static void main(String[] args) throws Exception {

print(create(getNum()));

}

private static int getNum() {

Scanner scanner = new Scanner(System.in);

int n = 0;

do {

System.out.println("请输入要生成的阶数：");

String input = scanner.next();

if (isDigital(input)) {

n = Integer.parseInt(input);

if (n = 0) {

System.out.println("阶数必须大于0");

}

}

} while (n == 0);

return n;

}

private static int[][] create(int n) {

int[][] num = new int[n][n];

int ax = 1, ay = 0, x = 0, y = 0;

for (int m = 1; m = n * n; m++) {

num[x][y] = m;

int tmpx = x + ax;

int tmpy = y + ay;

if (tmpx = n || tmpx 0 || tmpy = n || tmpy 0 || num[tmpx][tmpy] != 0) {

if (ax == 0) {

ax = -ay;

ay = 0;

} else if (ay == 0) {

ay = ax;

ax = 0;

}

}

x += ax;

y += ay;

}

return num;

}

private static void print(int[][] num) {

int length = String.valueOf(num.length * num.length).length();

for (int i = 0; i num.length; i++) {

for (int j = 0; j num[i].length; j++) {

String tmp = String.valueOf(num[i][j]);

while (tmp.length() length) {

tmp = " " + tmp;

}

System.out.print(tmp + " ");

}

System.out.println();

}

}

private static boolean isDigital(String input) {

if (input == null || input.length() == 0) return false;

for (int i = 0; i input.length(); i++) {

char ch = input.charAt(i);

if (!Character.isDigit(ch)) {

System.out.println("输入的阶数必须为数字");

return false;

}

}

return true;

}

运行时输入要生成的阶数就可以了，比如生成问题上的矩阵输入4就可以了。

用java怎么写矩阵乘法？

import java.util.Scanner; 

public class Matrix { 

public double[][] create() { 

Scanner sc = new Scanner(System.in) ; 

System.out.print（＂请输入矩阵的行高：＂）； 

int a = sc.nextInt() ; 

System.out.print（＂请输入矩阵的列宽：＂）； 

int b = sc.nextInt() ; 

double[][] x = new double[a][b] ; 

for(int i=0;ilt;a;i++){ 

for(int j=0;jlt;b;j++){ 

System.out.print（＂请输入元素x[＂+i+＂][＂+j+＂]的值：＂ ）； 

x[i][j] = sc.nextDouble() ; 

} 

} 

return x ; 

} 

public double[][] multiply(double[][] x,double[][] y){ 

double[][] result = null ; 

int a = x[0].length ; 

int b = y.length ; 

if(a != b){ 

System.out.println（＂输入的维数不匹配，不能进行运算＂）； 

}else{ 

int c = x.length ; 

int d = y[0].length ; 

result = new double[c][d] ; 

for(int i=0;ilt;c;i++){ 

for(int j=0;jlt;d;j++){ 

double sum = 0 ; 

for(int k=0;klt;a;k++){ 

sum += x[i][k]*y[k][j] ; 

} 

result[i][j] = sum ; 

} 

} 

} 

return result ; 

} 

public void print(double[][] x){ 

System.out.println（＂矩阵为：＂）； 

for(int i=0;ilt;x.length;i++){ 

for(int j=0;jlt;x[i].length;j++){ 

System.out.print(x[i][j] + ＂ ＂) ; 

} 

System.out.println(); 

} 

} 

} 

测试类： 

public class TestMatrix { 

public static void main(String[] args) { 

Matrix m = new Matrix() ; 

//double[][] x = {{1,2},{3,2}} ; 

//double[][] y = {{1,2,1},{2,3,3}} ; 

System.out.println（＂创建第一个数组：＂） ； 

double[][] x = m.create() ; 

m.print(x) ； //用来验证输入的是否和你一样的，没啥作用 

System.out.println（＂创建第二个数组：＂）； 

double[][] y = m.create() ; 

m.print(y) ； //用来验证输入的是否和你一样的，没啥作用 

double[][] result = m.multiply(x, y) ; 

if(result == null){ 

return ； //如果输入的矩阵不能运算就不输出结果了。 

} 

m.print(result) ; 

} 

}

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

Java编写一个程序实现矩阵的运算加减乘除，（并对其中的异常进行处理）

/**

* 矩阵：由 m × n 个数Aij排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵

* 说白了就是一个二维数组，下面的程序用整形作为数据类型，其他类型运算大同小异

* 

*/

public class MatrixUtils {

/**

* 矩阵运算：加(减法与之类似)

*/

public static int[][] matrixAdd(int[][] addend, int[][] summand) {

if (addend == null || addend.length == 0) {

throw new IllegalArgumentException("addend matrix is empty!");

}

if (summand == null || summand.length == 0) {

throw new IllegalArgumentException("summand matrix is empty!");

}

//矩阵加减要求两个矩阵类型一致，即行列数相同

int row = addend.length;

int col = addend[0].length;

if (row != summand.length || col != summand[0].length) {

throw new IllegalArgumentException("summand and summand not the same type!");

}

int[][] sum = new int[row][col];

for (int i = 0; i  row; i++) {

for (int j = 0; j  col; j++) {

sum[i][j] = addend[i][j] + summand[i][j];

// sum[i][j] = addend[i][j] - summand[i][j]; //减法

}

}

return sum;

}

/**

* 矩阵运算：乘法,没找到除法的运算规则

*/

public static int[][] matrixMultiply(int[][] addend, int[][] summand) {

if (addend == null || addend.length == 0) {

throw new IllegalArgumentException("addend matrix is empty!");

}

if (summand == null || summand.length == 0) {

throw new IllegalArgumentException("summand matrix is empty!");

}

//两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义。如A是m×n矩阵和B是n×p矩阵，它们的乘积C是一个m×p矩阵 

int row = addend.length;

int col = summand[0].length;

if (addend[0].length != summand.length) {

throw new IllegalArgumentException("summand and summand not the same type!");

} 

int[][] sum = new int[row][col];

for (int i = 0; i  row; i++) {

for (int j = 0; j  col; j++) {

for (int z = 0; z  addend[0].length; z++) {

sum[i][j] += addend[i][z] * summand[z][j];

System.out.println("sum[" + i+  "]["+ j+"]= " + sum[i][j]);

}

}

}

return sum;

}

}

新闻名称：矩阵用java代码实现 矩阵乘法java代码
本文路径：http://pwwzsj.com/article/dodgijc.html