java集合、常用类和String

第五部分Java中的集合

集合可以放置不同类型的数据，长度也是可以改变的，集合类都在java.util包中，包括：set、List、Map、等等。

Collection 接口是集合类的根接口，主要方法介绍：

Boolean add(E o) 指定元素追加到列表最后

Boolean addAll(Collection c) 将c中的所有元素追加

Void clear（）

Boolean contains（object e）判断是否含有指定元素

Boolean containAll(Collection c) 判断是否包含全部

int hashCode（）返回次集合的哈希码值

Boolean isEmpty（）

Inerator iterator

void remove(int index ) ; 删除指定位置上的元素

Boolean removeAll(Collection c) 删除与集合c中相同的元素

int size()

toArray() 和数组形式的转换

1.集合set

Set实现了Collection 中的所有方法，不能有重复元素，主要的类HashSet 和TreeSet

（1）HashSet 对元素随机排序的集合类，无序不重复集合，如果元素个数超过了集合容量，会自动增加一倍；

例子说名问题：

import java.util.HashSet;

public class HashSetTest {

public static void main(String args[]){

HashSet hashSet = new HashSet();

hashSet.add("red");

hashSet.add("yellow");

hashSet.add("blue");

hashSet.add("white");

hashSet.add("black");

hashSet.add(8);

System.out.println("hashSet's info : " + hashSet);

hashSet.remove("red");

System.out.println("hashSet : " + hashSet.toString());

System.out.println("the size of hashSet is : " + hashSet.size());

Object []Value = hashSet.toArray();

for(int i=0;i

System.out.print(Value[i]+" ");

}

System.out.println();

System.out.println(hashSet.contains(2));

hashSet.clear();

System.out.println("the hashSet's size : " + hashSet.size());

}

}

运行结果：

hashSet's info : [red, white, 8, blue, yellow, black]

hashSet : [white, 8, blue, yellow, black]

the size of hashSet is : 5

white 8 blue yellow black

false

the hashSet's size : 0

（2）TreeSet类对元素排序的有序集合

集合中元素是自然排序，不能有重复元素

例子说明：

import java.util.TreeSet;

import java.util.SortedSet;

