首页 > 其他 > 详细

Java String Class Example--reference

时间：2014-03-11 03:59:59 阅读：550 评论：0 收藏：0 [点我收藏+]

reference：http://examples.javacodegeeks.com/core-java/lang/string/java-string-class-example/

1. Introduction

In this example we are going to discuss about the basic characteristics of Java String Class. String is probably one of the most used types in Java programs. That’s why Java provides a number of API methods that make String manipulation easy and efficient, straight out of the box. Strings are so important that even in the latest Java releases (including 7 and 8), several changes have been made to its class methods and its internal representation, improving it even further in terms of performance and security.

2. String Class basic methods

A String is simply a sequence of characters. As a matter of fact, a String Object is backed by a char array. Consequently, it is not null terminated, like in C/C++.

Here is how you can create a String

  
    1
    String str= "Hello World";

"Hello World" is called a String literal. In a Java program, everything between two double quotes is a String literal. Literals are implemented as instances of String class. As you can see, you can conveniently initialize a String Object like a primitive type, e.g int i = 0;.

There is no need to do:

  
    1
    String str = new String("Hello World");

There is a difference between these two initialization methods, although the result is the same : A String with value “Hello World”. But more on that in just a bit.

For now, here is a simple main with the most important String API methods:

StringClassExample.java

  
    001
    package com.javacodegeeks.core.lang.string;

    002
     
    003
    public class StringClassExample {

    004
     
    005
        public static void main(String[]args){

    006
            //Initialization with literal

    007
            String str1 = "Hello World";

    008
            System.out.println("str1:"+str1);

    009
     
    010
            //Initialization with char array

    011
            char arr[] = {‘H‘,‘e‘,‘l‘,‘l‘,‘o‘};

    012
            String str2 = new String(arr);

    013
            System.out.println("str2:"+str2);

    014
     
    015
            //Concatenation using + operator

    016
            String str3 = "World";

    017
            str3 = str2 + " " + str3;

    018
            System.out.println("str3:"+str3);

    019
     
    020
            //find out the length of a string

    021
            System.out.println(str3.length());

    022
     
    023
            //You can even apply that to literals, as with all String API methods

    024
            //As we said. literals are implemented as String instances

    025
            System.out.println("Length: "+"abcdefg".length());

    026
     
    027
            //Substring from position 2 to position 10

    028
            String c = str1.substring(2,10);

    029
            System.out.println("Substring :"+c);

    030
     
    031
            //Substring from position 1 to position 4

    032
            System.out.println("Literal Substring :"+"abcdefghigklm".substring(1,4));

    033
     
    034
            // Get the charcter array of the string.

    035
            char[] chars = c.toCharArray();

    036
            System.out.println("Char array : ["+chars[0]+","+chars[1]+","+chars[2]+"]");

    037
     
    038
            //find the first index of a char inside a string

    039
            int i = str1.indexOf(‘W‘);

    040
            System.out.println("Index of ‘W‘:"+i);

    041
     
    042
            //find the first index of a string inside another string after a certain position

    043
            i = str1.indexOf("orld",5);

    044
            System.out.println("Index of ‘orld‘:"+i);

    045
     
    046
            //find the last index of a string inside another string

    047
            i = str1.lastIndexOf("l");

    048
            System.out.println("LAST Index of ‘l‘:"+i);

    049
     
    050
            //find the last index of a string inside another string after a certain position

    051
            // - like scanning the string backwards

    052
            i = str1.lastIndexOf("l",7);

    053
            System.out.println("LAST Index of ‘l‘:"+i);

    054
     
    055
            //find a character in a certain position

    056
            char cr = str1.charAt(5);

    057
            System.out.println("Character at position 5:"+cr);

    058
     
    059
            //Lower case

    060
            System.out.println("ABCEFAFA".toLowerCase());

    061
     
    062
            //Upper case

    063
            System.out.println("abcasipasc".toUpperCase());

    064
     
    065
            //replace occurrences of a character

    066
            str1 = str1.replace(‘o‘,‘0‘);

    067
            System.out.println(str1);

    068
     
    069
            //Trim white spaces from the end and the beginning

    070
            String str4 = "    Java";

    071
            System.out.println(str4);

    072
            System.out.println(str4.trim());

    073
     
    074
            //Split !!!

    075
            String str5= "Java is great";

    076
            String[] strArray = str5.split(" ");

    077
     
    078
            System.out.println(strArray[0]+","+strArray[1]+","+strArray[2]);

    079
     
    080
            str5= "Java-is-great";

    081
            strArray = str5.split("-");

    082
            System.out.println(strArray[0]+","+strArray[1]+","+strArray[2]);

    083
     
    084
            str5= "Java is great";

    085
            strArray = str5.split("/*");

    086
            System.out.println(strArray[0]+","+strArray[1]+","+strArray[2]+","+strArray[3]+","+strArray[4]+

    087
                    ","+strArray[5]+","+strArray[6]+","+strArray[7]+","+strArray[8]);

    088
     
    089
            //contains and equals

    090
            System.out.println("Contains :" + "qwerty".contains("ert"));

    091
            System.out.println ("Equals :"+str5.equals("java is great"));

    092
            System.out.println ("Equals ignore case:"+str5.equalsIgnoreCase("java is great"));

    093
     
    094
            // Compare lexicographically two strings

    095
            System.out.println ("Compare:"+str5.compareTo("abc"));

    096
     
    097
            //comparison attempts

    098
            String s1 = "abc";

    099
            String s3 = new String("abc");

    100
     
    101
            System.out.println(s1==s3);

    102
            System.out.println(s1.equalsIgnoreCase(s3));

    103
     
    104
        }

    105
     
    106
    }

