Processing - Recent changes [en]

Why use ArrayList instead of array with append()?

2012-05-13T08:12:03Z

Adding more on typed array lists

← Older revision		Revision as of 08:12, 13 May 2012
Line 2:		Line 2:

	A legitimate question is: "Why?"...		A legitimate question is: "Why?"...
		+
		+	==== append() ====

	append() has been designed in the first times of Processing, where usage of objects and casting were avoided, and it was supposed simpler to use than array lists.		append() has been designed in the first times of Processing, where usage of objects and casting were avoided, and it was supposed simpler to use than array lists.
Line 17:		Line 19:

	There is nothing that can be done to improve this process, as the constraint of append() is to return a pure Java array, where the field <code>length</code> must be equal to the number of items in the array.		There is nothing that can be done to improve this process, as the constraint of append() is to return a pure Java array, where the field <code>length</code> must be equal to the number of items in the array.
		+
		+	==== ArrayList ====

	[http://download.oracle.com/javase/6/docs/api/java/util/ArrayList.html ArrayList] actually works in a similar way, with an additional optimization, and an additional inefficiency...		[http://download.oracle.com/javase/6/docs/api/java/util/ArrayList.html ArrayList] actually works in a similar way, with an additional optimization, and an additional inefficiency...
Line 37:		Line 41:
	And arrays aren't obsolete: if you know in advance the size of your data, use arrays, they are the most efficient and their syntax is simple. You can also make an oversized array and maintain a counter pointing at the last current element of the array.		And arrays aren't obsolete: if you know in advance the size of your data, use arrays, they are the most efficient and their syntax is simple. You can also make an oversized array and maintain a counter pointing at the last current element of the array.

		+	==== Typed collections ====

	A last note: Processing reference, at the time of writing, presents only the old version of ArrayList, untyped.		A last note: Processing reference, at the time of writing, presents only the old version of ArrayList, untyped.
	So you have to cast back the value you get to the original type.		So you have to cast back the value you get to the original type.

-	~~It is no longer the case in recent Processing versions, you can use generics to indicate what you store~~ in the ~~list~~:	+	Listing in the old way looks like:
	<source lang="processing">		<source lang="processing">
	// A common convention is to use plural names for arrays and array lists		// A common convention is to use plural names for arrays and array lists
		+	ArrayList images = new ArrayList(); // Array list of PImage: must add a comment to indicate what is it
		+	image.add(someImage);
		+
		+	// Later...
		+	PImage img = (PImage) images.get(n); // We can a very generic Object, we must cast back to the real type
		+
		+	// Looping
		+	for (int i = 0; i < images.length; i++)
		+	{
		+	// Get the value at this index
		+	PImage img = (PImage) images.get(i);
		+	// use img
		+	}
		+	</source>
		+	Before Java 1.5, collections like ArrayList were untyped, meaning you could put anything in them, they store them as Object, the base type of any object in Java. And you needed to cast back (to indicate to the compiler what is the real type) the object you got to be able to use it.
		+	In practice, good practice at least, you always store objects of same type in a collection, so it was more an inconvenience than an advantage.
		+
		+	In recent Processing versions you can use generics to indicate what you store in the list. This is the type between angle brackets following the collection type:
		+	<source lang="processing">
		+	// This array list will store only PImage objects. Note that you can put sub-types in them: a PGraphics is OK there!
	ArrayList<PImage> images = new ArrayList<PImage>();		ArrayList<PImage> images = new ArrayList<PImage>();
	image.add(someImage);		image.add(someImage);

	// Later...		// Later...
-	PImage img = images.get(n);	+	PImage img = images.get(n); // See mom, no cast!

-	// ~~The~~ foreach syntax:	+	// If you don't need an index in the loop, you can use the new foreach syntax:
-	for (PImage img : images)	+	for (PImage img : images) // Combines the above for with the img = images.get() statement
	{		{
	// use img directly		// use img directly
	}		}
	</source>		</source>
		+	Note: some collections like HashMap need two types (eg. key and value). Syntax is: <code>HashMap<String, PVector></code>.<br/>
		+	You can also make collections of collections: <code>HashMap<String, ArrayList<PVector>></code>.

Technical FAQ

2012-05-13T07:57:05Z

Dividing bases, adding seq & timing. To do: explain exceptions. Add references to other articles elsewhere in the wiki.

← Older revision		Revision as of 07:57, 13 May 2012
Line 2:		Line 2:
	* [[What is a color in Processing?]]		* [[What is a color in Processing?]]
	* [[What are setup() and draw()?]]		* [[What are setup() and draw()?]]
		+
		+
		+	Sequencing and timing
	* [[I display images in sequence but I see only the last one. Why?]]		* [[I display images in sequence but I see only the last one. Why?]]
	* [[How do I display a message for a few seconds?]]		* [[How do I display a message for a few seconds?]]
Line 19:		Line 22:

	Exceptions		Exceptions
		+	* [[What is an exception?]] (also explains the "Unhandled exception type XxxException" error)
	* [[Why do I get a NullPointerException?]]		* [[Why do I get a NullPointerException?]]
	* [[Why do I get an ArrayIndexOutOfBoundsException?]]		* [[Why do I get an ArrayIndexOutOfBoundsException?]]
		+	See also [[CommonErrors \| Common Error Messages]] and [[Troubleshooting]]


	Eclipse		Eclipse
	* [[How I can make a sketch with libraries in Eclipse?]]		* [[How I can make a sketch with libraries in Eclipse?]]

Why I can't create a class of a library from my own classes?

2012-05-10T19:15:22Z

A bit of clarification

← Older revision		Revision as of 19:15, 10 May 2012
Line 12:		Line 12:

	But classes created outside of this <code>PApplet</code> class, like library classes (or those put in .java files in your sketch folder), haven't such direct access. Actually, they don't have an access at all, unless they are provided with a reference to the instance of this class (ie. the running sketch).		But classes created outside of this <code>PApplet</code> class, like library classes (or those put in .java files in your sketch folder), haven't such direct access. Actually, they don't have an access at all, unless they are provided with a reference to the instance of this class (ie. the running sketch).
-	That's why they ask to provide such reference in the constructor, which they store and use to access to drawing functions, events, etc. They do something like:	+	That's why they ask to provide such reference in the constructor, which they store and use to access to drawing functions, events, variables, etc. They do something like:
	<source lang="processing">		<source lang="processing">
	public class SomeClass		public class SomeClass
Line 49:		Line 49:

	The problem is that <code>this</code> refers to the current class. So, here, it refers to Stuff, and there is no GButton constructor accepting this "Stuff" as parameter. Result: you get an error, protesting that you gave a reference to some class that isn't a <code>PApplet</code>.		The problem is that <code>this</code> refers to the current class. So, here, it refers to Stuff, and there is no GButton constructor accepting this "Stuff" as parameter. Result: you get an error, protesting that you gave a reference to some class that isn't a <code>PApplet</code>.
		+
		+	In other words, only the <code>this</code> available in Processing functions like <code>setup()</code>, <code>draw()</code> or <code>keyPressed()</code> can be used as parameter.

	Fortunately, the solution is simple: adopt the same idiom as above for your own classes. Ie. make your constructor to get a <code>PApplet</code> parameter, fed with <code>this</code> from the main code, and pass <code>pa</code> (or whatever you call it) to the library class' constructor where <code>this</code> (the <code>PApplet</code> reference) is expected.		Fortunately, the solution is simple: adopt the same idiom as above for your own classes. Ie. make your constructor to get a <code>PApplet</code> parameter, fed with <code>this</code> from the main code, and pass <code>pa</code> (or whatever you call it) to the library class' constructor where <code>this</code> (the <code>PApplet</code> reference) is expected.
Line 55:		Line 57:
	class Stuff		class Stuff
	{		{
-	Stuff(PApplet pa, String buttonName)	+	Stuff(PApplet pa, String buttonName) // 'pa' here is equivalent to 'this' in Processing code
	{		{
	GButton btnSmile0 = new GButton(pa, buttonName, 3, 20, 270, 70, 70);		GButton btnSmile0 = new GButton(pa, buttonName, 3, 20, 270, 70, 70);
Line 65:		Line 67:
	Stuff stuff = new Stuff(this, "smile.png"); // Here, 'this' really refers to the PApplet		Stuff stuff = new Stuff(this, "smile.png"); // Here, 'this' really refers to the PApplet
	</source>		</source>
		+
		+	If you have other classes to instantiate from one of your class, you pass along the PApplet parameter to each constructor, a bit like a token / relay baton. Whenever you need a PApplet <code>this</code>, you use the <code>pa</code> field / parameter that have been transmitted via the constructor. The described process applies to each class needing such parameter.