public class TreeSetTest {

public static void main(String args[]){

SortedSet treeSet = new TreeSet();

treeSet.add("10");

treeSet.add("red");

treeSet.add("yellow");

treeSet.add("blue");

treeSet.add("white");

System.out.println("first_treeSet = " + treeSet.first());

System.out.println("last_treeSet = " + https://www.360docs.net/doc/3d7939806.html,st());

//

System.out.println("subSet_treeSet = " + treeSet);

System.out.println("treeSet'length ：" + treeSet.size());

System.out.println("treeSet is Contain red :"+ treeSet.contains("red"));

treeSet.clear();

System.out.println(treeSet.isEmpty());

}

}

运行结果：

first_treeSet = 10

last_treeSet = yellow

subSet_treeSet = [10, blue, red, white, yellow]

treeSet'length ：5

treeSet is Contain red : true

true

其他的构造方法：

public TreeSet(Collection c) // 含指定集合c中元素的set

public TreeSet(Comparation c) // 构造根据制定比较器进行排序的空set

public TreeSet(SortedSet s) // 构造复制品

2 列表List

顺序存放，可以有重复元素，主要有ArrayList , VectorList , Stack

(1)ArrayList 实现数组的动态操作，

例子：

import java.util.ArrayList;

import java.util.List;

public class ArrayListTest {

public static void main(String args[]){

List arrayList = new ArrayList();

arrayList.add("red");

arrayList.add("yellow");

arrayList.add(1,"blue");

arrayList.add(2);

System.out.println("arrayList = " + arrayList);

//删除元素

arrayList.remove(3);

System.out.println("arrayList = " + arrayList);

//以数组为单位构建数组

arrayList.add("black");

arrayList.add("red");

List arrayList2 = new ArrayList();

arrayList2.add(arrayList);

arrayList2.add(arrayList);

System.out.println("arrayList2_size " + arrayList2.size());

for(int i=0;i

System.out.print(arrayList2.get(i) + " ");

}

//转化为数组

System.out.println();

String []values = new String[arrayList.size()];

arrayList.toArray(values);

for(int i= 0;i

System.out.print(values[i] + " ");

}

/*

但是这里转化为数组的Arraylist不能是Array对象

在这里就是说arrayList2不能转化为数组

*/

//调整arrayList的长度,节省空间

System.out.println(arrayList.size());

((ArrayList) arrayList).trimToSize();

System.out.println(arrayList.size());

}

}

运行结果：

arrayList = [red, blue, yellow, 2]

arrayList = [red, blue, yellow]

arrayList2_size 2

[red, blue, yellow, black, red] [red, blue, yellow, black, red] red blue yellow black red 5

5

其他方法：

public void add(int index , E element) // 插入到指定位置

pubic void addAll(Collection< extend E> c) // 将所有元素追加到尾部

(2)Vector类

构造方法：

Public Vector()

Public Vector(Collection e )

Public Vector(int initialCapatity)

Public Vector(int initialCapatity , int capatityCream)

如果不定义增量的话，自动增长会增加一倍

用法和ArrayList一样

(3)Satck 栈

import java.util.*;

public class StackTest {

public static void main(String args[]){

Stack stack = new Stack();

stack.push("red");

stack.push("black");

stack.push("white");

stack.push("yellow");

System.out.println("stack : " + stack);

stack.pop();

System.out.println("stack : " + stack);

if(!stack.empty()){

System.out.println(stack.peek());

}

//在栈中的位置

System.out.println(stack.search("red"));

}

}

运行结果：

stack : [red, black, white, yellow]

stack : [red, black, white]

white

3

3. 映射Map

Map接口没有继承Collection接口，通过键的值指定位置存放，键值（key）不能重复，主要介绍HashMap 和HashTable

（1）HashMap

import java.util.Map;

import java.util.HashMap;

public class HashMapTest {

public static void main(String args[]){

Map hashMap = new HashMap();

hashMap.put(1,"red");

hashMap.put(2,"white");

hashMap.put(3, "black");

hashMap.put(2, "grap");

//打印

System.out.println(hashMap);

System.out.println(hashMap.get(0));

//删除

hashMap.remove(1);

System.out.println(hashMap);

//判断键值是否存在

if(hashMap.containsKey(1)){

System.out.println(hashMap.get(1));

}

//判断是否含有指定内容

System.out.println(hashMap.containsValue("white"));

}

}

运行结果：

{2=grap, 1=red, 3=black}

null

{2=grap, 3=black}

false

解析：写入相同的键值，后写入的会替代前面的；

其他的方法：containsKey() ,containsValue();

（2）HashTable

构造方法：

Public Hashtable()

Public Hashtable(int initialCapacity)

Public Hashtable(int initialCapacity , int loadFactor)

HashTable(Map m)

例子：

import java.util.Hashtable;

import java.util.Map;

public class HashTableTest {

public static void main(String args[]){

Map hashTable = new Hashtable();

hashTable.put(1,"red");

hashTable.put(2,"white");

System.out.println(hashTable);

hashTable.get(1);

//

hashTable.remove(2);

System.out.println(hashTable);

//

System.out.println(hashTable.containsKey(2));

System.out.println(hashTable.containsValue("red"));

hashTable.clear();

System.out.println(hashTable.size());

}

}

运行结果：

{2=white, 1=red}

{1=red}

false

true

4. 迭代器iterator

三个方法：

Boolean hashNext() //

E next() //

V oid remove() //

例子：

import java.util.Iterator;

import java.util.List;

import java.util.ArrayList;

public class ListIteratorTest {

public static void main(String args[]){

List arrayList = new ArrayList();

arrayList.add("red");

arrayList.add("white");

arrayList.add("gray");

arrayList.add(1,"blue");

System.out.println(arrayList);

//

Iterator it = arrayList.iterator();

while(it.hasNext()){

String listKey = it.next().toString();

System.out.println(listKey);

}

}

}

运行结果：

[red, blue, white, gray]

red

blue

white

gray

例子2：

import java.util.HashMap;

import java.util.Map;

import java.util.Iterator;

public class MapIteratorTest {

public static void main(String args[]){

Map hashMap = new HashMap();

hashMap.put(1, "arg1");

hashMap.put(2, "arg2");

hashMap.put(3,"arg3");

hashMap.put(4, "arg4");

Iterator it = hashMap.keySet().iterator();

while(it.hasNext()){

int key = Integer.parseInt(it.next().toString());

System.out.println(hashMap.get(key));

}

}

}

运行结果：

arg2

arg4

arg1

arg3

Collections类

它不是一个集合，提供了大量的与集合操作有关的方法，包括：列表排序，确定类表中最小元素，支持集合线程同步；

例子：

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class ListSortAndReverse {

public static void main(String args[]){

List arrayList = new ArrayList();

arrayList.add("white");

arrayList.add("red");

arrayList.add("yellow");

arrayList.add(1,"blue");

System.out.println("排序前的列表：" + arrayList);

Collections.sort(arrayList);

System.out.println("排序后列表：" + arrayList);

Collections.reverse(arrayList);

System.out.println("反转排序后的列表：" + arrayList);

}

}

运行结果：

排序前的列表： [white, blue, red, yellow]

排序后列表： [blue, red, white, yellow]

反转排序后的列表： [yellow, white, red, blue]

解析：

如果元素之间不能进行比较就会抛出ClassCastException异常

综合例子1：

顺序输出hashMap映射中的键值

import java.util.*;

public class mapKeyToListTest {

public static List mapKeyToList(Map map,Comparator desc){ Set keySet = map.keySet();

List list = new ArrayList();

list.addAll(keySet);

Collections.sort(list,desc);

return list;

}

public static void main(String args[]){

new HashMap();

hashMap.put("r","red");

hashMap.put("b","blue");

hashMap.put("y","yellow");

hashMap.put("o","orange");

hashMap.put("w","white");

Iterator it = hashMap.keySet().iterator();

while(it.hasNext()){

String key = it.next().toString();

System.out.print(hashMap.get(key) + " ");

}

System.out.println();

List list = mapKeyToList(hashMap,null);

System.out.println(list);

}

}

运行结果：

orange white red yellow blue

[b, o, r, w, y]

综合例子2：

顺序输出hashMap中键对应的值

import java.util.ArrayList;

import java.util.Collections;

import https://www.360docs.net/doc/3d7939806.html,parator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class MapValueToListTest {

public static List mapValueToList(Map map,Comparator desc){ List listValue = new ArrayList();

Iterator it = map.keySet().iterator();

while(it.hasNext()){

}

Collections.sort(listValue,desc);

return listValue;

}

public static void main(String args[]){

Map hashMap = new HashMap();

hashMap.put("r","red");

hashMap.put("b","blue");

hashMap.put("y","yellow");

hashMap.put("o","orange");

hashMap.put("w","white");

Iterator it = hashMap.keySet().iterator();

while(it.hasNext()){

String key = it.next().toString();

System.out.print(hashMap.get(key) + " ");

}

System.out.println();

List list = mapValueToList(hashMap,null);

}

}

