首页 / JAVA / 用Java写一个求逆矩阵的程序 2.0

用Java写一个求逆矩阵的程序 2.0

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了用Java写一个求逆矩阵的程序 2.0，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12690字，纯文字阅读大概需要19分钟。

内容图文

用Java写一个求逆矩阵的程序 2.0

变更记录

对上次的源程序程序进行了少许改动，
修复了输入3阶以上的矩阵会出现数组下标超出的BUG
修复了矩阵的行列式的值没有除相应的分母的BUG
修复了对矩阵求余子式计算错乱的BUG
在源码上添加了一些必要的解释

简析

函数在计算逆矩阵时会先调用这个函数
public void InvsIntM(int[][] E,int step)
这也是求逆矩阵的核心函数，由这个函数来调用程序其他的模块，最终实现逆矩阵的运算。那么它具体怎么协调调用其他的函数的呢，我们来看一下这个函数的实现代码。

public void InvsIntM(int[][] E,int step)//计算逆矩阵进行函数调用的核心函数
    {
        int[][] A = new int[row][row];
        for(int i = 0;i < row;i++)
            for (int j = 0;j < row;j++)
                A[i][j] = E[i][j];
        CacuIntValue(A,row,1);
        DeteValue.setFenzi(Value.getFenzi()/Value.getGcd());//将行列式的值设置为最简状态
        DeteValue.setFenmu(Value.getFenmu()/Value.getGcd());
        if(step == 1) {System.out.print("|A| = " );DeteValue.show();System.out.println("");}
        if(DeteValue.getFenzi() == 0)
            System.out.println("哎呦，|A| = 0 这是个奇异矩阵，不可逆！！！！");
        else {
            CompMatr(E,step);//调用求伴随矩阵的函数
            for(int i = 0;i < row;i++)
                for (int j = 0;j < row;j++)
         CM[i][j] = new Fraction(CM[i][j].getFenzi()*DeteValue.getFenmu(),CM[i][j].getFenmu()*DeteValue.getFenzi());
        if(step == 1)
        {
            System.out.println("A-1 = A* / |A| =");
        }

        CMShow();}

    }

首先上去一个For循环目的是为了将所输入的矩阵进行备份，全部的都复制到数组A中，然后用这个数组A来作为调用计算本矩阵对应的行列式的值的参数之一， CacuIntValue(A,row,1);第二个数表示矩阵是几阶的，并且将其作为循环的限界条件。
计算完之后数据被分数类的对象Value 保存。并通过Value将矩阵对应的行列式的值的数据传给DeteValue，从此DeteValue保持不变，它就是所输入的矩阵对应的行列式的值。并且这个值如果是分数他一定是最简分数。
DeteValue.setFenzi(Value.getFenzi()/Value.getGcd());
DeteValue.setFenmu(Value.getFenmu()/Value.getGcd());

之后是一个IF语句来决定是否输出行列式的值
if(step == 1 )
{System.out.print("|A| = " );
DeteValue.show();
System.out.println("");
}
再往后再判断一下所输入的矩阵是否为奇异矩阵，即行列式为0 的矩阵
if( DeteValue.getFenzi() == 0 )
System.out.println(“哎呦，|A| = 0 这是个奇异矩阵，不可逆！！！！”);
else
否则才进行下面的计算:
调用求伴随矩阵的函数求出伴随矩阵的每一个元素然后存到一个数组中
对伴随矩阵中的每一个元素的值都除以DeteValue并把它赋值给 Fraction类的二维数组 CM中的相应位置的元素

CompMatr(E,step);//调用求伴随矩阵的函数
            for(int i = 0;i < row;i++)
                for (int j = 0;j < row;j++)
         CM[i][j] = new Fraction(CM[i][j].getFenzi()*DeteValue.getFenmu(),CM[i][j].getFenmu()*DeteValue.getFenzi());

最后再判断是否要输出以下内容

if(step == 1)
{
System.out.println(“A-1 = A* / |A| =”);
}
最后调用输出最终结果的函数输出逆矩阵
CMShow();}

改进后的全部代码：

Main 函数：

package com.liable;
import java.util.Scanner;
public class Main extends Matrix{

