---
title: 'Das oberste Stack-Element duplizieren'
url: 'https://tutego.de/blog/javainsel/2013/09/das-oberste-stack-element-duplizieren-2'
markdown: 'https://tutego.de/blog/javainsel/2013/09/das-oberste-stack-element-duplizieren-2.md'
date: '2013-09-09'
description: 'Die Klasse Stack besitzt zwar die Basisfunktionalität, die ein Stapel besitzen sollte, aber auch nicht mehr. Hin und wieder wünschen wir uns aber eine Funktion, die das oberste Stack-Element dupliziert, kurz dup(). Allerdings ist das schwerer als gedacht, und das erklärt auch, warum es so eine Meth…'
taxonomy:
  category:
    - Allgemein
---

# Das oberste Stack-Element duplizieren

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://tutego.de/blog/javainsel/)

## Das oberste Stack-Element duplizieren

09.09.2013 · [Christian Ullenboom](https://tutego.de/blog/javainsel/author/admin/)

*Die Klasse Stack besitzt zwar die Basisfunktionalität, die ein Stapel besitzen sollte, aber auch nicht mehr. Hin und wieder wünschen wir uns aber eine Funktion, die das oberste Stack-Element dupliziert, kurz `dup()`. Allerdings ist das schwerer als gedacht, und das erklärt auch, warum es so eine Methode nicht gibt.*

Bei der Implementierung treten zwei Fragen auf, mit denen zwei völlig unterschiedliche Lösungsansätze verbunden sind. Da die Klasse Stack wie die anderen Datenstrukturen auf Objekte ausgelegt ist, müssen wir uns darüber Klarheit verschaffen, wie das obere Objekt dupliziert werden soll. Soll eine Kopie der Objekt-Referenz neu auf den Stapel gelegt werden oder etwa das gesamte Objekt geklont werden?

**Die einfache Lösung**

Die einfachste Lösung besteht darin, das oberste Objekt einfach mittels der schon vorhandenen Stack-Methoden **`push()`** und **`peek()`** draufzulegen. Nehmen wir an, wir haben eine Unterklasse **DupStack**, dann sieht die erste Variante zum Clonen so aus:

```java
void dup() /* throws EmptyStackException */
{
  push( peek() );
}
```

**`peek()`** gibt aber lediglich eine Referenz auf das Objekt zurück. Und das anschließende **`push()`** speichert diese Referenz dann auf dem Stapel. Nehmen wir an, wir haben zwei **`StringBuffer`**-Objekte auf dem Stapel. Wenn wir nun **`dup()`** aufrufen und den `String` ändern, der oben auf dem Stapel liegt, so ändern wir automatisch das zweite Element gleich mit. Dies ist aber nicht unbedingt beabsichtigt, und wir müssen uns Gedanken über eine alternative Lösung machen. Wir sehen, dass **`dup()`** in der Klasse Stack fehlt, weil seine Implementierung davon abhängt, ob eine Referenz- oder eine Wertsemantik für Kellerelemente gewünscht ist.

**Die kompliziertere Lösung mit Klonen**

Um das oberste **Stack**-Element zu kopieren, bietet sich die **`clone()`**-Methode von **`Object`** an. All die Objekte, die sich klonen lassen, und das sind längst nicht alle, implementieren das Interface **Cloneable**. Nun ließe sich einfach folgern: Wenn das zu duplizierende Objekt ein Exemplar von **Cloneable** ist, dann können wir einfach die **`clone()`**-Methoden aufrufen und das zurückgegebene Objekt mittels **`push()`** auf den Stapel bringen.

```java
void dup2() throws CloneNotSupportedException
{
  try
  {
    Object top = peek();

    if ( top instanceof Cloneable )
      push( top.clone() );

  }
  catch ( EmptyStackException e ) { }
}
```

Beziehungsweise

```java
void dup3() throws CloneNotSupportedException /*, EmptyStackException */
{
  push( peek().clone() );
}
```

Dies funktioniert für die meisten Objekte, allerdings nicht für Objekte der Klasse **`Object`**. Denn **`clone()`** der Klasse **`Object`** ist **protected** – wir dürfen also von außen nicht dran, nur eine Unterklasse und die Klasse selbst. Hier haben wir also zwei Probleme.

- Leider lässt sich nur mit Aufwand überprüfen, ob das Objekt auf dem Stapel auch wirklich ein pures **`Object`** ist, denn alle Objekte sind **instanceof** `Object`. Glücklicherweise gibt es kaum eine Anwendung, wo reine **`Object`**-Elemente gesichert werden müssen.
- Was machen wir mit Objekten, die nicht klonbar sind? Leider gibt es für diese Frage keine direkte Antwort. Eine universelle **Stack**-Klasse mit einer uneingeschränkten **`dup()`**-Methode gibt es nicht. Wir müssen als **Stack**-Benutzer festlegen, dass das oberste Element **Cloneable** ist, um zumindest eine eigene Implementierung nutzen zu können. Oder wir bleiben dabei, bei nicht klonbaren Objekten doch nur die Referenz zu duplizieren. Das wäre zumindest für eineindeutige Objekte mit Wertsemantik die ideale Lösung.

Kategorien: [Allgemein](https://tutego.de/blog/javainsel/category/allgemein/)

[← Alle Beiträge](https://tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [True Type Fonts in Swing/AWT-Anwendungen](https://tutego.de/blog/javainsel/2013/09/true-type-fonts-in-swingawt-anwendungen.md)
- Next: [Was sind Markierungsschnittstellen (Marker-Interfaces)?](https://tutego.de/blog/javainsel/2013/09/was-sind-markierungsschnittstellen-marker-interfaces.md)