运行结果：

orange white red yellow blue

[blue, orange, red, white, yellow]

第六部分Java常用类

所有类的父类Object类，它提供了9中方法：finalize() , clone() , notify(),notifyAll() , wait() , equals() , getClass() , hashCode(), toString().

还包括Math类，Random类，Date类，DateFormat类，以及Calendar类，下面学习；

一．9种方法

1.finalize()方法

使用方法：

protected void finalize() {

//程序代码

}

用来处理垃圾回收的，具体内容详细学习

2、clone() 克隆技术

Car c1 = new Car();

Car c2 = c1;

这是对象的赋值，c1,c2指向同一块堆内存，修改一个就修改了两个

Car c2 = c1.clone();

克隆技术就是解决这个问题，使c1，c2 指向不同的堆内存，但是相同的内容

3.notify(),

4.notifyAll()

5. wait()

6.equals()

判断两个对象在引用上是否相同，包括地址和内容，其他类可以重写这个方法，String重写了这个方法，只判断内容是否相同，而StringBuffer没有重写，还要地址相同才可以

7. getClass()

返回对象的运行时类，该方法不可以重写的；

可以判断两个对象是否属于同一个类，也可以通过“对象名.getClass().getName()”获得类名；

例子：

class Car{}

class SportCar extends Car{}

public class GetClassTest {

public static void main(String args[]){

Car c= new Car();

SportCar sc = new SportCar();

System.out.println("c 所属的类： " + c.getClass());

System.out.println("sc 所属的类： " + sc.getClass().getName());

}

//重写equals()

public boolean equals(Object o){

if(getClass() == o.getClass()){

return true;

}else {

return false;

}

}

}

运行结果：

c 所属的类： class Car

sc 所属的类： SportCar

false

8.hashCode()

