returning a generic array

4 Message(s) by 4 Author(s) originally posted in java programming

From: ndac

Date: Wednesday, March 21, 2007

Hello,

assume I've the following:

public interface

<jargon> A boundary across which two systems communicate.  An
	interface might be a hardware connector used to link to other
	devices, or it might be a convention used to allow
	communication between two software systems.  Often there is
	some intermediate component between the two systems which
	connects their interfaces together.  For example, two {EIA-232}
	interfaces connected via a serial cable.

	See also {graphical user interface}, {Application Program
	Interface}.

	(1996-05-22)

X<E> {
...
E[] toArray();
}
public class

1. <programming> The prototype for an {object} in an
	{object-oriented language}; analogous to a {derived type} in a
	{procedural language}.  A class may also be considered to be a
	set of objects which share a common structure and behaviour.
	The structure of a class is determined by the {class
	variables} which represent the {state} of an object of that
	class and the behaviour is given by a set of {methods}
	associated with the class.

	Classes are related in a {class hierarchy}.  One class may be
	a specialisation (a "{subclass}") of another (one of its
	"{superclasses}") or it may be composed of other classes or it
	may use other classes in a {client-server} relationship.  A
	class may be an {abstract class} or a {concrete class}.

	See also {signature}.

	2. <programming> See {type class}.

	3. <networking> One of three types of {Internet addresses}
	distinguished by their most significant bits.

	3. <language> A language developed by the {Andrew Project}.
	It was one of the first attempts to add {object-oriented}
	features to {C}.

	(1995-05-01)

XImp<E> {
E[] toArray(){
E[] a = (E[])new Object[N];
...
return a;
}
}

using this like this gives me a bad cast exception?
X<String> x = new X<String>();
...
String[] a = x.toArray();
(or String[] a = (String[])x.toArray();)

what am I doing wrong here?

Regards

From: Lew

Date: Friday, March 23, 2007

wrote in message:

Hello,
assume I've the following:
public interface X<E> {
...
E[] toArray();
}
public class XImp<E> {
E[] toArray(){
E[] a = (E[])new Object[N];
...
return a;
}
}
using this like this gives me a bad cast exception?
X<String> x = new X<String>();
...
String[] a = x.toArray();
(or String[] a = (String[])x.toArray();)
what am I doing wrong here?

Arrays and generics do not play well together.

-- Lew

From: Alex Gout

Date: Saturday, March 24, 2007

ndac schreef:

Hello,
assume I've the following:
public interface X<E> {
...
E[] toArray();
}
public class XImp<E> {
E[] toArray(){
E[] a = (E[])new Object[N];
...
return a;
}
}
using this like this gives me a bad cast exception?
X<String> x = new X<String>();
...
String[] a = x.toArray();
(or String[] a = (String[])x.toArray();)
what am I doing wrong here?
Regards

You cannot just cast an object

<object-oriented> In {object-oriented programming}, an
	instance of the data structure and behaviour defined by the
	object's {class}.  Each object has its own values for the
	{instance variables} of its class and can respond to the
	{methods} defined by its class.

	For example, an object of the "Point" class might have
	instance variables "x" and "y" and might respond to the "plot"
	method by drawing a dot on the screen at those coordinates.

	(2004-01-26)

array

1. <programming> A collection of identically typed data items
	distinguished by their indices (or "subscripts").  The number
	of dimensions an array can have depends on the language but is
	usually unlimited.

	An array is a kind of {aggregate} data type.  A single
	ordinary variable (a "{scalar}") could be considered as a
	zero-dimensional array.  A one-dimensional array is also known
	as a "{vector}".

	A reference to an array element is written something like
	A[i,j,k] where A is the array name and i, j and k are the
	indices.  The {C} language is peculiar in that each index is
	written in separate brackets, e.g. A[i][j][k].  This expresses
	the fact that, in C, an N-dimensional array is actually a
	vector, each of whose elements is an N-1 dimensional array.

	Elements of an array are usually stored contiguously.
	Languages differ as to whether the leftmost or rightmost index
	varies most rapidly, i.e. whether each row is stored
	contiguously or each column (for a 2D array).

	Arrays are appropriate for storing data which must be accessed
	in an unpredictable order, in contrast to {lists} which are
	best when accessed sequentially.

	See also {associative array}.

	2. <architecture> A {processor array}, not to be confused with
	an {array processor}.

	(1995-01-25)

