分类： 未分类

运行以下两段代码：
代码1：
       String[][] sa1 = new String[][]{{“a11”, “a12”},{“a21”, “a22”}};
       String[][] sa2 = new String[sa1.length][sa1[0].length];
       System.arraycopy(sa1,0, sa2, 0, sa1.length);
       System.out.println(“sa1[0][0] : ” + sa1[0][0]);
       System.out.println(“sa2[0][0] : ” + sa2[0][0]);
       sa1[0][0] = “XXXXX”;
       System.out.println(“———————“);
       System.out.println(“sa1[0][0] : ” + sa1[0][0]);
       System.out.println(“sa2[0][0] : ” + sa2[0][0])
输出：
sa1[0][0] : a11
sa2[0][0] : a11
———————
sa1[0][0] : XXXXX
sa2[0][0] : XXXXX

代码2：
       String[] sa1 = new String[]{“a11”, “a12”};
       String[] sa2 = new String[sa1.length];
       System.arraycopy(sa1,0, sa2, 0, sa1.length);
       System.out.println(“sa1[0] : ” + sa1[0]);
       System.out.println(“sa2[0] : ” + sa2[0]);
       sa1[0] = “XXXXX”;
       System.out.println(“———————“);
       System.out.println(“sa1[0] : ” + sa1[0]);
       System.out.println(“sa2[0] : ” + sa2[0]);
输出：
sa1[0] : a11
sa2[0] : a11
———————
sa1[0] : XXXXX
sa2[0] : a11

可见，当数组是两维时，对源数组的改变也影响到了目标数组，但一维数组却不会有问题。要当心的。。。

行列式,矩阵,线性方程组,逆阵
package org.dean;
import javax.swing.*;
public class fun {
       private double[][]a;
       private int[][]aa;
       public fun(double[][] aa){
               a=new double[aa.length][aa[0].length];
               System.arraycopy(aa,0,a,0,aa.length);
             
       }
       public fun(int[][] a){
               aa=new int[a.length][a[0].length];
               System.arraycopy(a,0,aa,0,a.length);              
       }
   public void displayMatrix(int aa[][]){
           for(int[] df:aa){
               System.out.println();
               for(int d:df)
                       System.out.print(d+” “);}
       }
 