    public static void main(String[] args) {
	int row,column;// 矩阵的行列数2
     Scanner sc = new Scanner(System.in);
     row = sc.nextInt();
     column = row;
     int[][] m = new int[row][column];
     for(int i = 0;i < row;i++)
     {
         for(int j = 0 ; j < column; j++)
             m[i][j] = sc.nextInt();
     }
       Matrix E = new Matrix(row);
     E.setIntMatrix(m);
     E.printInt(m,row);
     System.out.println(" ");
     E.InvsIntM(m,1);
     sc.close();
    }
}

Matrix 类：

package com.liable;
public class Matrix extends Fraction{
    private int row = 0,column = 0;//矩阵的行和列
    //private int M[][];//整形的矩阵
    private int Ma[][];//备份储存整形的矩阵的原始数据
    private Fraction Value = new Fraction(1,1);//行列式的值，初始化为1
    private Fraction DeteValue = new Fraction(1,1);//矩阵行列式的值，一旦求出不再改变
    private Fraction matr[][];//分数型矩阵
    private Fraction CM[][];//伴随矩阵
    private int IMstep = 1;//决定是否生成步骤的，如果是那就是1默认不生成求解步骤
    private int CMstep = 0;//伴随矩阵中余子式的步骤是否生成
    Matrix(){}
    Matrix(int row)
    {
        if(row == 0)
            System.out.println("哎呦，行和列等于零咋算啊");
        else if(row < 0)
            System.out.println("哎呦，行列数小于0咋算啊");
        else{
     this.row = row;
     column = row;}
    }
    Matrix(int row,int column)
    {
        if(row == 0 || column == 0)
            System.out.println("哎呦，行和列等于零咋算啊");
        else if(row < 0 || column < 0)
            System.out.println("哎呦，行列数小于0咋算啊");
        else{
        this.row = row;
        this.column = column;}
    }
    public void setIntMatrix(int[][] a)//初始化整形矩阵
    {
        if(row == 0 || column == 0)
            System.out.println("哎呦，还没初始化行和列呢");
        else{
       // M = new int[row][column];
        Ma = new int[row][column];
        for(int i = 0; i < row;i++)
        {
            for(int j = 0; j < column;j++) {
               // M[i][j] = a[i][j];
                Ma[i][j] = a[i][j];
            }
        }}
        //Value = CacuIntValue();//调用计算行列式的函数完成初始化
    }
    public void setFraMatrix(int a[][],int b[][])//初始化分数矩阵的成员
    {
        matr = new Fraction[row][column];
        for(int i = 0; i < row;i++)
        {
            for(int j = 0; j < column;j++)
            {
                matr[i][j] = new Fraction(a[i][j],b[i][j]);
            }
        }
    }
    private void SwapMatr(int a, int b,int[][] M)//输入两个行数来交换二维数组的两行
    {
        for(int i = 0 ; i < column ;i++)
        {
            int temp = M[a][i];
            M[a][i] = M[b][i];
            M[b][i] = temp;
        }
    }
    private void CaValCoeff(int i,int[][] Coeff,int[][] M,int R)//求出每一行与对角线元素对应行做差时的系数，并存在数组中
    {                                //如果要处理的是第一列，那么i=0
        int k = 0;                   //并且这个2行10列的数组第一行存储对角元素下的行的系数
       for(int j = i+1;j < R; j++)//第二行存储对角线元素所对应的行的系数
       {
          if(M[i][i] == M[j][i])
          {
              Coeff[0][k] = 1;
              Coeff[1][k] = 1;
          }
          else if(M[i][i] < M[j][i] )
          {
              if(M[j][i] == 0) {
                  Coeff[0][k] = 1;
                  Coeff[1][k] = 0;
              }
              else if(M[j][i] % M[i][i] == 0){
                     Coeff[0][k]=1;
                     Coeff[1][k]=M[j][i]/M[i][i];
              }else{
                  Coeff[0][k]=M[i][i];
                  Coeff[1][k]=M[j][i];
                  if(Coeff[0][k] < 0 && Coeff[1][k] < 0)
                  {
                      Coeff[0][k] *= -1;
                      Coeff[1][k] *= -1;
                  }
              }
          }
          else if(M[i][i] > M[j][i])
          {
              if(M[j][i] == 0) {
                  Coeff[0][k] = 1;
                  Coeff[1][k] = 0;
              }
              else if( M[i][i] % M[j][i] == 0){
                  Coeff[0][k]=M[i][i]/M[j][i];
                  Coeff[1][k]=1;
              }else{
                  Coeff[0][k]=M[i][i];
                  Coeff[1][k]=M[j][i];
                  if(Coeff[0][k] < 0 && Coeff[1][k] < 0)
                  {
                      Coeff[0][k] *= -1;
                      Coeff[1][k] *= -1;
                  }
              }

          }else;
          k++;
       }

    }
    private void MoveM(int i,int a,int b,int l,int[][] M,int R)//对已经确定系数的高阶行列式进行变换
    {
        for(int j = 0;j < R;j++)
        {
            M[i][j] = a*M[i][j]-b*M[l][j] ;
        }
        Value.setFenmu(Value.getFenmu()*a);
    }
    private void printCaIntVStep( int[][] Coeff,int j,int k,int i,int[][] M,int R)//负责输出计算矩阵对应行列式的值的过程
    {
        if(Coeff[0][k] == 0 && Coeff[1][k] == 0) {
            System.out.print(" " + "r" + (i + 1) + "<->" + "r" + (j + 1));
            System.out.print(" 系数：");
            Value.show();
            System.out.println(" ");
            printInt(M,R);
            System.out.println(" ");
        }
       else{ if(Coeff[0][k] == 1)
        System.out.print(" ");
        else
        System.out.print(Coeff[0][k]);
        System.out.print("r"+(j+1)+" - ");
        if(Coeff[1][k] == 1)
        System.out.print(" ");
        else
        System.out.print(Coeff[1][k]);
        System.out.print("r"+(i+1));
        System.out.print(" 系数：");
        Value.show();
        System.out.println(" ");
        printInt(M,R);
        System.out.println(" ");}
    }
    public Fraction CacuIntValue(int[][] M,int R ,int step)//求出所给方阵对应的行列式的值
    {

       if(R == 0)//先判断是几阶的，之后再选择用何种办法求
        return  Value = new Fraction(0,1);
    else if(R == 1 )
        return Value = new Fraction(M[0][0],1);
    else if(R == 2)//二阶的直接求
    {
        int a = M[0][0]*M[1][1] - M[0][1]*M[1][0];
        return Value = new Fraction(a,1);
    }
    else//对于3阶向上的用
    {
        for(int i = 0;i < R-1;i++)
        {//把每一列的元素除了从上往下数对角线元素下面的都设置为零。
            int a = 1, b = 1;
            int[][] Coeff = new int[2][10];
            int[][] Enmpty = new int [2][1];
            Enmpty[0][0] = 0;
            Enmpty[1][0] = 0;
            if (M[i][i] == 0) //如果有对角线上的元素等于零
            {
                for(int k = (i+1); k < R; k++)
                {//往下找看看有没有不等于零的元素，如果有就跟他交换元素
                    if (M[k][i] != 0)
                    {
                        SwapMatr(i, k,M);
                        Value.setFenzi(-1);
                        if(step == 1)
                            printCaIntVStep(Enmpty,k,0,i,M,R);
                    } else ;
                }
                continue;//走完for循环都没找到不为零的，那太好了
                // 这一列(i列)从M [i][i]开始（包括M[i][i]）往下都是0，还变换啥啊
            } else
            {
                CaValCoeff(i,Coeff,M,R);//计算出每次做差的系数放到数组存起来
                int k = 0;
                for(int j = i+1;j < R;j++)
                {
                    if(Coeff[0][k] == 1 && Coeff[1][k] == 0);
                    else
                        MoveM(j,Coeff[0][k],Coeff[1][k],i,M,R) ;//对矩阵进行相应的变换
                    if(step == 1)//是否输出步骤
                        printCaIntVStep(Coeff,j,k,i,M,R);//输出步骤
                    k++;
                }
            }
        }
        for(int i = 0; i < R;i++)
         Value.setFenzi(Value.getFenzi()*M[i][i]);
         Value.Setgcd();
        return DeteValue;
    }}
    private void InitCofa(int[][] a,int[][] b, int i,int j)
    {
        int p = 0,q = 0;
        for(int k = 0;k < row;k++)
        {
         if(k == i) continue;
         else
         for (int l = 0;l < row;l++)
         {
          if(l == j) continue;
          else
          {
              a[p][q] = b[k][l];
              q++;
              if(q == row-1)
              {
                  q = 0;
                  p++;
              }

           }
         }
        }
    }
    private void transCM()//对矩阵进行转置的函数，即进行行列互换
    {

        for(int i = 0;i < row;i++)
            for (int j = i+1;j <row;j++)
            {
            if ((i + j + 2) % 2 != 0)
            {
                CM[i][j].setFenzi(-1*CM[i][j].getFenzi());
                CM[j][i].setFenzi(-1*CM[j][i].getFenzi());
            }

            Fraction temp = new Fraction(CM[i][j].getFenzi(),CM[i][j].getFenmu());
            CM[i][j] = new Fraction(CM[j][i].getFenzi(),CM[j][i].getFenmu());
            CM[j][i] = new Fraction(temp.getFenzi(),temp.getFenmu());
            }

    }
    private void printCompStep()//输出求余子式的计算过程的函数
    {
        System.out.println("余子式：");
        for(int i = 0;i < row;i++) {
            for (int j = 0; j < row; j++)
            {
                System.out.print("M"+(i+1)+(j+1)+" = ");
                CM[i][j].show();
                System.out.print(" ");
            }
           ;
            System.out.println(" ");
        }
    }