to another type

<theory, programming> (Or "data type") A set of values from
	which a {variable}, {constant}, {function}, or other
	{expression} may take its value.  A type is a classification
	of data that tells the {compiler} or {interpreter} how the
	programmer intends to use it.  For example, the process and
	result of adding two variables differs greatly according to
	whether they are integers, floating point numbers, or strings.

	Types supported by most programming languages include
	{integers} (usually limited to some range so they will fit in
	one {word} of storage), {Booleans}, {floating point numbers},
	and characters.  {Strings} are also common, and are
	represented as {lists} of characters in some languages.

	If s and t are types, then so is s -> t, the type of
	{functions} from s to t; that is, give them a term of type s,
	functions of type s -> t will return a term of type t.

	Some types are {primitive} - built-in to the language, with no
	visible internal structure - e.g. Boolean; others are
	composite - constructed from one or more other types (of
	either kind) - e.g. {lists}, {arrays}, {structures}, {unions}.
	{Object-oriented programming} extends this with {classes}
	which encapsulate both the structure of a type and the
	operations that can be performed on it.

	Some languages provide {strong typing}, others allow {implicit
	type conversion} and/or {explicit type conversion}.

	(2003-12-22)

array. It's not
just because you use generics, it's just the way arrays work.

From: jupiter

Date: Monday, May 28, 2007

Hello,
assume I have the following:
public interface X<E> {
...
E[] toArray();
}
public class XImp<E> {
E[] toArray(){
E[] a = (E[])new Object[N];
...
return a;
}
}
using this like this gives me a bad cast exception?
X<String> x = new X<String>();
...
String[] a = x.toArray();
(or String[] a = (String[])x.toArray();)
what am I doing wrong here?

Do not forget: .toArray() must return Object[]. It'd be nice to
be able to cast from Object[] to String[] but you can not.

You can cast the items though after storing them in Object[]
though.

Object[] obj = x.toArray();
String[] str = null;
str[0] = (String)obj[0];

Of course the cast could be wrong at runtime. You've to make
sure that all the objects in obj can be represented by String.

Seems to me that it'd be nice to have .toArray() return the
correct type someday. But even if the cast you tried to do'd
work, you'd still have the same problem at runtime if one of the
objects wasn't capable of being represented by String. I do not
think it's a trivial fix.

Next Message: function as an argument

Blogs related to returning a generic array

Parametric testing show down
@Parameters public static Collection hiearchyValues() { return Arrays.asList(new Object[][] { {Vector.class, new String[] { "java.util.AbstractList", "java.util.AbstractCollection" } }, {String.class, new String[] {} } }); } ...

Ruby Class Tutorial
I’ll leave that as an exercise to the reader return both David Thomas and David Black. As a hint I’ll just say that you can push matched objects into an array. Inheritance Inheritance is one of the three pillars of Object Oriented ...

Java Generics basics
return elementData[index]; } The syntax is same as generic class. Two methods can not have same name and argument types if they have then the compiler will give an error. Generics and Arrays You can not create a array of generic type ...

java faqs
Casting between object references is used to refer to an object by a compatible class, interface, or array type reference. 136. What is the return type of a program's main() method? A program's main() method has a void return type. ...

Developer - Artefact API (updated)
p> * @param artefactType The type of artefact to retrieve, ie "Task" * @return An array of GrailsClasses which may empty by not null * @since 0.5 */ public GrailsClass[] getArtefacts(String artefactType); /** *

Get an artefact ...

Scala for Java programmers - Part 2
object Main { def func(s: String) : boolean = { return s.startsWith("J"); } def print(s: String): unit = { Console.println(s); } def main(args: Array[String]) : unit = { var list = List("hello", "world", "Java"); // pass method ...