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] + " ");
}
}
}
代码写得烂不要喷我，我想解决思路就是这样吧！
代码如下：
//按照步骤查找矩阵相乘结果，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以上，二维数组模拟矩阵，兼容普通矩阵相乘哦
借花献佛
/**
* 实现二维数组的转置
* @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();
// }
//
// }
//
//}
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就可以了。
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应用程序、分布式系统和嵌入式系统应用程序等。
/**
* 矩阵：由 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;
}
}
重庆分公司
重庆分公司