    private void printCpMaStep()//输出伴随矩阵的函数
    {
        System.out.println("A* =");
        for(int i = 0;i < row;i++) {
            for (int j = 0; j < row; j++)
            {
                CM[i][j].show();
                System.out.print(" ");
            }
                ;
                System.out.println(" ");
            }
    }
    public void CompMatr(int[][] E,int step)//计算伴随矩阵的核心函数
    {
         int [][] Cofa = new int[row-1][row-1];//定义一个小一阶的数组来储存余子式cofactor
         CM = new Fraction[row][row];
        // if(row == 2)

         for(int i = 0;i < row;i++)
         {
             for(int j = 0;j < row;j++)
             {
                 InitCofa(Cofa,E,i,j);
                 Value = new Fraction(1,1);
                 CacuIntValue(Cofa, row-1,0);
                 CM[i][j] = new Fraction(Value.getFenzi(),Value.getFenmu());
                 Value = new Fraction(1,1);
             }
         }
         if(step == 1)
          printCompStep();
         transCM();//调用转置矩阵的函数
        if(step == 1)
            printCpMaStep();
    }
    public void InvsIntM(int[][] E,int step)//计算逆矩阵进行函数调用的核心函数
    {
        int[][] A = new int[row][row];
        for(int i = 0;i < row;i++)
            for (int j = 0;j < row;j++)
                A[i][j] = E[i][j];
        CacuIntValue(A,row,1);
        DeteValue.setFenzi(Value.getFenzi()/Value.getGcd());//将行列式的值设置为最简状态
        DeteValue.setFenmu(Value.getFenmu()/Value.getGcd());
        if(step == 1) {System.out.print("|A| = " );DeteValue.show();System.out.println("");}
        if(DeteValue.getFenzi() == 0)
            System.out.println("哎呦，|A| = 0 这是个奇异矩阵，不可逆！！！！");
        else {
            CompMatr(E,step);//调用求伴随矩阵的函数
            for(int i = 0;i < row;i++)
                for (int j = 0;j < row;j++)
         CM[i][j] = new Fraction(CM[i][j].getFenzi()*DeteValue.getFenmu(),CM[i][j].getFenmu()*DeteValue.getFenzi());
        if(step == 1)
        {
            System.out.println("A-1 = A* / |A| =");
        }

        CMShow();}

    }
    public void printInt(int[][] M,int R)//输出整型矩阵成员
    {
        for(int i = 0;i < R;i++) {
            for (int j = 0; j < R; j++)
            {if(M[i][j] >= 0)
             System.out.print(" ");
             System.out.print(String.format("%-3d",M[i][j]) + " " );
             if(M[i][j] < 0)
             System.out.print(" ");
            }System.out.println();
        }

    }
    public void printFra()//输出分数类的矩阵成员
    {

        for(int i = 0;i < row;i++) {
            for (int j = 0; j < column; j++) {
                matr[i][j].show();
                System.out.print(" ");
            }
            System.out.println();
        }
    }
    private void CMShow()//输出最终的逆矩阵  数据类型 分数类对象
    {
        for(int i = 0;i < row;i++) {
            for (int j = 0; j < column; j++) {
                CM[i][j].show();
                System.out.print(" ");
            }
            System.out.println();
            System.out.println();
        }
    }
    public int GetIntMatr(int i,int j)
    {
        return Ma[i][j];
    }
    public void showOringIntM()//负责输出原始的矩阵
    {
        for(int i = 0;i < row;i++) {
            for (int j = 0; j < column; j++)
            {if(Ma[i][j] >= 0)
                System.out.print(" ");
                System.out.print(String.format("%-3d",Ma[i][j]) + " " );
                if(Ma[i][j] < 0)
                    System.out.print(" ");
            }System.out.println();
        }
    }
    public Fraction GetFraMatr(int i,int j)
    {
       return matr[i][j];
    }

