Vector (good for storing) and arrays(good for numerical sums, multiplying)

Question

Hi guys, I am trying to use vectors because I need a variable lenght and store 2D arrays in one coordenate of a vector. That is why I am using vector instead arrays. I can turn the type of variable using "Integer" (instead of "int" as arrays), "Double" (instead of "double") and so on. The problem is that it doesn't allow me to operate, it is very good for storing, but I need to be able to operate, multiplying, sum, etc the elements there are in the coordenates. And I think it is not possible.
What u think about it? I can only store stuff ion a vector, I cannot operate. Besides I cant turn a data from "Double" to "double", I can either use arrays OR vectors, but not both of them at the same time.
You think i am wrong?, because I mean in that case, Java is not very useful to do this numerical problem.
Thanks.
This is only a class of the program I am doing.
import java.util.*;
class SolveDomain {
     int newton_iter = 0, m = 0, work_count = 0;
     double t = 0, dx, dy, dt, start_t=0;
     double[][] v;
Details obDetails = new Details();
     public double[][] solveDomainMethod(Double vAxn, Double vAyn, Double vBxn, Double vByn, Integer nxn, Integer nyn, double dt, Double error1n, Double error2n, double end_tn, int stepsn, Integer kcn, Double u_n[][], Double v_n[][], Double bc1, Double bc2, Double bc3, Double bc4, double u[][]) {       
     double dx2, dy2, err = 1000000;
     v = new double[nxn+1][nyn+1];
     DoublevAxn, Double vAyn, Double vBxn, Double vByn, Integer nxn, Integer nyn, double dt, Double error1n, Double error2n, double end_tn, int stepsn, Integer kcn, double u_n[][], double v_n[][], Double bc1, Double bc2, Double bc3, Double bc4;
double k[][] = new double [nxn+1][nyn+1]; double kp[][] = new double [nxn+1][nyn+1];
double kpp[][] = new double [nxn+1][nyn+1]; double dudx[][] = new double [nxn+1][nyn+1];
double dudy[][] = new double [nxn+1][nyn+1]; double d2udx2[][] = new double [nxn+1][nyn+1];
double d2udy2[][] = new double [nxn+1][nyn+1]; double dudt[][] = new double [nxn+1][nyn+1];
double a[][] = new double [nxn+1][nyn+1]; double b[][] = new double [nxn+1][nyn+1];
double c[][] = new double [nxn+1][nyn+1]; double d[][] = new double [nxn+1][nyn+1];
double F[][] = new double [nxn+1][nyn+1]; double A[][] = new double [nxn+1][nyn+1];
double B[][] = new double [nxn+1][nyn+1]; double C[][] = new double [nxn+1][nyn+1];
double D[][] = new double [nxn+1][nyn+1]; double E[][] = new double [nxn+1][nyn+1];
double s[][] = new double[nxn+1][nyn+1];
          KDerivatives1 obK1 = new KDerivatives1();
          KDerivatives2 obK2 = new KDerivatives2();
UDerivatives obU = new UDerivatives();
          CalcPdeCoefficients obPde = new CalcPdeCoefficients();
          CalcFdCoefficients obFd = new CalcFdCoefficients();
          Gs obGs = new Gs();
dx = obDetails.seg(vBxn, vAxn, nxn);
dy = obDetails.seg(vByn, vAyn, nyn);
dx2 = dx*dx;
dy2 = dy*dy;
if (bc1 != -999999999) obDetails.initialiceBCDomainL(dx, dy, vAxn, vAyn, bc1, u);
if (bc2 != -999999999) obDetails.initialiceBCDomainU(dx, dy, vAxn, vAyn, bc2, u);
if (bc3 != -999999999) obDetails.initialiceBCDomainR(dx, dy, vAxn, vAyn, bc3, u);
if (bc4 != -999999999) obDetails.initialiceBCDomainD(dx, dy, vAxn, vAyn, bc4, u);
obDetails.source(dx, dy, vAxn, vAyn, s);
do {
++ newton_iter;
if (kcn == 1) { 
          obK1.calc_k(u, k);
     obK1.calc_kp(u, kp);
     obK1.calc_kpp(u, kpp);
          } else {
               obK2.calc_k(u, k);
          obK2.calc_kp(u, kp);
          obK2.calc_kpp(u, kpp);
               obU.calc_dudx(u, dx, dudx);
          obU.calc_dudy(u, dy, dudy);
               obU.calc_d2udx2(u, dx2, d2udx2);
               obU.calc_d2udy2(u, dy2, d2udy2);
          obU.calc_dudt(u, u_n, dt, dudt);
          obPde.calcPdeCoefficientsa(k, a);
          obPde.calcPdeCoefficientsb(kp, dudx, b);
          obPde.calcPdeCoefficientsc(kp, dudy, c);
          obPde.calcPdeCoefficientsd(kp, kpp, dudx, dudy, d2udx2, d2udy2, d);
          obPde.calcPdeCoefficientsF(k, kp, dudx, dudy, d2udx2, d2udy2, dudt, s, F);
          obFd.calcFdCoefficientsA(a, b, dx, dx2, A);
          obFd.calcFdCoefficientsB(a, b, dx, dx2, B);
          obFd.calcFdCoefficientsC(a, c, dy, dy2, C);
          obFd.calcFdCoefficientsD(a, c, dy, dy2, D);
          obFd.calcFdCoefficientsE(a, d, dx2, dy2, dt, E);
          obGs.gsMethod(v_n, A, B, C, D, E, F, dt, error2n, v);
          m = m + obGs.iter;
          for (int i=1; i < u.length - 1;i++ ) {
               for (int j=1; j < u[0].length - 1 ;j++ ) {
     u[i][j] = u[i][j] + v[i][j];
err = 0;
          for (int i=0; i < u.length ;i++ ) {
               for (int j=0; j < u[0].length ;j++ ) {
               err = err + Math.pow(v[i][j],2);
          err = Math.sqrt(err);
while (err > error1n);
     return u;           
public double[][] rectangleDomainF (Vector vAxvector, Vector vAyvector, Vector vBxvector, Vector vByvector, Vector nxvector, Vector nyvector, Vector error1vector, Vector error2vector, double end_t, int steps, Vector kcvector, double numberdomains, Vector bc1vector, Vector bc2vector, Vector bc3vector, Vector bc4vector) {
               double u[][] = new double[u.length][u[0].length];
               double dt = obDetails.seg(end_t, start_t, steps);
               Vector uvector = new Vector();
               Vector vvector = new Vector();
     do
++work_count;
          t = work_count * dt;
for (int k = 0; k < numberdomains ; k++) {
     solveDomainMethod((Double)vAxvector.elementAt(k), (Double)vAyvector.elementAt(k), (Double)vBxvector.elementAt(k), (Double)vByvector.elementAt(k), (Integer)nxvector.elementAt(k), (Integer)nyvector.elementAt(k), dt, (Double)error1vector.elementAt(k), (Double)error2vector.elementAt(k), end_t, steps, (Integer)kcvector.elementAt(k), (Double [][]) uvector.elementAt(k), (Double [][]) vvector.elementAt(k), (Double)bc1vector.elementAt(k), (Double)bc2vector.elementAt(k), (Double)bc3vector.elementAt(k), (Double)bc4vector.elementAt(k), u);
                                                       uvector.insertElementAt(u, k);
          vvector.insertElementAt(v, k);
while (t < end_t);
return u;

Answer 1

The only way to, for instance, multiply a Double object by another Double object is to convert them back to primitives, multiply them, and create a new Double instance:
public Double multiply(Double lhs, Double rhs) {
   return new Double( lhs.doubleValue() * rhs.doubleValue() );
}This is just an overhead that you have to accept if you want to use collections with primitive type data.
Coming soon in 1.5 (which is in Beta now and available for download in the usual places) a new feature called auto-boxing will do a lot of this automatically for you. You need to be aware that it's doing exactly the same operations with the same performance overhead; but it does save a lot of typing.
Thus in 1.5 the above becomes:
public Double multiply(Double lhs, Double rhs) {
   // Under the hood this is IDENTICAL to the above example
   return lhs * rhs;
}Now, addressing your post directly:
Besides I cant turn a data from "Double" to "double"
Yes you can, as in the first example, the doubleValue() method converts a Double object to a double primitive.
Java is not very useful to do this numerical problem.
If you need math performance, you need to use primitives, yes. Yes, that will preclude the use of collections.
Dave.