You're right.  I was confusing the (char[],int,int) constructor with the
(int,int,char[]) constructor.

Actually, it's the opposite.  The substring method does not copy the
contents but just returns a new String object pointing to the same
backing.  The String(String) constructor does do the copy if the
existing char[] is too big.  If you look at the code there, it
specifically checks whether the original String has a char[] that's
longer than its effective length... and if so, it allocates a different
char[] of the right size, and copies the relevant data into it.

(Notice that substring does use the String(int,int,char[]) constructor,
which does NOT copy anything.)

No, I haven't misunderstood at all.  Perhaps if you explained why you
disagree with my statement, we could have a productive discussion on the
matter.  I am missing that part of your reply, though.

If you don't agree, perhaps you'd like to explain how C++ templates
provide anything powerful enough to express the equivalent of the
following method signature with Java generics:

   public void doSomething(List<? extends Auditable> events);

or perhaps the C++ equivalent of:

public class MyClass<T extends Comparable<T>> { ... }

You see?  You can't do it.  These are type system features, and C++
templates don't provide them.  In fact, type-checking a program that
uses a C++ template means expanding the template and then type-checking
the equivalent program without templates.  The only checking that occurs
then is the minimal amount needed to prevent undefined behavior.  In
particular, this scheme is vulnerable to spurious subsumption.

This is simple fact: C++ templates to not provide as powerful a language
for expression type constraints as Java's generics.

Your flippant comment about "generics... just add a little compile-time
type checking and automatic casting" is half wrong -- casts are
syntactic features in Java, and they don't get added by the compiler --
and half spectacularly right, but in a way that you don't seem to get.  
Generics are about expanding the language for type checking to make it
considerably more powerful in being able to express type constraints.  
That's what they do, and they do it better than anything in C++.

This is why I pointed out that it's ridiculous to talk about C++
templates being "more" or "less" powerful than generics, since they
serve different purposes.

To me, it looks as if they only serve the same purpose on a NOT very
abstract level.  Ultimately, generic collections of reference types in
Java are possible not because of generics, but because of the existence
of a universal supertype for all reference types.  Generic collections
or primitive data are not possible because Java doesn't provide a
universal supertype for primitive data (neglecting boxing conversions),
and generics don't change that.

It's important for Java programmers to understand that generics in Java
are a type system feature.  They do not in any way relate to what the
code does!  Java's generics define a somewhat intricate language for
expressing syntactic constraints on situations in which certain code is
appropriate.  Once it is determined that the code is appropriate, the
code is executed exactly as if it had not been written with generics at
all.   Generics allow the programmer to limit the range of uses of some
piece of code, and then rely on the information added by these
constraints later on.

This is a huge difference from C++ templates, the whole purpose of which
is to write templates for code, which are expanded to different code
under different uses.  While some of the possible expansions of
templates may differ from each other only in type checking, there are
others that differ from each other in terms of static resolution of
method calls, or even (with template specialization) completely
different structures of code.  At the same time, C++ templates do NOT
provide any fundamentally new vocabulary for expressing type
constraints.  Every pure type constraint on code using C++ templates is
a type constraint from the non-templated subset of the C++ language
after expansion of the templates.  (I'm neglecting the type constraints
that are defined on non-type template parameters, as in
"template<int a>", because they are outside the scope of the discussion
here.)  Unlike Java, in which generics augment the subtype relation with
wildcard types that allow more flexible typing of expressions, C++
templates don't introduce any type relationships that wouldn't otherwise
be there.

Clearly, it's possible to find similarities between these two features,
but I certainly wouldn't call them abstract.  Instead, the similarities
seem to be that both features are used in the context of collection
classes.