java deallocates memory automatically?

I was looking for a method to turn a byte array into a string, the only way I found is this:

String s1="horse";
String s2;
byte[] b=s1.getBytes();
s2=new String(b);

So my questions are, is there any other way to convert a byte array to a string without creating a new instance of String?
Also if I repeatedly did:

String s;
while(true){
  s=new String();
}

Would take up more and more memory, or it is automatically deallocated and reallocated? If the memory were deallocated automatically, I would no longer have to look for an alternative method to convert an array of bytes to a string.

P.S.(I want s2 to be "horse")
P.S.2(Sorry my bad english)

The comment by Johannes is a good starting place as Garbage collection is a key concept in Java.

To answer your questions though, no you will need to create a new instance of string when initializing with a byte array.

In your second code snippet:

String s;
while(true){
  s=new String();
}

What we have is a String 's' which is a String pointer to nothing. Then in your loop you point this to a String object on the heap. When you reassign 's' in the loop it will allocate more memory for your new String and then the garbage collector will pick up the old String object from the heap. This is because the object has nothing referencing it anymore.

Here's a good article on string immutability.

> So my questions are, is there any other way to convert a byte array to a string without creating a new instance of String?

No there isn't. Java strings are immutable. That means that you cannot update / replace the characters in a string. Converting a byte array to an existing string would violate immutability.

> String s;
> while (true) {
> s = new String();
> }
>
> Would take up more and more memory, or it is automatically deallocated and reallocated?

Memory is automatically reclaimed by the Garbage collector (GC). The GC runs occasionally, identifies objects that are no longer reachable; i.e. that the program cannot find anymore. Those objects are then deleted.

^{That is the simple version. In reality not all "lost" objects are reclaimed at the same time, and there are some special kinds of reachability that are handled differently.}

Anyway, in your example, each time the program goes around the loop, a new String object is created, and the reference to the previous String is lost. Then later (as required) the GC finds and deletes the lost objects.

> If the memory were deallocated automatically, I would no longer have to look for an alternative method to convert an array of bytes to a string.

It is, and you don't.

In Java, you just let the runtime system deal with allocation and deallocation of object memory. (Just make sure that you don't cause objects to remain reachable by accident.)