Java String StringBuffer and StringTokenizer

r囧r小猫 2022-09-27 00:29 185阅读 0赞

## String ##

一个character constant 是char 在unicode character set中的整数值。A String 是String类的实例，定义String有两种形式。

String s1 = new String("new String"); //initializes **String**  reference s1 to the new created **String Object**  "new String"

String s2 = "ss";//anonymous java String object

String s3 = "ss";

Java treats all annonymous Strings with same contents as on anonymous String object that has many references to conserves memory.Thus s2==s3 is true and s2.equals(s3) is true

### String Constructors    ###

char charArray\[\] = new \{'b','i','r','t','h','d','a','y'\};

byte byteArray\[\] = new \{(byte)'n',(byte)'e',(byte)'w',(byte)'y',(byte)'e',(byte)'a',(byte)'r',\};

String s,s1,s2,s3.s4.s5.s6.s7;

StringBuffer buffer;

s = new String("Hello");

buffer = new StringBuffer("Hello StringBuffer");

s1 = new String();

s2 = new String(s);

//*String inistantiates a new **String**  object and assigns it to reference **s2,** using class **String** 's copy constructor. the new **String**  object contains a copy of the characters in the **String**  object b that is passed as a argument to the constructor.*

s3 = new String(charArray); // output is birthday

s4 = new String(byteArray); //output is newyear

s3 = new String(charArray,5,3);// output is day

s4 = new String(byteArray,3,4);//output is year

s4 = new String(buffer); // output is Hello StringBuffer

**String**  objects are immutable, their character contents cannot be changed after they are created, any changes to **String**  contents creates a new **String**  Object. The **StringBuffer** is a dynamically resizable and modifiable string.

###     ###

### String 的方法    ###

因为String是类，所以它有length方法，而不是属性。

String s1 = "123456";

Char\[\] charArray = new Char\[5\]

s1.charAt('3');

s1.getChars(0,5,charArray,0); *//把s1中的character从0(start index)，到5(end index)拷贝到charArray的第0(start index of destination array)位*

Method **equals** 是**String** 从**Object类中继承来的，** 来测试两个objects的内容是不是相等。比较**String** 时，其实是比较两个String的每一个字符的unicode整数值是不是相等。 == 比较的是两个reference是不是指向同一Object。当==用在primitive data type时，如果比较的值相等则是true, 但如果比较references, 如果都指向同一object in memory 则为真。

**s1.compareTo(s2):**  two Strings are compared character by character. 如果想等会返回0，如果s1的一个字符比s2大的话，返回s1的字符的unicode int - s2字符的unicode int =大于0，如果小的话就是负数小于零。

**s1.regionMatches(0,s2,0,5)  //** *case sensitive,第一个是s1的starting index,第二个是比较的String object,第三个是s2的start index, 第四个是比较的字符的长度。*

**s1.regionMatches(true, 0,s2,0,5)//ignore case**

**regionMatches**  comare portions of two String objects for equlity.

**s1.startsWith('st') s1.startsWith('st',2) s1.endsWith('st') s1.endsWith('st',25)**

返回值是boolean型，第一个参数是要比较的字符串，第二个字符是index, endsWith从后向前搜查。

**s1.indexOf("hello") s1.indexOf('h')**

if indexOf find the character, it returns the index of that character in the String, otherwise, it returns -1.

**s1.indexOf('h'.34) //** *t* he second argument indicates the starting index to search in String s1.

**s1.lastIndexOf('$') s1.lastIndexOf("hello")**

从后向前查询

**s1.lastIndexOf('h',24)**

the second argument indicates the highest index from which to begin searching backward for the character

**s1.concat(s2) //** *s2 is appended at the end of String s1*

**concat** 方法连接两个String object 并返回一个新的String Object. s1 和s2指向的String object维持不变。不过使用StringBuffer更有效率。

char charArray\[\] = s1.toCharArray();

