Why String class was declared as final.

Why String class was declared as final.
Thanks
Mohan

http://bugs.sun.com/bugdatabase/view_bug.do;jsessionid=d92720bd3ed4dffffffff95e59403ecf4db1:YfiG?bug_id=4095367

Similar Messages

Why String class is defined as immutable?

Why String class is defined as immutable? what can be the reason behind it?

Do try this at home. :)
public class Main {
    public static void main(String... args) {
        System.out.println("Greetings.");
        System.out.println("Goodbye.");
    static {
        // translates into Japanese. NOT a good idea!
        try {
            final Field field = String.class.getDeclaredField("value");
            field.setAccessible(true);
            char[] chars = new char[8];
            "Sayonara".getChars(0,8,chars,0);
            field.set("Goodbye.", chars);
            chars = new char[10];
            "Konichi-wa".getChars(0,10,chars,0);
            field.set("Greetings.", chars);
        } catch (Exception e) {
            throw new AssertionError(e);
}

Doubt with String class

Please tell me why String class objects are immutable. Why it was designed like that?

Read Java tutorials.Thanks for your reply. But tutorial says thatString
objects are immutable but they dont say why
they
made
as immutable.Welcome swathi.reply #4 is the best answer Ithink.
But please look at my reply #8Please look at reply#2 in the other thread.But reply #2 was mine. I dont understand what you say? Please help me.

Why I should declare a final object!

import java.util.*;
public class Problem {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
System.out.println("Exiting.");
timer.cancel();
5000);
System.out.println("In 5 seconds this
application will exit. ");
When I complie the program there is one error as follow:
Problem.java:11: local variable timer is accessed from within inner class; needs
to be declared final
timer.cancel();
1 error
I don't kown why I must declare the timer as "final"!
Help me!

What you have is an anonymous inner class. For this class to be able to access local variables in the containing class they must be final. When the compiler compiles the code it will create the inner class with a reference to the variable. If you were able to change the variable the inner class would lose the reference.

Why should we not declare Class with protected modifier ?

Why should we not declare Class with protected modifier ?

jwenting wrote:
georgemc wrote:
Why we not research our endless questions?how else could you reach 14000 posts in under 3 years, a true achievement :) Congratulations.Ah, that reminds me. It was a long time ago since I posted some stats:
Posts:
jverd                        46427   2972   0,06
DrClap                       36310   5222   0,14
jschell                      32357   2583   0,08
CeciNEstPasUnProgrammeur     31500   1438   0,05
camickr                      29870   4783   0,16
yawmark                      28729   1803   0,06
kajbj                        24180   1829   0,08
BalusC                       22857   2875   0,13
warnerja                     21886   2188   0,10
ejp                          19929   3247   0,16
sabre150                     17537   1913   0,11
paulcw                       16005   1724   0,11
DrLaszloJamf                 14857   1840   0,12
georgemc                     14000    889   0,06
prometheuzz                  13466   1180   0,09
cotton.m                     13409   1308   0,10
ChuckBing                    12667   1735   0,14
JosAH                        11926    842   0,07
flounder                     11607   1201   0,10
mlk                          10795    886   0,08
Darryl.Burke                 10564   1787   0,17
Encephalopathic              10203   1508   0,15
tjacobs01                     9540   1658   0,17
BigDaddyLoveHandles           8980    763   0,08
dcminter                      8081    533   0,07
tsith                         8049    704   0,09
jwenting                      7831    249   0,03
malcolmmc                     7539    819   0,11
Michael_Dunn                  7392   2088   0,28
PhHein                        7360   1207   0,16
morgalr                       7081    703   0,10
pbrockway2                    6471   1208   0,19
BIJ001                        6179    322   0,05
JoachimSauer                  5824    604   0,10
abillconsl                    5777    943   0,16
corlettk                      5671    544   0,10
TuringPest                    5651    444   0,08
masijade.                     5396    434   0,08
YoGee                         4695    530   0,11
gimbal2                       3642    315   0,09
uncle_alice                   3496   1009   0,29
bshannon                      3427    614   0,18
tschodt                       3236    280   0,09
sjasja                        3193    459   0,14
SoulTech2012                  3005    109   0,04
Peter__Lawrey                 2847    254   0,09
Torgil                        2175    358   0,16
Navy_Coder                    2119    648   0,31
rukbat                        1951    252   0,13
java_2006                     1913   1123   0,59
baftos                        1808    665   0,37
es5f2000                      1718    192   0,11
AndrewThompson64              1716    973   0,57
YAT_Archivist                 1713    230   0,13
Aknibbs                       1693     86   0,05
drvijayy2k2                   1574    266   0,17
StanislavL                    1396   1117   0,80
stefan.schulz                 1159    208   0,18
JayDS                         1100    410   0,37
dannyyates                    1094    211   0,19
Joerg22                       1046     48   0,05
uj_                           1033     49   0,05

Why we should not declare a business method as final in EJBs - THX

Why we should not declare a business method as final in EJBs - THX

'cause it makes no sense at all and doesn't boost performance.
regards
dan
scpj2

Why String need to be final?

Why String need to be final?

Final or immutable? Final so that you are not tempted to extend String. You are supposed to use String. Immutable for the salient reasons previously posted.
- Saish

Did the Java Writers Get a Little Happy with Memory Use in String class?

I mean that question half jokingly.
Taking a look at the String class code, I saw the following (below).
Why is there an int for offset and an int for count?
String is immutable, why not just return value.length for the count?
And what is the offset for?
Thanks!
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
    /** The value is used for character storage. */
    private final char value[];
    /** The offset is the first index of the storage that is used. */
    private final int offset;
    /** The count is the number of characters in the String. */
    private final int count;
    /** Cache the hash code for the string */
    private int hash; // Default to 0PS: a second look kinda verifies it too.
in the constructor ,count is even defined as value.length.
    public String(char value[]) {
     int size = value.length;
     this.offset = 0;
     this.count = size;
     this.value = Arrays.copyOf(value, size);
    }

You don't get the choice. The arrays are shared
whenever you do substring.Yea, thats my point. I think most Strings are unique.
Id be very surprised if even 2% of all String use was
a result of a substring.The wrapper classes use it for parsing.
File uses it for getName and getParent.
String uses it for trim.
Class uses it for resolving names.
Regex uses it.
etc. ...
Now, I don't know what percentage of usage all that amounts to, but it IS heavily used.
So your desire to gain the 2 bytes back would cost enough byte every time substring is used that it might end up costing far more than the 8 bytes you save.

Why no class CodePoint ?

I find the implementation of code point handling in the Character class quite cumbersome.
A class "CodePoint" that supercedes "Character" in the long run would look more logical and more convenient in usage to me.
What's the reason why this road was not taken?

The current design allows to handle code points
correctly but encourages the average programmer to
just ignore them (and continue to use Characters)
because the code point API is so cumbersome and
supplementary characters are hardly ever needed.
If we had an additional CodePoint class that contains
all the methods of Character that take an "int
codePoint" we would surely see more programs that
handle all possible characters correcty. And it would
be type safe too (I hate to use int)In the design justification (given in the Index page of the JSR 204 final draft) they discuss not just the representation of characters using char/char32/int/CodePoint, but also Strings. I think this is the significant point. Presuming that we don't have a new type of String for supplementary characters, we need to expand String's API so it can be 'viewed' as comprising both chars and code points. But if the latter are represented as a new CodePoint class, it's hard to avoid a lot of slow boxing/unboxing to convert chars to CodePoints.
I agree though that the new methods aren't pretty, such as this one from String:
int offsetByCodePoints(int index, int codePointOffset); // in effect advances an index (measured in chars) by codePointOffset (measured in codePoints) to return another index (measured in chars).
This seems to be the only String method which 'knows' whether a codepoint in a String consists of 1 or 2 chars. So iteration code will look something like this:
String text = whatever;
int index = 0;
while (blah) {
int codePoint = text.codePointAt(index);
// ...process this character
index = text.offsetByCodePoints(index, 1); // skip a Unicode 4.0 character
Not very pretty. Alternatively you could use index += Character.charCount(codePoint), but doing iteration 'by hand' like this without using String methods is a bit unfortunate. Perhaps they should have provided a CodePointIterator for String (+Buffer/Builder) which returns ints (and thus can't be an instance of Iterator).
String text = whatever;
CodePointIterator it = text.codePointIterator();
while (it.hasNext()) {
int codePoint = it.next();
// ...process this character
Or even, if they added a CodePoint class, they could have made made String implement Iterable<CodePoint> and thus return a genuine Iterator<CodePoint> so you can write:
String text = whatever;
for (CodePoint c : text) {
// ...process this character
AFAIK this would work OK in terms of generics but would be quite slow.

Problems with String[] Class Object

Hi guys,
I'm writing a web server who should invoke a method of a class when asked by a client.
My problem is that if the method that should be invoked has a String[] parameter the web server is unable to invoke it and throws a java.lang.IllegalArgumentException: argument type mismatch.
Useful pieces of code to understand are the following:
//create the Class[] to pass as parameter to the getMethod method
Class[] paramType = {String[].class};
//find the class "className" and create a new instance
Class c = Class.forName(className);
Object obj = c.newInstance();
//the getMethod should find in the class c the method called nameMeth
// having paramType (i.e. String[]) as parameter type...
Method theMethod = c.getMethod(nameMeth, paramType);
//here's the problematic call!!
theMethod.invoke(obj, params);I've noted that System.out.println(theMethod); prints the signature of the method with the parameter type java.lang.String[].
System.out.println(paramType[0]); instead prints [Ljava.lang.String;
I know that [L means that it is an array, so why do you think that I'm having an argument type mismatch?
Thank you

I had no problems making that work.import java.lang.reflect.Method;
public final class StringArray {
    public static final String CLASSNAME = "StringArray";
    public static final String METHODNAME = "myMethod";
    public static final String[] sa = { "a", "b"};
    // automatic no-args constructor
    public final void myMethod(String[] sa) {
        for(int i=0;i<sa.length;++i) {
            System.out.println(sa);
public static final void main(String[] arg) throws Exception {
//create the Class[] to pass as parameter to the getMethod method
Object[] params = { sa };
Class[] paramType = {sa.getClass()};
//find the class "className" and create a new instance
Class c = Class.forName(CLASSNAME);
Object obj = c.newInstance();
//the getMethod should find in the class c the method called nameMeth
// having paramType (i.e. String[]) as parameter type...
Method theMethod = c.getMethod(METHODNAME, paramType);
//here's the problematic call!!
theMethod.invoke(obj, params);

How to change the cursor type when a TableView class was added to a Swing application?

We can resize column width by dragging the column divider in the table header. This is a built-in feature of the TableView class.
Normally, the cursor will become to east-resize (or west-resize) type with positioning the cursor just to the right of a column header.
However, I found that the cursor is remaining the default type at the same position if I integrate JavaFX into Swing Application. That is adding the TableView to a Scene, and then adding this Scene to a JFXPanel, finally, adding this JFXPanel to the JFrame.
The sample codes are listing below:
public class Run extends JFrame {
    Run() {
        setSize(600, 450);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        initComponents();
    private void initComponents() {
        final JFXPanel fxPanel = new JFXPanel();
        this.getContentPane().add(fxPanel);
        Platform.runLater(new Runnable() {
            @Override
            public void run() {
                initFX(fxPanel);
    private void initFX(JFXPanel fxPanel) {
        Scene scene = null;
        try {
            scene = FXMLLoader.load(
                new File("res/fxml_example.fxml").toURI().toURL()
        } catch (Exception ex) {
            ex.printStackTrace();
        fxPanel.setScene(scene);
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new Run().setVisible(true);
fxml_example.fxml:
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.Scene?>
<?import javafx.scene.control.TableView?>
<?import javafx.scene.control.TableColumn?>
<Scene xmlns:fx="http://javafx.com/fxml">
    <TableView fx:id="tableView"
               editable="true">
        <columns>
            <TableColumn text="COL1">
            </TableColumn>
            <TableColumn text="COL2">
            </TableColumn>
            <TableColumn text="COL3">
            </TableColumn>
            <TableColumn text="COL4">
            </TableColumn>
            <TableColumn text="COL5">
            </TableColumn>
        </columns>
    </TableView>
</Scene>
So, are there anyone can advise how to fix these codes; make the cursor can change to east-resize (or west-resize) type when this TableView class was added to a Swing application?

Thanks for the report. I've just filed a JIRA issue: https://javafx-jira.kenai.com/browse/RT-34009
//Anton.

EXTENDING the string class

ok, i know extending the string class is illegal because it's final, but i want to make an advanced string class that basically "extends" the string class and i've seen online this can be done through wrapper classes and/or composition, but i'm lost
here is my sample code that is coming up with numerous compile time errors due to the fact that when i declare a new AdvString object, it doesn't inherit the basic string features (note: Add is a method that can add a character to a specified location in a string)
class AdvString
     private String s;
     public AdvString(String s)
          this.s = s;
     public void Add(int pos, char ch)
          int this_len = (this.length()) + 1;
          int i;
          for(i=0;i<(this_len);i++)
               if(pos == i)
                    this = this + ch;
               else if(pos < i)
                    this = this + this.charAt(i-1);
               else
                    this = this + this.charAt(i);
     public static void main(String[] args)
          AdvString s1;
          s1 = new AdvString("hello");
          char c = 'x';
          int i = 3;
          s1.Add(i,c);
          //s2 = Add(s1,i,c);
          //String s2_reversed = Reverse(s2);
          System.out.println("s1 is: " + s1);
any tips?

see REString at,
http://www.geocities.com/rmlchan/mt.html
you will have to replicate all the String methods you are interested in, and just forward it to the String instance stored in REString or the like. it is like a conduit class and just passes most processing to the 'real' string. maybe a facade pattern.

What does the trim() method of the String class do in special cases?

Looking here ( String (Java Platform SE 7 ) ), I understand that the trim() method of the String class "returns a copy of the string, with leading and trailing whitespace omitted", but I don't understand what the last special case involving Unicode characters is exactly.
Looking here ( List of Unicode characters - Wikipedia, the free encyclopedia ), I see that U+0020 is a space character, and I also see the characters that follow the space character (such as the exclamation mark character).
So, I decided to write a small code sample to try and replicate the behaviour that I quoted (from the API documentation of the trim method) in the multi-line comment of this same code sample. Here is the code sample.:
public class TrimTester {
    public static void main(String[] args) {
         * "Otherwise, let k be the index of the first character in the string whose code
         * is greater than '\u0020', and let m be the index of the last character in the
         * string whose code is greater than '\u0020'. A new String object is created,
         * representing the substring of this string that begins with the character at
         * index k and ends with the character at index m-that is, the result of
         * this.substring(k, m+1)."
        String str = "aa!Hello$bb";
        System.out.println(str.trim());
However, what is printed is "aa!Hello$bb" (without the quotes) instead of "!Hello$" (without the quotes).
Any input to help me better understand what is going on would be greatly appreciated!

That's not what I was thinking; I was thinking about the special case where the are characters in the String whose Unicode codes are greater than \u0020.
In other words, I was trying to trigger what the following quote talks about.:
Otherwise, let k be the index of the first character in the string whose code is greater than '\u0020', and let m be the index of the last character in the string whose code is greater than '\u0020'. A new String object is created, representing the substring of this string that begins with the character at index k and ends with the character at index m-that is, the result of this.substring(k, m+1).
Basically, shouldn't the String returned be the String that is returned by the String class' substring(3,9+1) method (because the '!' and '$' characters have a Unicode code greater than \u0020)?
It seems to not be the case, but why?

Where can I declare a final variable?

I'm wondering where excatly I can declare a final variable. I know I can declare them right after I start the class.
i.e.:
public class x {
     public static final Scanner CONSOLE = new Scanner(System.in);
     public static final Random GENERATOR = new Random();
}I would like to declare a final within the main method. i.e.:
     public static void main(String[] args) {
          System.out.print("Please type in your name and press return: ");
          final String NAME = CONSOLE.next();
     }Is this just not possible or am I just writing it wrong? Couldn't find an example using google. Any help?
fyi: I'm fairly new to using java so this may be obvious.

     public static void main(String[] args) {
System.out.print("Please type in your name and
nd press return: ");
          final String NAME = CONSOLE.next();
     }Is this just not possible or am I just writing it
wrong?No, you can declare a local variable final, which means that it's value can only be set once in or after the declaration. But be aware that a new variable is created each time the method is invoked.
About the only reason people do this is so it can be used in a local class declared further down the method.

Why String Objects are immutable ?

From the JLS->
A String object is immutable, that is, its contents never change, while an array of char has mutable elements. The method toCharArray in class String returns an array of characters containing the same character sequence as a String. The class StringBuffer implements useful methods on mutable arrays of characters.
Why are String objects immutable ?

I find these answers quite satisfying ...
Here's a concrete example: part of that safety is ensuring that an Applet can contact the server it was downloaded from (to download images, data files, etc) and not other machines (so that once you've downloaded it to your browser behind a firewall, it can't connect to your company's internal database server and suck out all your financial records.) Imagine that Strings are mutable. A rogue applet might ask for a connection to "evilserver.com", passing that server name in a String object. The JVM could check that this server name was OK, and get ready to connect to it. The applet, in another thread, could now change the contents of that String object to "databaseserver.yourcompany.com" at just the right moment; the JVM would then return a connection to the database!
You can think of hundreds of scenarios just like that if Strings are mutable; if they're immutable, all the problems go away. Immutable Strings also result in a substantial performance improvement (no copying Strings, ever!) and memory savings (can reuse them whenever you want.)
So immutable Strings are a good thing.
The main reason why String made immutable was security. Look at this example: We have a file open method with login check. We pass a String to this method to process authentication which is necessary before the call will be passed to OS. If String was mutable it was possible somehow to modify its content after the authentication check before OS gets request from program then it is possible to request any file. So if you have a right to open text file in user directory but then on the fly when somehow you manage to change the file name you can request to open "passwd" file or any other. Then a file can be modified and it will be possible to login directly to OS.
JVM internally maintains the "String Pool". To achive the memory efficiency, JVM will refer the String object from pool. It will not create the new String objects. So, whenever you create a new string literal, JVM will check in the pool whether it already exists or not. If already present in the pool, just give the reference to the same object or create the new object in the pool. There will be many references point to the same String objects, if someone changes the value, it will affect all the references. So, sun decided to make it immutable.

Why String class was declared as final.

Similar Messages

Maybe you are looking for