    void getValue() {

       Value.show();
    }
}

Fraction 类分数类：

package com.liable;

public class Fraction {
    private int fenzi=0 , fenmu=1;
    private int gcd = 0;///分子分母的最大公约数

    private int abs(int x)
    {
        if(x < 0)
            return -x;
        return x;
    }
    private int f_gcd(int a, int b)///辗转相除法求两个正整数的最大公约数 例如：a=14 b = 21
    {
        if( a * b == 0)
            return 1;
        int g;
        if(a < b)
        {
            int t = a;
            a = b;
            b = t;
        }///a = 21  b = 14
        g = b;///g = 14
        while(a % b != 0)
        {
            g = a % b;///g = 7
            a = b;///a = 14
            b = g;///b = 7
        }
        return g;
    }
     Fraction(){}
     Fraction(int fenzi)
    {
        this.fenzi = fenzi;
        fenmu = 1;
        gcd = 1;
    }
     Fraction(int fenzi, int fenmu )//:fenzi(fenzi), fenmu(fenmu)
    {
        this.fenzi = fenzi;
        this.fenmu = fenmu;
        gcd = f_gcd(abs(fenzi), abs(fenmu));
    }
    public void show()
    {
        if(fenmu == 0)
        {
            System.out.println("Error!!");
            return;
        }
        if(fenzi == 0)
        {
            System.out.print("0");
            return;
        }
        if(fenzi * fenmu < 0)
            System.out.print("-");
        else System.out.print(" ");//为了保证输出能做到行列对齐。如果前面没有负号输出一个空格来占一位
        System.out.print(String.format("%-2d",abs(fenzi)/gcd));//分子最低占两位
        if(abs(fenmu)/gcd != 1)
            System.out.print("/"+ String.format("%-3d",abs(fenmu)/gcd));//分母最低占三位
        else System.out.print("    ");


    }