s1.replace('l','L');

String.valueOf(a)把参数a返回成String值。a的类型可以是boolean, char, int, long, float, double and Object.  其中 Object可以是因为它的toString方法。

String s1 = new String("hello");

Strings2 = new String("hello");

**s3 = s1.intern();**

**s4 = s2.intern();**

**s3 ==s4 is true**

**s3==s1 is false**

**s2==s4is false**

**s1==s4 is false**

因为比较大的**String objects** 会比较慢，使用**intern** 方法可以提高比较速度。s1调用intern方法时，它返回一个指向**String object** 的reference并且这个**String Object** 拥有与s1完全相同的contents. **Class String** 会把这个返回的**String Object保存在memory中** during program execution. 如果the program invokes method **intern**  on other **String**  objectswith contents identical to the original **String** s1, method **intern** returns a reference to the copy of the **String**  maintained in memory by class **String** . 这样程序可以用**intern** 方法在很大的String上，程序用==作比较会更快，因为==只是比较references. 用equals会一个字符一个字符的比对String objects内容。

## StringBuffer    ##

有三个**constructor** 方法，

StringBuffer sb1 = new StringBuffer();   //default size 16

StringBuffer sb1 = new StringBuffer(10); // size 10

StringBuffer sb1 = new StringBuffer("hello"); // defause size is number of characters in the String argumnet + 16

**length()**  method returns the number of characters in the **StringBuffer**

**capacity()**  method returns the number of characters can be strored in the **StringBuffer**  without allocating more memory.

**setLength(int i)**  set the length of String currently stored in the **StringBuffer** , if the current **String** length is larger than **i,**  then reduced the original String length to the new length.

**setCapacity(int y)**  set the capacity of the **StringBuffer，** if the current capacity is more than the specified capacity, the **StringBuffer** 's capacity remain unchanged.

**charAt(int k)**  takes an integer argument and returns the character inthe **StringBuffer** at that index.

**setCharAt(int i, char c)**  set the character **c**  at the index **i.**  the argument **i** must be large or equal to 0 and less than the **length.**

**buffer.getChars(int i, int j,char\[\] charArray, int k)** . **i** is the starting index from which characters should be copied in the **StringBuffer,**  the index **j** past the last character to the copied from the **StringBuffer** , **charArray** is the char array which characters are to be copied, **k**  is the first character should be places in the char array.

**buffer.reverse()**   returns String which is the reverse of the original **String**  buffer.

**buffer.insert(0, i)** method allows data values to be inserted at any position in a **StringBuffer.**  the type of i can be **Object, String, char, boolean, char, int, long, float, double.**

**buffer.deletaCharAt(int i)** delete character at a specified position

**buffer.delete(int i, int j)**  delete from index **i** to index **j** .

**Character**  type wrapper class. have the following methods

Char c

**Character.isDefined(c)**  //if **c** is defined in the Unicode character set; return true/false

**Character.isDigit(c)      //** if **c** is a digit in Unicode Character set; return true/false

**Character.isJavaIdentifierStart(c) //** if **c** is the character that can be used as the first character of an identifier

**Character.isJavaIdentifierPart(c)  //** if **c** is a character that can be used in Identifier in Java

**Character.isLetter(c)                      //** if **c** is a letter

**Character.isLetterOrDigit(c)**

**Character.isLowerCase(c)**

**Character..isUpperCase(c)**

**Character.toUpperCase(c)**

**Character.toLowerCase(c)**

**Character c = new Character('c')**

**c.charValue()**  returns the char value stored in **Character** c

**digit(Char c, int radix)** and **forDigit(int digit, int radix)**  perform conversions between characters and digits in different number systems. common number systems include decimal (base10), octal (base 8), hexadecimal (base 16) and binary (base 2). the **radix **  should be 2,8,10 or 16.

## Class StringTokenizer ##

