String class

hai friends......
When we are creating the array we are using new operator for creating memmory space.But in main method we are not using any new operator for creating array(public static void main(String arg[])).why?and how is the array is creating here?plz expalin
thnk you

sonu_sr wrote:
hai friends......
When we are creating the array we are using new operator for creating memmory space.But in main method we are not using any new operator for creating array(public static void main(String arg[])).why?and how is the array is creating here?plz expalin
thnk youYou aren't creating an array there. You only declare a method that takes a string array as argument. The VM is creating the array.
Kaj

Similar Messages

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 find out what are the functions supported by string class

Hi,
Can any one let me know how to find what are all the functions supported by the string class in standard(STL) library on solaris.
Regards,
Vignesh

1. Any C++ textbook that covers the Standard Library will tell you about the standard string class. A good tutorial and reference for the entire Standard Library is "The C++ Standard Library" by Nicolai Josuttis, published by Addison Wesley.
2. WIth Sun C++, the command
man -s3C++ basic_string
provides documentation for the default libCstd version of the Standard Library.
3. You could look at the <string> header itself. I don't recommend that approach.

Memory leak in string class

We have developed our application in Solaris 10 environment. While running Purify on that it shows leak in the string class. This leak is incremental and so process size keeps in increasing. If we replace string with char array, the leaks disappears and process size also becomes stable.
Following is the snapshot of the memory leak stack reported by Purify:
MLK: 4505 bytes leaked in 85 blocks
* This memory was allocated from:
malloc [rtlib.o]
operator new(unsigned) [libCrun.so.1]
void*operator new(unsigned) [rtlib.o]
__rwstd::__string_ref<char,std::char_traits<char>,std::allocator<char> >*std::basic_string<char,std::char_traits<char>,std::allocator<char> >::__getRep(unsigned,unsigned) [libCstd.so.1]
char*std::basic_string<char,std::char_traits<char>,std::allocator<char> >::replace(unsigned,unsigned,const char*,unsigned,unsigned,unsigned) [libCstd.so.1]
std::basic_string<char,std::char_traits<char>,std::allocator<char> >&std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=(const char*) [libCstd.so.1]
Has anyone faced this problem earlier or is there any patch available for this?