该函数返回对象的哈希码值，该值是通过将对象的内存地址转换为一个整数来实现的，这样obj1.equals(obj2)为TRUE的话，那么他们的哈希码值应该是相同的；当然除了重写函数的

例子：

public class HashCodeTest {

public static void main(String args[]){

String s1 = new String ("hello");

String s2 = new String ("java");

String s3 = "java";

System.out.println("s1.hashCode = " + s1.hashCode());

System.out.println("s2.hashCode = " + s2.hashCode());

System.out.println("s3.hashCode = " + s3.hashCode());

System.out.println(s2.equals(s3));

}

}

运行结果：

s1.hashCode = 99162322

s2.hashCode = 3254818

s3.hashCode = 3254818

true

9.toString()

该方法返回对象的字符串表示，该字符串为：类名@对象哈希码的十六进制

例子：

class Test{}

public class toSTringTest {

public static void main(String args[]){

Test c = new Test();

System.out.println(c.toString());

}

}

运行结果：

Test@998b08

该方法应该重写，这样没有实际的意义

二．基本数据类型对象的封装类

Java中的基本数据类型不属于Object类，他们之间是不相容的，但是java中提供了一组封装类，将基本数据类型转化为对象，就是所谓的装箱；还可以拆箱；

import java.util.ArrayList;

public class A {

public static void main(String args[]){

ArrayList list = new ArrayList();

list.add(1);

list.add(2);

list.add(3);

list.add(4);

System.out.println(list.get(0) + " " + list.get(1));

}

}

运行结果：

1 2

分析：

Add()方法接收的是Integer对象，，get()方法得到的是int数据，这里是自动拆箱；

基本数据类型的和对象类型的转化方法；

Public Integer（int Value）；装箱

Public int intValue();拆箱

其他的类同：public Character（char value）,public char charValue();

三．与数学计算相关的类 Math类

常量字段: E –自然对数底数 PI

abs() --绝对值，double float int long

三角函数和反三角函数 cos,sin,tag,asin,acos,atan, -- 全为double类型

public static double pow(double a, double b) – a 的b 次方

public static double exp(double ) e 的a 次方

public static double sqrt(double a ) -- 平方根

public static double cbrt(double a ) –立方根

log()

log10()

max(type a ,type b);

min(type a, type b);

随机数 public static double random() 返回0.0 到1.0 之间的数

数值的舍入：

public class DataCalculate {

public static void main(String args[]){

double d = 4.4;

System.out.println(Math.rint(d)); //最接近参数的整数

System.out.println(Math.round(d)); // 四舍五入的long型

System.out.println(Math.floor(d)); // 不大于参数的整数

System.out.println(Math.ceil(d)); //不小于参数的整数

}

}

运行结果：

4.0

4

4.0

5.0

四．产生随机数的random类

import java.util.Random;

public class RadomTest {

public static void main(String args[]){

Random rand1 = new Random();//随机数生成器

int k1 = rand1.nextInt(20); //0~20

System.out.println(k1);

Random rand2 = new Random(10); //使用10 为种子创建随机数

int k2 = rand2.nextInt(20); //0~20

System.out.println(k2);

}

}

运行结果：

12 4

13 13

K1是随机的，k2 在第二次运行时和第一次是一样的参数10 的作用：

五．日期时间类 Date

可以表示到精确到毫秒的瞬间

构造方法：

Public Date() 创建一个Date对象并获取当前时间

Public Date(long date) 表示从1970.1.1.00：00：00开始计算的相对时间，精确到毫秒；比较日期的方法：

Boolean after（Date when ）

Boolean before（Date when）

Boolean equals（Object obj）

日期格式化的DateFormat类

例子：

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateFormatTest {

public static final String YYYMMDDHHMMSS = "YYYY/MM/dd HH:mm:ss";

public static void main(String args[]){

Date nowDate = new Date(); //

System.out.println(nowDate);

//格式化时间

SimpleDateFormat sf1 = new SimpleDateFormat(YYYMMDDHHMMSS);

System.out.println(sf1);

Date date = new Date(6000);

System.out.println(date);

}

}

没有调试通过

操作日历的Calendar类：import java.util.Calendar;

import java.util.GregorianCalendar;

import java.text.*;