**StringTokenizer class **  from package java.util. it breaks a string into its component tokens. its delimiters are white space characters such as blank, tab, newline, and carriage return " **/n/t/r** ".

**StringTokenizer tokens = new StringTokenizer("This is Beijing");**

**tokens.countTokens();//** 返回token的数目

while(**tokens.hasMoreTokens()**  )

\{

System.out.println(tokens.nextToken());

\}

**StringTokenizer tokens = new StringTokenizer("This is Beijing",",");//** 第二个参数设置新的delimiter

**StringTokenizer tokens = new StringTokenizer("This is Beijing",",",true);//** 第二个参数设置新的delimiter,第三个delimiter指示是否把delimiter也当做token。

**tokens.nextToken(newDelimiterString) //change** the delimiter String while tokenizing a string.

发表评论取消回复

表情：

评论列表（有 0 条评论，185人围观）

还没有评论，来说两句吧...

相关阅读

相关 java stringbuffer原理_java String、StringBuffer、StringBuilder 的区别

StringBuffer、StringBuilder和String一样，也用来代表字符串。String类是不可变类，任何对String的改变都会引发新的String对象的生成；

雨点打透心脏的1/2处/ 2022年11月06日 09:57/ 0 赞/ 187 阅读

相关【java学习】常用实体类--String、StringBuffer\StringTokenizer

文章目录参数传递 String String类有两个常用构造方法：引用String常量 String类的常用方法

末蓝、/ 2022年10月06日 09:55/ 0 赞/ 185 阅读

相关 Java String StringBuffer and StringTokenizer

String 一个character constant 是char 在unicode character set中的整数值。A String 是String类的实例，定义

r囧r小猫/ 2022年09月27日 00:29/ 0 赞/ 186 阅读

相关 java String、StringBuffer、StringBuilder

String类： 1、String表示一个字符串，是final类型的类，不能被继承； 2、两种赋值方式： 1、直接赋值，String s = “aa”; 2、通

太过爱你忘了你带给我的痛/ 2022年08月21日 13:51/ 0 赞/ 168 阅读

相关 JAVA StringBuffer类与StringTokenizer类

StringBuffer类提供了一个字符串的可变序列，类似于String类，但它对存储的字符序列可以任意修改，使用起来比String类灵活得多。它常用的构造函数为： Stri

ゝ一纸荒年。/ 2022年08月02日 12:46/ 0 赞/ 177 阅读

相关 java StringTokenizer

StringTokenizer：官方API解释如下：stringtokenizer 类允许应用程序将字符串分解为标记。 StringTokenizer 是出于兼容性的原因而被

￡神魔★判官ぃ/ 2022年06月13日 00:13/ 0 赞/ 272 阅读

相关 Java - Differences between String, StringBuffer and StringBuilder

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击[http://www.captainbed.net][http_www.cap

喜欢ヅ旅行/ 2022年05月29日 12:19/ 0 赞/ 137 阅读

相关杂谈——String、StringBuffer、StringBuilder和StringTokenizer有什么区别

字符串是Java中很特殊的一个东西，本帅博主自学习Java以来被这小兔崽子拽入多次坑。而Java语言中有四个类可以对字符或者字符串进行操作，它们分别是Character、S

ゞ浴缸里的玫瑰/ 2022年04月11日 11:25/ 0 赞/ 315 阅读

相关 StringBuffer,Character和StringTokenizer的使用

StringBuffer StringBuffer类自我感觉只是string类的多个方法进行了加强，可以对多个字符串进行处理，也可以改变自身字符串的序列，比如说可以倒序等

柔光的暖阳◎/ 2022年01月29日 18:34/ 0 赞/ 181 阅读

相关 string stringbuffer

1.string是final修饰的，创建后不可变，每次修改都会创建新的变量；多线程下不安全 2.stringbuffer是线程安全的，append方法由sync修饰 3.s

川长思鸟来/ 2021年09月18日 13:20/ 0 赞/ 352 阅读