   public void displayMatrix(double aa[][]){
           for(double[] df:aa){
               System.out.println();
               for(double d:df)
                       System.out.print(d+” “);}
       }
       /**
        * 使用高斯消元解行列式
        * @param aa 二维double数组
        */
 public double guass(){          
         double arrangerResult=1.0;
         double k=0;
         if(a[0].length!=a.length)throw new IllegalArgumentException(“行列式的行列数必须相等”);
     for (int p = 0; p       for (int r =p+1; r        k=a[r][p]/a[p][p];
       a[r][p]=0;
       for (int c = p+1; c         a[r][c]=a[r][c]-k*a[p][c];
            }
          }
         }
     for (int i = 0; i                  arrangerResult=arrangerResult*a[i][i];//计算主对角线相乘的结果
          }
     return arrangerResult;
 }
 public int arra(){
         int c,l,sum;
         int A[];
         c=aa[0].length;
         l=aa.length;
         //第一行的代数余子式
         A=new int[c];        
         sum=0;
         //若行列数不相等
         if(c!=l) throw new IllegalArgumentException(“行列式的行数和列数必须相等”);
         //到达最小单位2*2,计算出值
         if(c==2)return aa[0][0]*aa[1][1]-aa[0][1]*aa[1][0];
         //按第一行展开,计算代数余子式
         for(int i=0;i          {   if((i)%2==0){
                 //求第一行第i个元素的代数余子式
                 A[i]=solveA(aa,0,i);}
         else{                
                 A[i]=solveA(aa,0,i)*(-1);}        
         sum+=aa[0][i]*A[i];
         }
       
         return sum;
       
       
 }
 public int arra(int aa[][]){
         int c,l,sum;
         int A[][];
         c=aa[0].length;
         l=aa.length;
         A=new int[c][l];        
         sum=0;        
         if(c!=l) throw new IllegalArgumentException(“行列式的行数和列数必须相等”);
         if(c==2)return aa[0][0]*aa[1][1]-aa[0][1]*aa[1][0];
         for(int i=0;i          {   if((i)%2==0){                
                 A[0][i]=solveA(aa,0,i);}
         else{        
                 A[0][i]=solveA(aa,0,i)*(-1);}        
         sum+=aa[0][i]*A[0][i];
         }
       
         return sum;
       
       
 }
 /**
  * 计算aa[][]第i行的j列元素的代数余子式
  * @param aa 整形数组
  * @param ii 元素的行号
  * @param jj 元素的列号
  * @return 代数余子式的行列式的值
  */
 public int solveA(int aa[][],int ii,int jj){
       //余子式元素
         int a[][];
         int c,l,m;
         int x=-1,y=0;
         c=aa[0].length-1;
         l=aa.length-1;
         //每次都按第一 行展开的余子式的行列式的值
         int A[];
         int sum=0;
         A=new int[c];
         a=new int[c][l];
         for(int i=0;i<=c;i++){
                 //如果元素的行号等于要求余子式的行号则跳过
                 if(i==ii){continue;}
                 y=0;x++;
                 for(int j=0;j<=c;j++){
            //如果元素的列号等于要求余子式的列号则跳过
                          if(j==jj){continue;
                                 }else{
                         a[x][y]=aa[i][j];                        
                         y++;}
                       
                 }}  
         if(c==2)return a[0][0]*a[1][1]-a[0][1]*a[1][0];
//  递归调用.每次都按第一行展开
         for(int i=0;i          {   if((i)%2==0)                
                 A[i]=solveA(a,0,i);
         else
                 A[i]=solveA(a,0,i)*(-1);
                 sum+=a[0][i]*A[i];
         }  
         return sum;
 }
 /**
  * 输入增广矩阵求解线性方程组解
  * @return 包含解的double数组
  */
 public double[] formula(){
         int c=aa[0].length-1;
         int r=aa.length;
         if(r!=(c)) throw new IllegalArgumentException(“必须是增广矩阵.且行数比列数少1 “);
         int D[]=new int[c];
         //A矩阵存放解
         double A[]=new double[c];        
         int a[][]=new int[r][c];
         for(int i=0;i            for(int j=0;j              a[i][j]=aa[i][j];
         //求出系数矩阵行列式的值
         int DD=arra(a);  
         for(int k=0;k            for(int i=0;i              for (int j=0;j                      a[i][j]=aa[i][j];
             }
             //第k列用最后一列替换
             a[i][k]=aa[i][c];
             }
             //求出第k列用最后一列替换以后的 行列式的值
             D[k]=arra(a);
             //求出解
             A[k]=D[k]/(double)DD;
             }
             return A;
         }
 /**
  * 求方阵的逆阵
  *
  *
  * @return 逆阵
  */
 public double[][] nizhen()
       {
       int c,l,sum;
        double A[][];
        c=aa[0].length;
       l=aa.length;
       A=new double[c][l];          
       double he=arra(aa);
       //如果只有2*2 则主对角线交换,副对角线取负即为A*
       if(c==2){
               A[0][0]=aa[1][1];
               A[1][1]=aa[0][0];
               A[1][0]=aa[0][1]*(-1);
               A[0][1]=aa[1][0]*(-1);
               //displayMatrix(A);
               return A;
       }
       for(int i=0;i          for(int j=0;j        {   if((i+j)%2==0){              
               A[j][i]=solveA(aa,i,j)/he;}
       else{              
               A[j][i]=(solveA(aa,i,j)*(-1))/he;}      
       }
       //displayMatrix(A);
       return A;
       }
}
今天重写了一次..使用了jdk5.0 的for while功能.不错.十分好用.只是递归的效率太低.高阶的几乎就是解不出来了.在想办法..

历经千辛万苦总算到家啦..虽然路途很远.腿好累.但是还是免不了说一句很俗气的话.回家真好 ..
   很久没写日记,当然不是没话说了.只是静不下心来.作个年度总结吧.
   这半年也许是我学习比较用功的半年.虽然还是逃课.上课不听讲.但是总比以前进步了不少.至少数学课笔记都 记全了.就是最后算法和数据库没考好.让我一直记在心里,同学关系比较一般.班上的人都没认全噢..还是比较不外向,看来以后要努力改变一下.搞好和同学的关系..
   新的一年有好多目标噢.软件设计师要考下来,六级要考到550分,java程序员也要尽力考.数据库管理和编程要搞定.MCSE课程要学完.linux管理和编程又是不少时间.想起来头都大了噢.天天不上课也没那么多时间嘛..明年过年的时候再来看日记.看目标实现了多少噢..同学 结婚请酒.说老实话都不怎么想去,感觉我太老了噢.不过我确实是不小了.都二十好几.在过几年都奔三了 .突然感到原来我已不在年轻.有种紧迫感.

  来天津都三年多了,竟然没有去过塘沽,说起来经常被别人鄙视,没事老听别人说在洋货市场十几块钱买劳力士的经历,各种水货,各国的小东西,总是不禁心生向往.昨天一同学塘沽回来告诉我今天塘沽有个国际大学生龙舟邀请赛,说的可是眉飞色舞,让我觉得不去都不行了.马上打电话联系,约定好时间.
   今天起了一个大早.难得地破坏了我晚起得习惯.七点多就起床了,一醒马上打电话给他们,打开电脑,装魔兽,刷牙去,估计他们会磨点时间,让他们上车打电话给我,不料他们已经上车了.倒!手机欠了二十多了,这次真难得竟然还能打电话,去银行还交不了话费,坐上公交竟然下错了站,提前一站下了,没办法等了一辆再上,而他们已经等得开始骂娘了噢.到了中山门第一眼看到就是长长得排队得队伍,晕.怎么这么多人?打电话却联系不上人.不管了.先排上对再说.就在我放弃得时候他们打电话过来.原来他们还在外面等我.又被鄙视了一番,我只好把给他们买轻轨票当作补偿.到塘沽还要5块钱.轻轨很新,感觉和上海得差不多,不过上海得轻轨好像是卖票得,地铁才用磁卡.虽然感觉轻轨开得并不快,但是半个小时我们就到塘沽了.而以前他们坐公交要2个小时呢.
   在轻轨上看塘沽感觉塘沽还是挺大得,我以前一直以为塘沽是个很小的区,下了轻轨发现原来并不小,市区有得基本那边都有噢..一样有家世界.国美什么得,下了轻轨却没发现洋货市场在哪,先不管了.看龙舟先,上了公交感觉公交开得好猛噢.都是急开急停,站着都要拉紧了才行,有点象福州的小公交噢.人家的口号是中速行驶呢.可怜我没吃早饭,本来就没啥力气还要耗费大量体力在维持身体平衡上.
  到了外滩就感叹,人好多呀,早就听说国庆出门就是看人噢.不过还好..还可以走着游玩而不用到处挤,到了河边确发现沿河全是人,几乎都看不到河面,汗.欺负我不够高嘛…
to be continued….

今天逃了两节课，上午上的郁闷。上课几分钟就从后门逃走。下午第一次一开始就没去，以为老师上节课点的就是我们班。想想应该不会又点我们班吧。。如果全部点的话我们前面还有2个班还是来得及赶到的噢。以为宿舍到教室也就100米嘛。
  想不到。。竟然又点七班。穿着拖鞋一路狂奔过去。还是晚了。。最后记了个迟到。。倒。。上了两份钟就从后门溜了。。闷。
  今天宽带装好了。虽然学校好像不允许装，但是给人家网通钱 还是好说话嘛。昨天申请的，今天就开通了。怕别人知道大家都装，现在我们屋都锁门，进去就不出来了。有人来还要伪装一番。晕。