Hallo erstmal,
kann mir irgendjemand erklären, wie ich feststellen kann ob ein Object ein Array ist oder nicht?
Ich habe eine Methode, die ein Object übergeben bekommt. Jetzt möchte ich feststellen, ob diese Object ein Array ist.
Mit if(o instanceof Array) funktioniert die Sache nicht.
Bin für jeden Tip dankbar.
Ciao
Jochen
Hallo erstmal,
Hallo Jochen!
kann mir irgendjemand erklären, wie ich feststellen kann ob
ein Object ein Array ist oder nicht?
Erkennst Du das nicht aus der übergebenen Funktion?
Ich habe eine Methode, die ein Object übergeben bekommt. Jetzt
möchte ich feststellen, ob diese Object ein Array ist.
Mit if(o instanceof Array) funktioniert die Sache nicht.
Wenn Du das Object über die Parameterliste bekommst, mußt Du dort doch schon wissen, ob es sich bei dem Objekt um ein Array oder ein einzelnes Objekt handelt, also entweder OBJECT[] a oder OBJECT a.
Wenn Du schon mir letzterem das Objekt bekommst, dann wirst Du in Deiner Methode keine Chance habe, zu erfahren, ob es sich um ein Array handelt. Es würde ja auch ein compiler-Fehler ausgelöst, wenn der Compiler erkennt das Du ein Array in ein einfaches Objekt packen willst.
Bin für jeden Tip dankbar.
IMHO ist das also gar nicht möglich ein Array in ein einzelnes Objekt zu "vertsecken". Aber vielleicht gibt es ja doch eine Möglichkeit. Man lernt ja nie aus!
Ciao
Jochen
CU
BJ
Hallo,
erstmal danke für die schnelle Antwort. Ich erkläre dir nochmal mein Problem:
Ein Array wird doch meines Wissens in Java genauso behandelt wie ein Object. Das funktioniert auch. Ich kann einer Methode, die ein Object erwartet ein Object[] übergeben. Dann muß ich halt in der Methode das übergebene Object wieder in ein Object[] casten.
Zuerst bekommt die Methode ein Array von Objecten. Dieses Array besteht entweder aus Strings oder aus weiteren Object-Arrays. Die Methode ruft sich rekursiv auf. Wenn das übergebene Object kein Array mehr ist, wird es einfach ausgegeben. Wenn es ein Array ist, wird die Methode wieder rekursiv aufgerufen.
Jetzt hab ich halt abgefragt, ob das übergebene Object ein String ist. Das funktioniert schon. Aber mich hätte schonmal interessiert, ob es möglich ist, zu unterscheiden, ob der übergebene Parameter ein Array ist oder nicht. Wenn mein Array nämlich mal nicht mehr nur aus Strings besteht, wird die Abfrage immer komplizierter.
Ich hoffe, ich hab das jetzt irgendwie rübergebracht, was ich vorhabe.
Ciao
Jochen
Mit if(o instanceof Array) funktioniert die Sache nicht.
was soll dabei nicht funktionieren? wie lautet die Fehlermeldung?
Hallo,
da gibt es keine Fehlermeldung. Aber die Abfrage 'instanceof Array' ist bei einem Object immer false.
Ich habs schon so probiert:
if(((Object[])o).length > 1)
Das funktioniert aber auch nicht. Gibt ne ClassCastException, wenn das Object z.B. ein String ist.
Ciao
Jochen
class TestArray
{
public static void main(String[] args)
{
Object[] StrArray = new Object[1];
String str = "1";
StrArray[0] = str;
obarry(StrArray);
obarry(str);
}
static void obarry(Object ob)
{
if(ob instanceof Object[])
System.out.println("true");
else
System.out.println("false");
}
}
output: true //Parameter StrArray
output: false // parameter str
Hallo,
na so schwer ist das doch gar nicht. Man darf nicht zu kompliziert denken!!!
Mit if(o.getClass().isArray()) funktionierts einwandfrei
Gruß
Jochen
Mit if(o.getClass().isArray()) funktionierts einwandfrei
Sieht gut aus.
Trotzdem wäre es mehr im Sinne von Java, wenn du verschiedene Methoden gleichen Namens mit verschiedenen Parametern erzeugen würdest (Methodenüberladung).
Dann kannst du folgendes machen:
public void krams(String[] p)
{
/* mach was draus */
krams(wasauchimmer);
}
public void krams(String p)
{
/* mach was anderes */
/* keine Rekursion */
}
Hallo,
da hast du wohl recht, daß wäre die eleganteste Lösung. Und vor allem am meisten 'Javalike' :-)
Aber in meinem Fall würden die Methoden ehr komplizierter werden als einfacher. Hier mal meine Methode:
1 public void Ausgabe(Object o)
2 {
3 Vector objects = new Vector();
4 if(o != null)
5 {
6 if(o.getClass().isArray())
7 {
8 Object[] objArray = (Object[])o;
9 for(int i=0; i<objArray.length; i++)
10 {
11 System.out.println(i+" "+objArray[i]);
12 objects.addElement(objArray[i]);
13 }
14 for (int j=0; j<objects.size(); j++)
15 Ausgabe(objects.elementAt(j));
16 }
17 else System.out.println(o);
18 }
19 }
Mit deiner Methode könnte ich mir die Abfrage in Zeile 6 sparen, das stimmt. Aber genau diese Abfrage müsste ich dann in Zeile 15 reinpfriemeln. Denn vector.elementAt(i) liefert ja ein Object zurück und dann würde die falsche Methode aufgerufen. Da müßte ein Cast auf String folgen. Und dazu muß ich wieder abfragen, ob es ein Array ist.
Ich laß es jetzt mal so, auch wenns nicht am elegantesten ist.
Würde es überhaupt funktionieren, wenn die zwei Methoden hätte:
public void Ausgabe(Object o) und
public void Ausgabe(String s)?
String is ja auch ein Object...
Also public void Ausgabe(Object o) und public void Ausgabe(Object[] o) funktioniert irgendwie nicht so richtig. Da wird immer dieselbe Methode aufgerufen. Ein Objectarray wird ja in Java genauso behandelt wie ein Object.
Und an dem Object-Parameter kann ich nix machen. Ich krieg ein Object-Array aus einer Methode, die ich nicht ändern kann. Da geht nix mit String-Array, leider.
Aber ist jetzt ja egal!
Gruß
Jochen <--- der jetzt genug probiert hat :-)
Würde es überhaupt funktionieren, wenn die zwei Methoden
hätte:
public void Ausgabe(Object o) und
public void Ausgabe(String s)?
String is ja auch ein Object...
Richtig, so einfach ist das nicht. IM Wesentlichen entscheidet nämlich schon der Compiler, welche Methode aufgerufen wird. Wenn der nicht mit Sicherheit sagen kann, dass das Objekt ein String ist, dann sagt er sich eben: Was soll's, die andere Methode kann es in jedem Fall handhaben, die frisst ja Objekte.
Verschiedene Methoden funktionieren also nur, wenn die Parameter auch wirklich verschieden sind. Alles andere sollte mensch auch tunlichst vermeiden, da sonst sehr schnell schwer zu findende Programmfehler auftreten können, nur weil mensch mal irgendwo vergessen hat, einen Funktionsaufrufsparameter zu casten...
Das Problem in deiner Methode ist jedenfalls, dass du dem Compiler jegliche Informationen über die verwendeten Typen nimmst. "Object" ist nunmal das meiste in Java, da kann dir der Compiler nicht helfen, Fehler zu vermeiden. Deshalb ja auch die bevorzugte Verwendung der Methodenüberladung, das kann der Compiler prüfen...
Wenn die Methode wirklich so klein bleibt, wie sie ist, dann sollte das kein Problem sein, aber wenn du die mal später wiederverwenden möchtest, dann musst du i.A. selbst höllisch aufpassen, was du da reinsteckst.
Na ja, sei's drum, hast ja wahrscheinlich wirklich schon genug gefriemelt...
Stefan :)