<p>I want to save the objects I generated in a program. After restart the App should load automaticly all Objects in an Array. I want to write them in a file and parse them after restart. Are the other smarter possibilities than do it by hand?
Thank you</p>

Yes, the concept you are looking for is called serialization. There's a fine tutorial at Sun
here
.
The idea is that classes you want to persist have to implement the Serializable interface. After that you use java.io.ObjectOutputStream.writeObject() to write the object to a file and java.io.ObjectInputStream.readObject() to read it back.
You can't serialize everything, as there are things that don't make sense to serialize, but you can work around them. Here's a quote about that:
The basic mechanism of Java
  serialization is simple to use, but
  there are some more things to know. As
  mentioned before, only objects marked
  Serializable can be persisted. The
  java.lang.Object class does not
  implement that interface. Therefore,
  not all the objects in Java can be
  persisted automatically. The good news
  is that most of them -- like AWT and
  Swing GUI components, strings, and
  arrays -- are serializable.
On the other hand, certain
  system-level classes such as Thread,
  OutputStream and its subclasses, and
  Socket are not serializable. Indeed,
  it would not make any sense if they
  were. For example, thread running in
  my JVM would be using my system's
  memory. Persisting it and trying to
  run it in your JVM would make no sense
  at all. Another important point about
  java.lang.Object not implementing the
  Serializable interface is that any
  class you create that extends only
  Object (and no other serializable
  classes) is not serializable unless
  you implement the interface yourself
  (as done with the previous example).
That situation presents a problem:
  what if we have a class that contains
  an instance of Thread? In that case,
  can we ever persist objects of that
  type? The answer is yes, as long as we
  tell the serialization mechanism our
  intentions by marking our class's
  Thread object as transient.