Over time, we have found and fixed memory leaks in the C++ runtime libraries.
Get the latest patches for the compiler you are using. (You didn't say which one.) You can find all patches here:
[http://developers.sun.com/sunstudio/downloads/patches/index.jsp]
Also get the latest Solaris patch for the C++ runtime libraries, listed on the same web page.
If that doesn't fix the problem, please file a bug report at
[http://bugs.sun.com]
with a test case that can be compiled and run to demonstrate the problem.

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.

I think this is a Bug of String class

I think this is a Bug of String class, do you agree with me ?
String s = "1234........"; // when "1234........". length() > 65535, there will be wrong, but
char[] c = new char[88888];...
String s = new String(c);even if c.length >65535�Cevery thing is ok.
so I think is a bug. Somebody give me a answer, thanks

below is the two Constructors Of String
    public String(String original) {
     int size = original.count;
     char[] originalValue = original.value;
     char[] v;
     if (originalValue.length > size) {
         // The array representing the String is bigger than the new
         // String itself. Perhaps this constructor is being called
         // in order to trim the baggage, so make a copy of the array.
         v = new char[size];
         System.arraycopy(originalValue, original.offset, v, 0, size);
     } else {
         // The array representing the String is the same
         // size as the String, so no point in making a copy.
         v = originalValue;
     this.offset = 0;
     this.count = size;
     this.value = v;
    }=====================
    public String(char value[]) {
     int size = value.length;
     char[] v = new char[size];
     System.arraycopy(value, 0, v, 0, size);
     this.offset = 0;
     this.count = size;
     this.value = v;
    }I don't know where has the problem.

How to implement the String class "split()" method (JDK1.4) in JDK 1.3

is it possible , with some code, to implement the split() method of the String class......which is added in JDK1.4 ..... in JDK1.3
would be helpful if anyone could suggest some code for this...

Here it is
public static String[] split(String source, char separ){
answer=new Vector();
int position=-1, newPosition;
while ((newPosition=source.indexOf(separ,position+1))>=0){
answer.add(source.subString(position+1,newPosition));
position=newPosition;
} //while
answer.add(source.subString(position+1,source.length-1);
return (String[])(answer.toArray());
} //split

How to specify ");" as a regular expression in split method of String class

How to specify ");" as a regular expression in split method of String class using delimeters?

Sorry, you can't specify that by using delimiters. Mostly because this requirement makes no sense.
Do you rather need "\\);"?

Any size Constraints On a variable of String Class

Hi All
I would like to know whether there are any constraints on the size of data that a variable of Class String can store.
For example i need to store data of length around 70,000 (can be more too) in a String variable.
Can i use a variable of String Class for this purpose or is there another Class which can do the work with minimum rework
Thanking in anticipation of all the replies

hi,
not sure about the internal array size( integer?)...
but as charactor occupies 2 bytes, ability to create
lengthier string is restricted only by out of memory
error...
in which case, the allowable size will be different
in different memory configurationsActually, kajbj and you are both correct. There are 2 limitations: 1 is physical memory, the other is the index of the char[] may not exceed Integer.MAX_VALUE (standard is 2,147,483,647). Depending on your physical memory, it is possible (and likely in many large systems) to run out of integers before running out of memory.

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.

Is the instance fields have private accessibility in String class?

Is the instance fields have private accessibility in an immutable class, such as the String class?
also Could any one answer the following question,
(This is the question I got in written exam for job recruitment)
"Invoking a method can represent a significant amount of overhead in a program; as such, some compilers will perform an optimization called "method inlining." This optimization will remove a method call by copying the code inside the method into the calling method."
Referring to the text above, which one of these statements is true?
Choice 1 The performance benefits should be balanced against the increased chance of a RuntimeException.
Choice 2 It allows the use of getter and setter methods to execute nearly as fast as direct access to member variables.
Choice 3 This optimization will only occur if the relevant methods are declared volatile.
Choice 4 The developer of inlined methods must copy and paste the code that is to be inlined into another method.
Choice 5 It prevents code from executing in a way that follows object-oriented encapsulation.

Sarwan_Gres wrote:
Is the instance fields have private accessibility in an immutable class, such as the String class?Usually, but not always.
"Invoking a method can represent a significant amount of overhead in a program; as such, some compilers will perform an optimization called "method inlining." This optimization will remove a method call by copying the code inside the method into the calling method."The java compiler does not inline methods so this is not relevant to Java. (The JVM does inline methods) The java compiler does inline constants known at compile time but it is a feature causes more trouble than good IMHO.

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?

(Class ? extends Set String ) Class.forName("example.SetImpl").asSubclass

Is there a way to do the following without an Unchecked cast?
Class<? extends Set<String>> clazz;
clazz = (Class<? extends Set<String>>) Class.forName("example.SetImpl").asSubclass(Set.class);
Set<String> mySet = clazz.newInstance();
cheers,
reto

No. The last line will always generate that warning making the second line pointless. There is no way to create a new instance of a generic class because there is (for most intents and purposes) no such thing as a generic class at runtime.

Question about the String class

Did I understood the JLS/Javadoc properly if I say that the String class has got an internal pool of String objects (therefore I expect this pool to be stored in some sort of static variable)?
Looking at the intern() method in the String class, this is declared as native, which make me think the whole pooling thing is managed internally by the JVM.
Does this mean that, if there is only a String class per JVM and String literals (or better Strings that are values of constant expressions) are pooled in the String class, the more String constants are around the bigger the String class object becomes?

Did I understood the JLS/Javadoc properly if I say
that the String class has got an internal pool of
String objects (therefore I expect this pool to be
stored in some sort of static variable)?Yes.
Looking at the intern() method in the String class,
this is declared as native, which make me think the
whole pooling thing is managed internally by the JVM.The intern() method is implemented in some programming language. If you happen to have a Java runtime where it is written as a native method, it is probably implemented in C or C++. Not a terribly important detail.
Does this mean that, if there is only a String class
per JVM and String literals (or better Strings that
are values of constant expressions) are pooled in the
String class, the more String constants are around
the bigger the String class object becomes?The String.class object (of type java.lang.Class) as such doesn't "grow", but some memory structure somewhere will contain interned String literals. Probably a hash table of some sort. Yes indeed: if you have String literals in your program, those literals are stored in the computer's memory during runtime so that they can be accessed by the executable program code.

The TableModel.getColumnClass() always return String class

Hi, anybody here has ever encountered and problem like mine? Please help if you do.
I have an JTable and the table model derived from AbstractTableModel, I use TableSorter from the tutorial to sort the table(I have also implemented my own sorting method, but the result is the same), but whatever the data type of the table column, the getColumnClass() method always return String type, so the table is always sorted by String type.
My implementation of this method is as following:
return getValueAt(0, columnIndex).getClass();
What is possibly wrong?
Please help, thank you so much!
Janet

Presumably the data in your first cell is a String object... therefore your code in getColumnClass() will always return String.class.

[svn:osmf:] 11239: Updated DRM MediaError codes to work with the the Framework strings class.

Revision: 11239
Author:   [email protected]
Date:     2009-10-28 13:03:06 -0700 (Wed, 28 Oct 2009)
Log Message:
Updated DRM MediaError codes to work with the the Framework strings class. DRM errors spit directly from the VideoElement.
Modified Paths:
    osmf/trunk/framework/MediaFramework/org/osmf/events/MediaErrorCodes.as
    osmf/trunk/framework/MediaFramework/org/osmf/utils/MediaFrameworkStrings.as
    osmf/trunk/framework/MediaFramework/org/osmf/video/VideoElement.as

check the server log;
/app/oracle/product/fwm11g/user_projects/domains/fwm_domain/servers/AdminServer/logs/AdminServer.log
you can launch the console and see if it is running; http://<server>:<port>/console

String class

Similar Messages

Maybe you are looking for