Thanks, Kevin, for the detailed answer. Sounds good
to me :)
Vasudev
--- Kevin Mukhar <[EMAIL PROTECTED]> wrote:
> I don't think that any of the responses that you've
> received are correct.
>
> RVASUDEV wrote:
> >
> > In a code fragment like this (the JDBC stuff is
> not relevant, just used as
> > an example):
> >
> > // load driver, connect to dbURL, create
> Statement, execute query.
> > ResultSet rs;
> > while (rs.next()) {
> > String col = rs.getString(1);
> > // do something with col
> > }
> >
> > My question : how is the
> declaration/definition/allocation of the col String
> > object handled ?
> > Is it like this :
> >
> > a) col is declared/defined/instantiated
> only on the first iteration
> > of the loop,
> > and the same object is used on all
> subsequent iterations
> >
> > or
> >
> > b) a new col Java object is
> declared/defined/instantiated on each
> > iteration and
> > goes out of scope and is a candidate for
> garbage collection) at the
> > closing
> > brace of the while loop ?
> >
>
> Keith R Gilbertson wrote:
> >
> > If you were to use a StringBuffer instead of a
> string, javac is smart
> > enough to optimize so that the object is created
> outside of the loop.
> > However, since you have chosen to use a String
> here, and Strings are
> > immutable, a new String object must be created
> (without your interference)
> > every time you assign a new value to the String.
> This will happen
> > regardless of whether the String col variable was
> declared inside or
> > outside of the loop.
>
> The error here is to confuse the variable col with
> the object that col refers
> to. Based on the code example, javac is not "smart
> enough to optimize so that
> the object is created outside of the loop." The
> _reference_ may be declared
> inside or outside of the loop and it is possible
> that javac might move the
> declaration of col outside the loop. If you declare
> the reference inside the
> loop, you are telling the compiler that the
> reference is valid ONLY inside the
> block created by the if statement. If the compiler
> moves the declaration outside
> the loop, the compiler must not allow any code
> outside the loop to use the
> reference.
>
> The String objects, if any are created at all, are
> created inside the loop.
> Whether or not new String objects are created
> depends upon the class that
> implements ResultSet which is an interface. When you
> call rs.getString, it is
> entirely possible that the String already exists and
> that the method returns a
> reference to an already existing String. It is also
> possible that the String
> already exists and that the ResultSet object creates
> a copy and passes a
> reference to the new String. Or, perhaps the data
> exists in some other form and
> the ResultSet creates a new String and passes a
> reference to the new String.
>
> > In theory each String is eligible for garbage
> collection immediately after
> > all handles to the object have been lost; here,
> when the assignment
> > statement is performed. But the objects aren't
> guaranteed to be garbage
> > collected at all. This is something to consider,
> depending on how many
> > instances of your servlet will run concurrently.
>
> Only if ResultSet created a new String. Then that
> new String is eligible for gc
> when col is assigned a reference to a different
> String or when the loop
> completes and execution passes outside of the block.
> If ResultSet returns a
> reference to an already existing String, then
> presumably ResultSet holds a
> reference to the String, so reassigning col does not
> eliminate all references
> and the String is not eligible for gc.
>
> Ernie V wrote:
> >
> > The answer is (b), although it is not always clear
> with String objects whether a
> > new instance will be created on each itteration.
> And there is no gaurantee that
> > the allocated memory will be garbage collected. I
> would use StringBuffer in this
> > case and declare it outside the loop.
>
> Well, this answer is closer to what I consider to be
> correct, but for the wrong
> reason. As I stated above, it does not depend upon
> the nature of String but upon
> the class that implements ResultSet.
>
> Using a StringBuffer may or may not be effective.
>
> This would create a new StringBuffer object every
> time and assign the reference
> to col:
> StringBuffer col;
> while (rs.next()) {
> col = new StringBuffer
> (rs.getString(1));
> }
>
> This would reuse the same StringBuffer object every
> time
> StringBuffer col;
> while (rs.next ()) {
> col = StringBuffer.append
> (rs.getString (1));
> //do something with col
> col.setLength (0) //clears the
> contents of the StringBuffer
> }
>
> Colin Watford wrote:
> >
> > rs.getString(i) creates the first string.
> > The value of col is copied into col.
> >
> > Each time the loops go round, then the last
> col and getString are
> > flagged for GC - no refernces left. New
> Strings are allocated space
> > for the new connections.
>
> Again, whether rs.getString creates a new String or
> not depends upon the
> implementation of the class. The value of col is not
> copied into col because col
> is not an object, it is a reference to an object.
> The method rs.getString
> returns a reference to a String object; the
> reference is assigned to the
> variable col.
>
> The variable col cannot be flagged for gc because it
> is not an object, it is a
> variable. If a new reference is assigned to col,
> then the String that col
> previously referred to may be marked for gc if there
> are no other reference to
> the String. If col was declared inside the block,
> when execution passes outside
> the block col is out of scope and the last String
> that col referred to is now
> eligible for gc if there are no other references to
> the String.
>
> Finally, in answer to your question, I believe the
> answer to be c, some other
> way.
>
> The variable col is declared inside the loop. The
> compiler will create the
> variable only once. Where the compiler creates the
> variable depends upon the
> compiler. The same variable is used on all
> iterations of the loop. Each time
> through the loop, depending upon the class that
> implements ResultSet, a new
> String object may or may not be created. A reference
> to each String object is
> assigned to the variable col. If the class that
> implements ResultSet simply
> passes a reference to an existing String object,
> then
=== message truncated ===
__________________________________________________
Do You Yahoo!?
Thousands of Stores. Millions of Products. All in one place.
Yahoo! Shopping: http://shopping.yahoo.com
___________________________________________________________________________
To unsubscribe, send email to [EMAIL PROTECTED] and include in the body
of the message "signoff SERVLET-INTEREST".
Archives: http://archives.java.sun.com/archives/servlet-interest.html
Resources: http://java.sun.com/products/servlet/external-resources.html
LISTSERV Help: http://www.lsoft.com/manuals/user/user.html