This is the output of the above program:

str1:Hello World
str2:Hello
str3:Hello World
11
Length: 7
Substring :llo Worl
Literal Substring :bcd
Char array : [l,l,o]
Index of ‘W‘:6
Index of ‘orld‘:7
LAST Index of ‘l‘:9
LAST Index of ‘l‘:3
Character at position 5: 
abcefafa
ABCASIPASC
Hell0 W0rld
    Java
Java
Java,is,great
Java,is,great
,J,a,v,a, ,i,s, 
Contains :true
Equals :false
Equals ignore case:true
Compare:-23
false
true

From the above program is clear that Java designers decided to treat Strings somewhat differently from other Objects. For example you can initialize them like a primitive, e.g String a="abc" and you can concatenate two strings using + operator, like you would add twoints (looks like overloading + operator in C++).

The comparison attempts section of the code might seem a little fuzzy, but it will get clear in the next section. What you should take away from it now, is that you SHOULD NEVER try to compare the contents of Strings using == operator. You are only comparing reference equality, not content equality. You MUST use equals or equalsIgnoreCase.

3. Other characteristics of String objects

String objects are immutable. This means that once a String is created, its contents cannot be changed. In the above example, every time we attempt to change its contents, e.g when concatenating, a new String object is created representing the result. Additionally, String class is final, so you cannot override its behavior.

Immutability was mostly chosen for security reasons and for performance. It also means that two different thread can share the same String and manipulate it as they want, not having to synchronize anything, because every time they make a change in the original string, a new one is created, while the old one remains untouched.

Now let’s see this :

  
    1
    String s1 = "abc";
  
    2
    String s2= "abc";
  
    3
     
    4
    String s3 = new String("abc");
  
    5
     
    6
    System.out.println(s1==s2);
  
    7
    System.out.println(s1==s3);

This outputs:

true
false

Literals are stored in a special place in memory, called a String pool, of course in the form of String Objects. In that pool, a Stringobject with value “abc” is only created and stored once. Any other String that gets the value “abc” (statically – hard coded) will reference the same String object. So, every time you create a String using a literal, the system will search that pool and checks if the value of the literal exists in an object of the pool. If it does, it sends back the reference to that matching object, if not it creates a new Object and stores it in the pool. So, String references, initialized with the same literals, will point to the same String object. This technique was used to save precious memory, as it shares as much common data as possible.

Now, you can also see another reason why Strings are immutable. Imagine thread A creating a local string “abc” and then a second thread B creating his own local string “abc”. These two threads will share the same String object… If String was mutable, then if A changed the string, the change would affect thread B, but in a meaningless (put catastrophic) way.

When creating a String using new, you explicitly create a brand new object in the heap. This is also the case for non hard codedString initialization, for example, if you are reading input Strings from a source. These String Objects will not be stored in the pool. Imagine that you create an application that has to hold addresses for users living in Greece. There are four million people living in Athens, so consider the massive waste of space should you store four million String objects with value “Athens”. In order to pool those non hard coded Strings, there is an API method called intern, and can be used like so:

  
    01
    String s1 = "abc";
  
    02
    String s2= "abc";
  
    03
     
    04
    String s3 = new String("abc");
  
    05
     
    06
    System.out.println(s1==s2);
  
    07
    System.out.println(s1==s3);
  
    08
     
    09
    s3 = s3.intern();

    10
    System.out.println(s1==s3);

This will now output:

true
false
true

When calling intern, the system follows the same procedure as if we did s3 = "abc", but without using literals.

But be careful. Before Java 7, this pool was located in a special place in the Java Heap, called PermGen. PermGen is of fixed size, and can only hold a limited amount of string literals. So, interning should be used with ease. From Java 7 onward, the pool will be stored in the normal heap, like any other object (making them eligible for garbage collection), in a form of a hashmap and you can adjust its size using -XX:StringTableSize option. You could create your own String pool for that matter, but don’t bother.

This is only one of the aspects that Java creators changed in the String class. Even more radical changes ware made, including the internal String representation (it now has two less static fields).

Download the Eclipse Project

This was an example of Java String Class. You can download the Eclipse Project of this example here : StringClassExample.zip

Java String Class Example--reference,布布扣,bubuko.com

Java String Class Example--reference

原文：http://www.cnblogs.com/davidwang456/p/3591803.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)