Methode die 2 int Werte tauscht?
Guten Abend,
ich habe gerade mit Java "angefangen", also lerne es seit einem Monat, und es ist meine erste Programmiersprache! Ich mache deshalb einige Aufgaben von Websites um mich etwas zu testen. Dabei bin ich auf diese gestoßen:
"Versuch eine statische Methode zu schreiben, um den Inhalt von 2 Ints zu tauschen."
Ich habe gar keine Idee wie ich das lösen kann, ich möchte auch keinen fertigen Code, nur hat jemand für mich ne Idee, oder halt das etwas erklärt wie man es machen kann, halt nur in Worten gefasst, habe da wirklich keine Vorstellung :/
8 Antworten
In Java dürfte das nicht so einfach funktionieren.
Eine Möglichkeit hat "Ecaflip" ja bereits gepostet. Um noch eine andere zu bringen:
public static void main(String[] ARGS){
int[] testArr = new int[2];
testArr[0] = 1;
testArr[1] = 2;
System.out.println(testArr[0] + " " + testArr[1]);
swap(testArr);
System.out.println(testArr[0] + " " + testArr[1]);
}
public static void swap(int[] testArr){
int c = testArr[0];
testArr[0]=testArr[1];
testArr[1]=c;
}
Allerdings werden dabei halt keine 2 Integer übergeben. Also stehste im Endeffekt vor der Problematik, dass die Rückgabe nicht wie gewünscht funktioniert oder die Übergabe der Integer anders gestaltet werden muss, als über 2 Integer.
Eine andere Möglichkeit wären globale Variablen, aber das hört sich irgendwie auch nicht wie gewünscht an.
In C dürfte das alles, wenn ich mich recht entsinne, ohne Probleme möglich sein ;)
In C dürfte das alles, wenn ich mich recht entsinne, ohne Probleme möglich sein ;)
Du entsinnst dich recht! ;)
Und bei C++ ist dieses "Swapping" sogar ein extrem wichtiger Teil eines Kernkonzepts (nämlich der Verschiebesemantik), weshalb es das sogar schon fertig gibt:
Ich finde die Aufgabenstellung etwas merkwürdig, da sie gerade für Anfänger nicht lösbar ist. Sogar für viele Fortgeschrittene dürfte die Aufgabe ohne schmutzige Tricks kaum lösbar sein.
Hier ist mein Ansatz mithilfe der Reflection-API:import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class Main {
private static String findValueFieldName() throws Exception {
for (final Field field : Integer.class.getDeclaredFields()) {
if (!Modifier.isPrivate(field.getModifiers())) {
continue;
}
final Class<?> type = field.getType();
if (!type.isPrimitive() || !type.toString().equals("int")) {
continue;
}
return field.getName();
}
throw new RuntimeException("no value field found");
}
public static void swap(Integer a, Integer b) throws Exception {
final String valueName = findValueFieldName();
Field valField = Integer.class.getDeclaredField(valueName);
valField.setAccessible(true);
Field modField = Field.class.getDeclaredField("modifiers");
modField.setAccessible(true);
modField.setInt(valField, valField.getModifiers() & ~Modifier.FINAL);
final Integer tmp = new Integer(a);
valField.set(a, b);
valField.set(b, tmp);
}
public static void main(String[] args) throws Exception {
Integer a = 123;
Integer b = 456;
System.out.printf("a = %d; b = %d\n", a, b);
swap(a, b);
System.out.printf("a = %d; b = %d\n", a, b);
}
}
Dabei mache ich mir das java-typische Autoboxing zunutze. Die Ausgabe lautet:
a = 123; b = 456
a = 456; b = 123
Dazu noch folgende Bemerkungen:
- Ja, ich weiß, dass man einem Entwickler dafür den Kopf abreißen sollte, wenn er so anfängt. :)
- Ein Anfänger muss das noch lange nicht nachvollziehen können.
- Die Funktionsweise ist sehr fragil und hängt sowohl von der Implementierung einiger Klassen im JRE als auch den Optimierungen des Compilers ab. (Deshalb auch notgedrungen die merkwürdige Deklaration der Variablen "tmp", die normalerweise vom Compiler wegoptimiert wird.)
- Ich werde das Gefühl nicht los, dass die Aufgabe einfach nur total schlecht formuliert ist ... kann mir beim besten Willen nicht vorstellen, dass es sich um eine Frage für Einsteiger handeln soll.
Naja, viel Erfolg noch beim Lernen, und lass dich bitte nicht vom obigen (grauenhaften) Reflection-Code abschrecken. Normalerweise läuft dir so etwas bei ordentlicher Programmierung eigentlich niemals über den Weg. Nimm meinen Code einfach als "schlechtes und abschreckendes" Beispiel! ;)
Schönen Tag noch! :)
Deine Datenstruktur, die zu in die Funktion "eingibst" und herausbekommst muss so aussehen:
public class Tupel {
private int a;
private int b;
public Tupel(int a, int b) {
this.a = a;
this.b = b;
}
public int getA() {
return a;
}
public int getB() {
return b;
}
}
Hier einmal die Methode, die das ganze umdrehen soll, unvollständig:
public class Main {
public static Tupel swap(Tupel tupel) {
return new Tupel(..., ...);
}
}
Du musst dich dafür mit Pointern, Instanzen und Refferenzen auseinander setzten (Objektorientierte Programmierung). Oder du gibst die Integer in einem Array zurück (ist aber nicht Sinn der Aufgabe).
Da die Rückgabe ja immer nur ein Ausdruck sein kann, musst du dir denke ich mal einen Datentyp nehmen, der praktisch ist. Z.B. ein Array mit den beiden Zahlen. Du kannst dir auch selber einen schreiben. Als Beispiel ist ein Array aber ganz gut. Von der Umsetzung her hat gauldthudr richtig geantwortet.
Hier wäre ein Ansatz:
System.out.println(Arrays.toString(swap(3, 4)));
}
public static int[] swap(int x, int y) {
int z;
z = x;
x = y;
y = z;
final int[] a = new int[] { x, y };
return a;
}
//-> [4, 3]
Was dich hier halt etwas behindert ist die Aufgabenstellung. Wenn es nicht statisch sein müsste ginge auch sowas:
public class Test {
private static int x;
private static int y;
public static void main(String[] args) {
x = 3;
y = 4;
swap();
System.out.println(x);
System.out.println(y);
}
public static void swap() {
int z;
z = x;
x = y;
y = z;
}}
Anmerkung: Du kannst natürlich eine Klasse schreiben, deren globale Variabeln in einer Methode festgelegt werden und dann getauscht werden und danach holst du diese wieder einzeln raus. Das ist aber relativ sinnlos, denn dann könntest du das ganze gleich in deinen Code direkt reinschreiben.