ArrayDeque as a stack doesn't work as expected with complex objects

Question

Trying to use ArrayDeque as a strorage for complex values <PSList<PSol>> (i.e. Arraylists of structured Values PSol), this doesn't work as expected. The code below should produce different values of pSLWk, being stored on bkStack, which are then to be retrieved by pop() to the variables pSL1, pSL2, pSL3.
However, retrieval only ends up with three identical data sets (variables) pS1,pS2, pS3.
        public PSList<PSol> pSL;
        private ArrayDeque<PSList<PSol>> bkStack=new ArrayDeque<PSList<PSol>>();
        pSLWk=new PSList<PSol>();       // Constructor copies some Array (static field) to the PSLists
        pSL=new PSList<PSol>();
        pSLAux=new PSList<PSol>(pSLWk);   // Constructor copies from existing PSList
        pSLWk.checkResult("pSLWk prior to setDefaults - modifies pSLWk !");
        setDefaults();                                                            // Modifies pSLWk only
        pSLWk.checkResult(" pSLWk after setDefaults");              // .. got changes (o.k.)
        pSL.checkResult(" pSL after setDefaults");                  // .. unchanged  (o.k.)
        pSL.checkResult(" pSLAux after setDefaults");               // .. unchanged  (o.k.)
        bkStack.push(new PSList<PSol>(pSLWk));                      // store changes in bkStack
        pSLWk.getEl(77).setVal(new StringBuffer("4"));              // change pSLWk again (value 4 @ 77)
        pSLWk.checkResult("pSLWk, after PUSH, THEN modify 4@77");   // .. got change (o.k.)
        pSL.checkResult("pSL after setVal 77");
        bkStack.push(pSLWk);                      // store changes in bkStack
        pSLWk.getEl(80).setVal(new StringBuffer("8"));              // change pSLWk again (value 8 @ 80)
        pSLWk.checkResult("pSLWk after setVal 8@80");               // .. got change (o.k.)
        pSL.checkResult("pSL after setVal 80");
        bkStack.push(new PSList<PSol>(pSLWk));                      // store changes in bkStack
        pSL1=new PSList<PSol>(bkStack.pop());
        pSL1.checkResult("pSL1 after 1st pop");
//      pSL1=bkStack.pop()                                          // Straightforward way doesn't work either...
        pSL2=new PSList<PSol>(bkStack.pop());
        pSL2.checkResult("pSL2 after 2nd pop");
        pSL3=new PSList<PSol>(bkStack.pop());
        pSL3.checkResult("pSL3 after 3rd pSLWk=..pop()");Here the result from the code above:
debug:
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.>pSLWk prior to setDefaults - modifies pSLWk !
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2   63 <C.R.> pSLWk after setDefaults
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.> pSL after setDefaults
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.> pSLAux after setDefaults
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  463 <C.R.>pSLWk, after PUSH, THEN modify 4@77
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.>pSL after setVal 77
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSLWk after setVal 8@80
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.>pSL after setVal 80
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSL1 after 1st pop
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSL2 after 2nd pop
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSL3 after 3rd pSLWk=..pop()
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.>pSLWk prior to setDefaults - modifies pSLWk !
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2   63 <C.R.> pSLWk after setDefaults
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.> pSL after setDefaults
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.> pSLAux after setDefaults
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  463 <C.R.>pSLWk, after PUSH, THEN modify 4@77
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.>pSL after setVal 77
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSLWk after setVal 8@80
1 8 9   4  5 42 9 7  5  2 6 4 923     1  7   3         86   7 5  3 69     2   63 <C.R.>pSL after setVal 80
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSL1 after 1st pop
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSL2 after 2nd pop
128 96  4635 42 9 7945  2 6 47923     1  7   3 9       86   7 5  3 69     2  4638<C.R.>pSL3 after 3rd pSLWk=..pop()What's the problem with this ?
Rem: I tried the simple approach as well:
bkstack.push(pSLWk);
...

Answer 1

