First of all, do you understand the basics of references and objects in
Java?  If not, it's best to start there.

That said, new is *always* used to create a new object directly.  
However, there are ways that you can get other things to create objects
for you.  In that case, you won't use new because it's not your code
that is creating the object.

As for the differences:

There's no constructor at all here.  You are obtaining, from the Java
virtual machine, a reference to a String object.  Of course, the VM may
use a constructor to build the String object before giving it to you...
(or it may not; since it's the virtual machine, it doesn't always have
to follow language rules).  However, *you* aren't creating any objects;
only asking the VM for a reference to an object.

Here, you are first asking the VM for an object, and then directly
creating an object of your own.  You're using the 'new' keyword for that
second part.  However, the object you are creating is going to be
identical to the one you got from the VM, so there's really no reason to
create the extra object; but it won't do any more harm except taking up
a bit of extra memory.

Here, you are directly creating an object of your own, and then asking
the virtual machine for an object.  After you ask the virtual machine
for the object, you're throwing away your only way of finding that first
object you created... so eventually it will go away.  You once again
didn't need to create it at all, but it won't do any harm except making
more work for the garbage collector.

Here you declare a reference to a String. At that time, the reference is not
assigned to refer to any string at all. Then you assign it to refer to a
compile-time constant, which existed before you ever referred to it, and
which you did not create yourself.

Here you create a new String, using a compile-time constant as the source
of the string contents. This is pretty-much a waste of time, and you are
probably better off just saying:
   String str1 = "mystring";
This avoids creating a duplicate String.

This creates a new empty string and assigns str1 to refer to it.
It then immediately overwrites the value of str1 to refer to a
compile-time constant String instead. The empty string you
created is lost and will eventually be garbage collected. (Unless
the compiler optimized the first line away to nothing, in which
case a String was never constructed.)

Try to understand the difference between an Object and a
reference to an Object. This line:
   String str1;
does not create a String. It creates a (unassigned) reference
to a String. Conversely, this line:
   new String("ABC" + "123");
creates a new string (optimizer permitting) but immediately
forgets it because no lasting reference to it is stored -
you cannot retrieve the string in any way - it has no handle.

Steve

This "new" is bad form. It generates a clone of the string needlessly.

see http://mindprod.com/jgloss/newbie.html

--
Canadian Mind Products, Roedy Green.
Coaching, problem solving, economical contract programming.
See http://mindprod.com/jgloss/jgloss.html for The Java Glossary.

This is just a waste of effort.  Why assign a value then immediately
replace it.  Further you could use "" instead of new String() to avoid
cluttering the literal pool.

--
Canadian Mind Products, Roedy Green.
Coaching, problem solving, economical contract programming.
See http://mindprod.com/jgloss/jgloss.html for The Java Glossary.

Keep in mind that your examples are using Strings.  Strings are NOT
run-of-the-mill objects.  For example, you can't do anything like your
first example with any other kind of object (that I am aware of).

For anything BUT Strings, the answer is pretty much 'yes' you need the
new operator.  There are some exceptions, but none that a beginner is
likely to encounter for awhile.