public class CalendarTest {

public static final String YYYMMDD = "yyyy年MM月dd日";

public static void main(String args[]){

Calendar calendar = new GregorianCalendar();

int nowYear = calendar.get(Calendar.YEAR);

int nowMonth = calendar.get(Calendar.MONTH);

int nowDay = calendar.get(Calendar.DAY_OF_MONTH);

calendar.set(nowYear,nowMonth,nowDay);

SimpleDateFormat sf = new SimpleDateFormat(YYYMMDD);

System.out.println("当前时间为： " + sf.format(calendar.getTime()));

long nowTime = calendar.getTimeInMillis();

calendar.set(2008,7,8);

System.out.println("北京奥运会时间为： " + sf.format(calendar.getTime()));

long OPTime = calendar.getTimeInMillis();

long time = (nowTime - OPTime)/(1000*60*60*24);

System.out.println("北京奥运会就现在已经： "+ time);

}

}

运行结果：

当前时间为： 2010年02月12日

北京奥运会时间为： 2008年08月08日

北京奥运会就现在已经： 553

第七部分泛型和枚举

一．泛型类型

这就是C++ 中模板的用法：

集合的泛型应用就不说了，下面看Car类：

import https://www.360docs.net/doc/3d7939806.html,parator;

import java.util.Iterator;

import java.util.TreeSet;

public class CarPowerTest {

public static void main(String args[]){

TreeSet treeSet = new TreeSet(new Comparator(){

public int compare(CarPower c1,CarPower c2){

return https://www.360docs.net/doc/3d7939806.html,pareTo(c2);

}

});

CarPower cm1 = new CarPower(372,"宝马6系M6");

CarPower cm2 = new CarPower(309,"奔驰slk350");

CarPower cm3 = new CarPower(239,"保时捷911 Carrera");

CarPower cm4 = new CarPower(200,"奔驰SLK 431");

treeSet.add(cm1);

treeSet.add(cm2);

treeSet.add(cm3);

treeSet.add(cm4);

//

Iterator it = treeSet.iterator();

while(it.hasNext()){

CarPower listKey = it.next();

System.out.println(listKey.carPower+ " " + listKey.carName);

}

}

}

class CarPower{

int carPower;

String carName;

CarPower(int carPower,String carName){

this.carPower = carPower;

this.carName = carName;

}

public int compareTo(CarPower cm){

return this.carPower - cm.carPower;

}

}

运行结果：

200 奔驰SLK 431

239 保时捷911 Carrera

309 奔驰slk350

372 宝马6系M6

解析：

TreeSet()四种构造方法，一种是指定比较器，Comparator是个接口，里面的compare()方法，要重写；二．枚举类型

定义常量：

enum Direction{

FORWARD,BACK,LEFT,RIGHT

}

定义方法：

第八部分String

（1）构造方法

public class test2 extends test1 {

public static void main(String args[]){

char c[] = {'f','o','r','e','v','e','r'};

//构造方法

String s1 = new String();

String s2 = new String("forever");

String s3 = new String(c);

String s4 = new String (c,1,3);

//获取字符串长度

System.out.println(s4.length());

System.out.println(s1+" "+s2+ " "+ s3 + " " + s4);

}

}

运行

3

forever forever ore

（2）比较方法

（1）public class test2 {

public static void main(String args[]){

String s1 = new String ("hello java!");

String s2 = new String ("hello java!");

String s3 = "hello java!";

String s4 = "hello java!";

System.out.println(s1==s2);

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

System.out.println(s4==s3);

}

}

运行结果：

false

false

true

解析：s1 ,s2 分别开辟了两个不同的空间，返回值为false；

S3 ，s4 这样的方式传创建的常量被放在公共的字符串池中，可以共享使用，即s3，s4指向的地址是

一样的

