Java - Waarom wordt de waarde van de primitieve wrapperklasse (bijvoorbeeld Integer) niet behouden in recursieve aanroepen?

Ik gebruik recursie en ik wil dat een Integer -object zijn waarde behoudt voor recursieve aanroepen. bijv.

public void recursiveMethod(Integer counter) {
    if (counter == 10)
        return;
    else {
        counter++;
        recursiveMethod(counter);
    }
}

public static void main(String[] args) {
    Integer c = new Integer(5);
    new TestSort().recursiveMethod(c);
    System.out.println(c);//print 5
}

Maar in de onderstaande code (waar ik een Teller -klasse gebruik in plaats van Integer wrapper-klasse, wordt de waarde gehandhaafd

public static void main(String[] args) {
    Counter c = new Counter(5);
    new TestSort().recursiveMethod(c);
    System.out.println(c.getCount());//print 10
}

public void recursiveMethod(Counter counter) {
    if (counter.getCount() == 10)
        return;
    else {
        counter.increaseByOne();
        recursiveMethod(counter);
    }
}

class Counter {

    int count = 0;

    public Counter(int count) {
        this.count = count;
    }

    public int getCount() {
        return this.count;
    }

    public void increaseByOne() {
        count++;
    }
}

dus waarom primitve wrapper class zich anders gedraagt. Beide zijn immers objecten en in de reucrsive call geef ik het Integer -object door en niet alleen int zodat het Integer -object ook moet behouden zijn waarde.

2
@ Oli de bovenstaande code is alleen voor de uitleg van mijn twijfel. Het heeft dus geen zin van irrelevantie ... U had dit zelf moeten begrijpen. Ik moet zeggen dat uw opmerking niet relevant is voor deze vraag.
toegevoegd de auteur Yatendra Goel, de bron
U zou de codevoorbeelden moeten vereenvoudigen; de recursie is niet relevant ...
toegevoegd de auteur Oliver Charlesworth, de bron
De reden die ik heb gezegd, is dat wanneer je probeert om iets te begrijpen dat je niet begrijpt, het meestal helpt om het te reduceren tot het eenvoudigste mogelijke test-geval (dat wil zeggen alles te elimineren dat niet relevant is voor het kernprobleem).
toegevoegd de auteur Oliver Charlesworth, de bron

2 antwoord

De Java-wrappertypen zijn onveranderbaar . Hun waarden veranderen nooit.

counter++ is really counter = counter + 1; i.e. a new object gets created.

10
toegevoegd
+1 voor beknopt en to the point antwoord
toegevoegd de auteur Yatendra Goel, de bron

Sommige objecten zoals String, Integer etc .... zijn onveranderlijk zelfs als ze objecten zijn ....

probeer deze link ...

http://www.javaranch.com/journal/2003/04/immutable.htm

Ik raad je aan het volgende te doen ......

         public void recursiveMethod(Integer counter) 
         {
            if (counter == 10)
            return counter; //return the value
            else 
            {
                    counter++;
                    counter=recursiveMethod(counter);
             }
         }

         public static void main(String[] args) 
         {
           Integer c = new Integer(5);
           c=(Integer)new TestSort().recursiveMethod(c);
           System.out.println(c);//print 5
          }

Het enige verschil dat ik geloof dat je zult vinden over het gebruik van beide zou zijn

Het gebruik van int is als het gebruik van java primitives zoals elke andere taal, terwijl Integer methoden bevat zoals wait (), notify (), parsing, hashcode etc .....

1
toegevoegd
@OliCharlesworth, het gaat erom dat java-objecten zoals Integer, String, enz. Onveranderlijk zijn .... en ik heb zojuist de code bewerkt en niet overwogen om rekening te houden met de compliation ....
toegevoegd de auteur Arjun K P, de bron