Something like

1. PShape myShape;
2. 
   
3. void loadOrCreateShape( String name, String otherArgs ){ 
4.   myShape = loadShape( name );
5.   if( myShape == NULL ){ // Shape did not exist
6.     createShape( name, otherArgs );
7.   }
8. }

If I understood correctly your problem, you should use a HashMap to associate your strings with a PShape.
A HashMap<String, PShape>, then. If a get() of the string returns null, then the shape doesn't exist yet.

Thanks to both. The HashMap notion seems perfect. I think the "loadShape" solution is not recommended, since it does have to be done within the draw function.

I wonder why "exists" doesn't exist in Processing.

" I wonder why "exists" doesn't exist in Processing."
Because there are HashMaps for this functionality?

Wouldn't "exists" be so much easier? As I understand your explanation, someone has to deliberately create the HashMap, and then my method has to check whether it contains the label of the PShape I am asked to use.  In my specific case, I can arrange that, but I'd much rather have the kind of simple, natural, and general solution that would be offered by "if(exists(x))". Too bad it isn't there.

Is the HashMap approach always effective? Suppose I want to know whether someone has declared or generated a variable "foo23", should I expect that it will be registered in an automatically created HashMap somewhere? Could I always use get("foo23"... to see if it exists?

Anyway, it would be nice if in some beginner's tutorial there was an explanation of what to do if you want to know if something exists. I spent quite a while looking through the language reference, the tutorials, and the examples, before coming to the forum for advice. The answer may well be there, but I didn't come across it.

I think you are missing the fact that Java (thus Processing) is a static language: everything is defined beforehand. You don't check if a variable foo23 exists, because you have to declare it anyway.

What would be the semantic of the exist() function? What would it take as parameter? What would it check?

The interest of HashMap is that it is flexible: you can put anything as key: a String, an Integer, an object you created yourself. And of course, values are whatever you want too. An " automatically created HashMap" would be less flexible, and I still fail to see what you want to put in it.

But you might have a point on the tutorials, perhaps a good explanation of what is a HashMap, how it works and how to properly use it is missing.
But it is OK to ask in the forums, these are here for that!

I guess my almost complete ignorance of Java is the main problem, then. I did write a few very small programs when trying to learn what Java was about, but that was quite a few years ago. I'm a scientist, not a frequent programmer, but I'm not a novice programmer, having written my first program in machine code (before assemblers were invented) in 1954.

Right now, I'm trying to compare Processing with LiveCode for ease of use and power, and learning Java comes for free as an element of learning Processing. LiveCode has " if exists(entity)" (entity is any kind of object) and "thereIs" (as in "if there is a process procname" or "if there is a file FilePath") to do this kind of thing, so I expected to be able to do it equally easily in Processing. I'm using Processing to build a programme I want to have handy, and will use LiveCode to write a companion programme that analyses the output of the Processing programme. I'm hoping that I can figure out a way to get them to call each other, but that's a long way off.

To answer your question more directly, I suppose if I were to write a function "exists(entity)", I would have to have previously created some sort of global HashMap into which I would have entered everything I declared, and then within the "exists" method I would try a get() on that HashMap for the entity. In effect, that would mean declaring everything twice, but I imagine it would work. Does that sound right?

OK, thanks for the background.

I don't know LiveCode, but you have to be aware of two kinds of languages: static languages, like Java (or C or Pascal, etc.) require to declare everything, so that the compiler can do static checks of the validity of the code. The latter is good to validate the code and report errors even before running the code, but requires more code to be written and is quite rigid.
Dynamic languages, like JavaScript (or Python, Lua, etc.) are more flexible, allow to create variables on the fly, can sometime store a string in a variable holding previously a number, etc. Some people like the ease of coding in these languages, others say they are more risky in production (enterprise software), unless making tons of unit tests, because an error can happen because the code took a route rarely used and reveal an error uncaught so far (precisely like calling a function with a string instead of a number...), error that would have been caught by a static compiler.

Well, I err a bit, but what I wanted to say is that some languages allow things that are hard and inefficient in other languages. Like having an eval() function taking an expression (or a code fragment) and running it, or listing all the entities created so far, and so on.

In Processing, doing an exist() function would need to keep track of all objects created. It would need either to plug into the JVM (the Java Virtual Machine, taking care of the lifetime of the objects) which is hard to impossible (unless instrumenting the code, perhaps, kind of advanced topic) or to keep a reference to each created object. At least for the Processing-specific types like PShape or PImage.
But then, it would mean that memory would never be released! Because the garbage collector of Java will release memory of an object only when it has no longer any reference on it.
Well, there are weak hash map for this case, I suppose (thinking while typing...), but that's another case, and a failed experiment with PImage, resulting in a kind of memory leak, shown that's not an easy topic...

All this to say such feature is very hard to do correctly in Java (if at all, in an efficient way, ie. not slowing down the sketches and eating a lot of memory...); while it is quite trivial and flexible to do it with your own HashMap.
Processing is all about making life of coders easier, but sometime the cost is too high to be practical.

That said, if you still need help to tame your HashMap, just ask.

Thanks for the very clear explanation. I need trouble you no further on this question.