Thank you for your comments, although I see we still don't have a common understanding of the problem.
Firstly, I add the code for the PSList and the PSol classes, so you might find some problem with that:
     public class PSol     {
          private StringBuffer val;
          private int zI;
          private int sI;
          private int bI;
                    // == Konstruktor
          public PSol( StringBuffer v, int z, int s, int b )     {
               this.val=v;
               this.zI=z;
               this.sI=s;
               this.bI=b;
                    // == Getter,Setter
          public StringBuffer getVal()     {return val;}
          public int getZ()     {return zI;}
          public int getS()     {return sI;}
          public int getB()     {return bI;}
          public int getVSize()     {return val.length();}
          public void setVal(StringBuffer v)     {val=v;}
          public boolean hasVChar( StringBuffer ch, boolean delCh )     {
               boolean bT=false;
               StringBuffer fSt=getVal();
               if (!(fSt.indexOf( ch.toString() )     == -1))     {
                    bT=true;
                    if (delCh)     {
                         setVal(fSt.deleteCharAt(fSt.indexOf( ch.toString() )));
               return bT;
     }     // PSol
     public class PSList<E> extends ArrayList<PSol>     {
               /**     Construktor 1: PSList(v,z,s,b) - makes list from single arrays
          private static final long serialVersionUID =  4711L;                         // ### JAVAC Warning! ###
        public PSList (String[] vS, int[] z, int[] s, int[] b) {
               StringBuffer[] v=new StringBuffer[valDim];
            for (int i=0;i<valDim;i++)  {
                v=new StringBuffer(vS[i]);
//ArrayList<PSol> pSL=new ArrayList<PSol>;
               for (int i=0; i<valDim; i++) {
                    this.add( new PSol( v[i], z[i], s[i], b[i] ) );
/** Konstruktor2 : makes list from matrix array
public PSList () {
for (int j=0; j<nDim; j++) {
for (int i=0; i<nDim; i++) {
this.add( new PSol( new StringBuffer(sGuiArr[i][j]), i, j , i/locDim + (j/locDim)*locDim) );
                    /**     ------- Construktor 3 : PSList(PSList pS) - makes list as a copy of an existing one
public PSList ( PSList<PSol> pX )     {
               super (pX); // ArrayList-Constructor (Collection)
// get Element <PSol>
public PSol getEl ( int i )     {return get(i);}
     public int getCount()     {return size();}
     public int getTValLg()     {
               int lg=0;
               for (int i=0; i<getCount(); i++)     {
                    lg=lg + getEl(i).getVal().length();
               return lg;
                    /**     ------- checkResult()     -     Check if alll elements are single char +dump
     public boolean checkResult(String messg)     {
               boolean allOne=true;
               for (int i=0; i<size(); i++)     {
                    if ( getEl(i).getVal().length() > 1 )     {
                         allOne=false;
                         System.out.print(" ");
               else     {
                    System.out.print(getEl(i).getVal());
               System.out.println("<C.R.>"+messg);
               return allOne;
     }     // Class PSList
Secondly, I don't really see what you mean by pointing out to 'only one "pSLWk" instance of PSList'. The variable pSLWk is the variable to be worked upon; after some change of the contents, I want to save this state of contents to the stack. When I pop that variable from the stack, I wouldn't want to restore it to pSLWK, but to some other variable, e.g. by public PSList<PSol> pSL1;
pSL1=new PSList<PSol>(bkStack.pop());Again - to my understanding (which comes from old days of microprocessor coding... - there shouldn't be a need to know how the data came there, or what was the name of the variable who stored it there. And  : the implementation of ArrayDeque returns 'elements' of class E, not references !
Thirdly, you're right, that the method of using a copy constructor for retrieval looks 'weird'. However - I had some other versions that didn't work either, e.g. the straightforward one, as I pointed out.
And fourthly: yes, I'm almost sure that I'm messing up something somewhere. I went to this forum hoping to clarify that ... :)
If you don't mind, could you please sketch a few lines of code, how to 'push' a complex variable to a ArrayDeque stack, and retrieve it - by 'pop()' - to some to other variable of the same class later ?
Might make our discussion much easier, to see how things REALLY work.
Thank you !