    public void setFenzi(int fenzi) {
        this.fenzi = fenzi;
    }

    public void setFenmu(int fenmu) {
        this.fenmu = fenmu;
    }

    public void Setgcd()
    {
        gcd = f_gcd(abs(fenzi), abs(fenmu));
    }//访问权限为公开的设置最大公约数的函数

    public int getGcd(){ gcd = f_gcd(abs(fenzi), abs(fenmu)); return gcd; }

    public int getFenmu() {
        return fenmu;
    }

    public int getFenzi() {
        return fenzi;
    }
}

内容总结

以上是互联网集市为您收集整理的用Java写一个求逆矩阵的程序 2.0全部内容，希望文章能够帮你解决用Java写一个求逆矩阵的程序 2.0所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/608854.html

来源：【匿名】

【上一篇】javaSE 11(2)---1/23 【下一篇】JAVA/JSP学习系列之五

更多 ►

【用Java写一个求逆矩阵的程序 2.0】教程文章相关的互联网学习教程文章

MVC模式在Java Web应用程序中的实例分析【图】

结合六个基本质量属性可用性：异常可修改性：1.维持语义的一致性，高内聚低耦合2.维持现有的接口，Login依赖LoginIService接口，LoginService依赖ILogDAO性能：暂无安全性：对用户进行身份验证易用性：暂无分析具体功能模块的MVC设计实现（例如登录、用户权限等功能模块）在实际项目中的具体应用或分析MVC设计模式在具体网站中的应用（需要列举实例） loginpublic String execute() throws Exception{ String[] request=loginser...

《JAVA程序设计》实训第一天——《猜猜看》游戏【图】

课程实训是做一个猜猜看的小游戏。对于对代码不熟悉不了解的我来说的确挺难的。但是我还是会努力的。import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JPanel; import javax.swing.border.EmptyBorder; import javax.swing.JButton; import javax.swing.JTextField; import javax.swing.JLabel; import java.awt.Color; import java.awt.SystemColor; import java.awt.event.ActionListener; import ja...

好程序员分享如何在Java面试中克服恐惧

有些人即使有丰富的经验，在面试中也难免会恐惧。面试恐惧是恐怖症的一种。面试恐惧症即是对面试这一特定事件的一种无理性的、不适当的担心和焦虑。一旦面对这种场合时，恐惧症患者就会产生一种极端的恐怖感，以致会千方百计地躲避这种环境。那么如何克服这种恐惧，今天就为大家简介一下。要淡化面试的成败意识。一位面试者在面试前自认为各方面都比别人优秀，因此，他认为自己可以高枕无忧了。谁知主考官在面试中出其不意，提了一...

使用exe4j将java项目打成exe执行程序【图】

最近用Java写了一个小工具，想将它达成exe执行文件，到时候直接放某个目录下，一执行就能跑啦。用到的工具：1、写好的项目：可以是java项目，也可以是java web项目2、能够打jar的工具：我用的MyEclipse开发，他们有自带的工具，我就直接用这个了3、exe4j：可以去网上下载，地址：http://www.ej-technologies.com/download/exe4j/files.html，有绿色版的和安装的，32位和64位的。我的是别人给的安装版的，跟官网的最新版可能有些出...

用java编写一个程序，来验证用户输入的数是不是2的阶次方

?1234567891011121314151617181920212223242526272829303132333435363738394041packagecom.stella; importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;/** * 获取用户输入的数 * @author Administrator * */publicclassGetUserInput { privatestaticString str; /** * 获取用户输入 */ privatestaticvoidgetUserInput(){ BufferedReader rb = newBufferedReader(n...

网易前端微专业，JavaScript程序设计基础篇:数组【代码】

任何一种语言数组都是比较重要的，其作为一种基础对象应用很多，如Java你肯定少不了集合（List，Map)这些。因此本篇主要记录JS的数组使用和常用方法。要点如下：1，数组创建两种方式：var stu = new Array();var stu1 = [];这就和定义对象一样：var cat = new Object(); var cat1 = {};推荐用后者，比较简洁。如：var score = [1, 2, 3];数组里的东西可以是不同类型的，数组里面可以是基础类型也可以是对象或数组：var array = [16...

Android（java）学习笔记217：开发一个多界面的应用程序之清单文件

清单文件的重要参数： <intent-filter> 代表的应用程序的入口界面 <action android:name="android.intent.action.MAIN" /> 应用程序在桌面上会产生一个快捷图标，category设置程序运行的场景：default--运行在手机上，CAR_MODE--车载模式…… <category android:name="android.intent.category.LAUNCHER" /> </intent-filter>结论：（1）.一个应用程序可以有多个界面（...

Javascript&Html-弹出窗口的屏蔽程序

大多数的浏览器都内置了弹出窗口的屏蔽程序，即使没有内置此类屏蔽程序的浏览器，用户也可以安装Yahoo tool等带有内置屏蔽程序的应用工具。结果就是用户可以将绝大多数弹出窗口屏蔽掉。于是，再弹出窗口的时候，就应该考虑两种可能性。如果是内置的屏蔽程序组织了弹出窗口，那么window.open()就可能会返回null 。此时，只要检测这个返回值就可以确定弹出窗口是否被屏蔽了。如下面的例子所示。　　var newOpenWin = window.open(...

java程序中的多线程(转)【代码】

为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ― 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的...

每天一个JavaScript实例-使用缓存计算（memoization）来提高应用程序性能

<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>每天一个JavaScript实例-使用缓存计算（memoization）来提高应用程序性能</title> <script> window.onload = function(){var fibonacci = function(){var memo = [0,1];var fib = function(n){var result = memo[n];if(typeof result != "number"){result = fib(n-1) + fib(n-2);memo[n] = result;}console.log("mem...

Winform JAVA程序破解，以及反混淆工具

对于winform生成的exe程序，可以通过ILSpy.exe工具来进行破解。可以通过ILSpy下载有的程序会使用混淆工具进行混淆，这样反编译的源代码可读性很差，可以使用反混淆工具对其进行反混淆de4dotde4dot用法使用命令行到de4dot目录中，调用de4dot.exe(如果是64位调用de4dot64.exe) 后续添加要反混淆的exe目录执行后就可以成功。反编译java程序，需要用到jd_guijd-GUI原文：http://blog.csdn.net/tianshikuqi8/article/details/44956191

谈谈Java程序员进阶的那些知识和方向【代码】

谈谈Java程序员进阶的那些知识和方向记得前段时间看过一篇文章谈到一种程序员叫野生程序员，战斗力极强，可以搞定一切问题，但是通常看问题抓不到本质，或者说是google/baidu/stackoverflow/github的搬运工，其实个人觉得也没什么不好的，闻道有先后，术业有专攻，确实有工作岗位就需要这样的职位。但是计算机行业的发展有其方向，工程师的职业发展也有其方向，随着经验的积累，可能这样的人回头再看看自己写的代码也会觉得不太好。...

迈进java初中级程序员分水岭是否合格？十个题告诉你！【代码】【图】

前言不论你是职场新人还是步入职场N年的职场新人大哥大~当然这个N<3~,我能担保你答不对这十个题~不要问我为什么这么自信~，这些个题还是“有水平”的javase的基础题，传闻小白指定鸭蛋分，一测一个准，哈哈。作为将来要成为架构师的男人，对，你没看错，就是在说你 ~皮一下很开森~ ，what？你是小白？我顶你个肺，我叫声杠精，你敢应吗，那个代号9527的杠精，说你呢快快来答题，看你能答对几道题。题一下面的程序有问题吗？如果有问...

如何设置Java虚拟机内存以适应大程序的装载【代码】【图】

Java虚拟机对于运行时的程序所占内存是有限制的，当我们的项目或者程序很大时，往往会照成内存溢出。举个例子：publicclass SmallTest1 {publicstaticvoid main(String[] args) {byte[] array = newbyte[1024*1024*500];}}当定义这样一个500MB的数组时，就会造成JVM内存溢出：而Java虚拟机默认的程序运行能得到的内存大小是随系统的，由Java的api体系结构中，点击Java：后找到 “-Xmxn”这一项：所以默认大小是根据系统设置的，那...

201621123042《java程序设计》第十一次作业【图】

1. 本周学习总结1.1 以你喜欢的方式（思维导图或其他）归纳总结多线程相关内容。2. 书面作业本次PTA作业题集多线程1. 源代码阅读：多线程程序BounceThread1.1 BallRunnable类有什么用？为什么代码中需要调用Thread.sleep进行休眠？答：BallRunnable类，实现了Runnable接口，实现run方法中的move和repaint方法，实现小球的轨迹。调用Thread.sleep是为了使线程休眠，延缓线程的完成时间，这样就可以查看小球的移动轨迹，如果不调用...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / 用Java写一个求逆矩阵的程序 2.0

用Java写一个求逆矩阵的程序 2.0

内容导读

内容图文

用Java写一个求逆矩阵的程序 2.0

变更记录

简析

改进后的全部代码：

内容总结

内容备注

内容手机端

【用Java写一个求逆矩阵的程序 2.0】教程文章相关的互联网学习教程文章

MVC模式在Java Web应用程序中的实例分析【图】

《JAVA程序设计》实训第一天——《猜猜看》游戏【图】

好程序员分享如何在Java面试中克服恐惧

使用exe4j将java项目打成exe执行程序【图】

用java编写一个程序，来验证用户输入的数是不是2的阶次方

网易前端微专业，JavaScript程序设计基础篇:数组【代码】

Android（java）学习笔记217：开发一个多界面的应用程序之清单文件

Javascript&Html-弹出窗口的屏蔽程序

java程序中的多线程(转)【代码】

每天一个JavaScript实例-使用缓存计算（memoization）来提高应用程序性能

Winform JAVA程序破解，以及反混淆工具

谈谈Java程序员进阶的那些知识和方向【代码】

迈进java初中级程序员分水岭是否合格？十个题告诉你！【代码】【图】

如何设置Java虚拟机内存以适应大程序的装载【代码】【图】

201621123042《java程序设计》第十一次作业【图】

JAVA - 相关标签

程序 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程