（2）public class test2 {

public static void main(String args[]){

String s1 = new String ("Hello");

String s2 = new String ("Hello");

String s3 = new String("JAVa");

String s4 = new String("java");

String s5 = "Hello";

System.out.println(https://www.360docs.net/doc/3d7939806.html,pareTo(s2));

System.out.println(https://www.360docs.net/doc/3d7939806.html,pareTo(s3));

System.out.println(https://www.360docs.net/doc/3d7939806.html,pareTo(s4));

System.out.println(https://www.360docs.net/doc/3d7939806.html,pareTo(s5));

System.out.println(https://www.360docs.net/doc/3d7939806.html,pareToIgnoreCase(s4)); // 忽略大小写的比较

System.out.println(s1.regionMatches(1,s2,1,3)); //特定位置的比较

System.out.println(s3.regionMatches(true,0,s4,0,3)); //设定是否对大小写敏感}

}

结果：

-2

-32

true

true

（3）查找

public class test2 {

public static void main(String args[]){

String s1= new String ("xiaowei jialin");

char c1= s1.charAt(0);

char c2= s1.charAt(4);

System.out.println(s1.indexOf("wei")); //返回第一次出现的位置

System.out.println(s1.indexOf("ia",4)); //第4个开始检索

System.out.println(https://www.360docs.net/doc/3d7939806.html,stIndexOf("ia")); // 最后出现的位置

System.out.println(https://www.360docs.net/doc/3d7939806.html,stIndexOf("ia",4)); //第4个开始检索

System.out.println(s1.contains("i"));// 判断是否包含

}

}

结果：

4

9

9

1

true

（4）截取、替换、大小写转换

public class test2 {

public static void main(String args[]){

String s1 = new String ("hello java!");

//检查起始字符

System.out.println(s1.startsWith("l")); //判断起始字符串是否为“ ”

System.out.println(s1.startsWith("l",3)); // 3处开始检索

System.out.println(s1.endsWith("!")); //判断结尾字符

//截取

System.out.println(s1.substring(2)); //从起始到结束

System.out.println(s1.substring(2,4)); //包括开始，不包括结束

//替换

s1.replace("hello","xiaowei");

System.out.println(s1);

s1="xiaowei9921jialin";

s1.replaceAll("[0 - 9]","love"); //正则表达式？？

System.out.println(s1);

//大小写转换

s1="xiaoweiJIALIN";

s1.toUpperCase();

System.out.println(s1.toUpperCase());

//注意：返回值是大写的，并没有转换成大写的

s1.toLowerCase();

System.out.println(s1);

//去除首尾空格

s1 = " xiaoweijialin ";

System.out.println(s1.trim()); // 只是在这个输出起作用

System.out.println(s1);

}

}

运行结果：

false

true

true

llo java!

ll

hello java!

xiaowei9921jialin

XIAOWEIJIALIN

xiaoweiJIALIN //只是修改返回值，不会改变字符串

xiaoweijialin

xiaoweijialin

（5）字符转化为数组、以及字符串分割

public class test2 {

public static void main(String args[]){

String s=new String ("xiao.wei.bao.bao");

char c[]= s.toCharArray();

for(int i=0;i

System.out.print(c[i]);

}

System.out.println();

String s1 [] = s.split("[.]"); //正则表达式对字符串进行拆分

for(int i =0;i

System.out.println(s1[i]);

}

//如果字符不属于正则表达式中的，可以直接使用

String s2[] = s.split("a");

for(int i = 0;i

System.out.println(s2[i]);

}

}

}

运行结果：

xiao.wei.bao.bao

xiao

wei

bao

bao

xi

o.wei.b

o.b

o

说明：

public class test2 {

public static void main(String args[]){

String s = new String();

char c[]= {'a','b','c','d','e','f'};

int i=3456;

float f=3.4f;

s= String.valueOf(c);

System.out.println(s);

s= String.valueOf(i);

System.out.println(s);

s= String.valueOf(f);

for(int n=0;n

System.out.println(s.charAt(n));

}

}

}

运行结果：

abcdef

3456

3

.

4

说明：

String类可以将基本数据类型和字符串数组转化为String类；为静态方法：String::valueOf(type);

（6）可变字符串的创建和初始化

public class test2 {

public static void main(String args[]){

String s0 = new String ("hello java!");

StringBuffer sb= new StringBuffer (s0);

System.out.println("sb's length is : "+sb.length());

System.out.println("sb's capacity is : "+sb.capacity());

sb.setLength(8); //setlength(int newLength)

//如果newLength 小于实际长度，多余部分将被舍弃；如果大于实际长度，将被补空格

System.out.println(sb);

StringBuffer sb1 = sb;

//对于StringBuffer类，只有地址和内容完全一样时，equals（）才为TRUE；

System.out.println(sb.equals(sb1));

//减小用于字符序列的存储空间 trimToSize（）

System.out.println(sb.capacity());

sb.trimToSize();

System.out.println(sb.capacity());

//转化为String

String s = sb.append("xiaowei").append("baobao").toString();

}

}

结果：

sb's length is : 11

sb's capacity is : 27

hello ja

true

27

8

字符串应用举例：