第五章总结

最新推荐文章于 2023-07-18 21:35:13 发布

暴露了姓氏的王某

最新推荐文章于 2023-07-18 21:35:13 发布

阅读量250

点赞数

文章标签： eclipse

本文链接：https://blog.csdn.net/wCq1433223/article/details/124228404

版权

5.1 String 类
5.1.1 声明字符串
字符串是常量，它们可以显示任何文字信息，

‘ ’ 字符一个

“ ” 字符串多个

5.1.2 创建字符串
1.引用字符串常量

String a = “建团一百周年”

String a；

a = “建团一百周年”

2.利用String提供的构造方法

String a = new string“建团一百周年”

3.利用字符数组

Char[] ch ={‘建’,’团’,’一’,’百’,’周’,’年’}

String a = new string(ch)

4.提取字符数组中的一部分

Char[] ch ={‘举’,’办’,‘建’,’团’,’一’,’百’,’周’,’年’,’晚’,’会’}；

String a = new string(ch，2，8)；

import java.util.Scanner;

public class dd {
代码如下
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String a = "时间就是金钱，我的朋友。";//直接引用字符串常量
       System.out.println("a = " + a);
       String b = new String("我爱清汤小肥羊");//利用构造方法实例化
       String c = new String(b);//使用已有字符串变量实例化
       System.out.println("b = " + b);
       System.out.println("c = " + c);
       char[] charArray = {'t','i','m','e'};
       String d = new String(charArray);//利用字符数组实例化
       System.out.println("d = " + d);
       char[] charArray2 = {'时','间','就','是','金','钱'};//提取容从元素开始，取2个字符
       String e = new String(charArray2, 4,2);
       System.out.println("e = " + e);
   }

}

5.2 连接字符串

5.2.1 连接字符串

String a =“建团“

String b =“一百周年“

b= a + b; // b =“建团一百周年“

b += a ; // b =b+a=“建团一百周年“

代码如下

public class dd {

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String a = "abc";
       String b = "123";
       String c = a + b + "!"; //使用“+”拼接字符串
       String d = "拼接字符串";
       d += c; // 使用“+=”拼接字符串
       System.out.println("a = " + a);
       System.out.println("b = " + b);
       System.out.println("c = " + c);
       System.out.println("d = " + d);
   }

}

5.2.2连接其他数据类型

String a =” 建团”;

Int b = 100;

String c =“周年“;

a+=（b+c）

1.b+c=“100周年“

2.a=a+100周年=建团100周年

5.3提取宇符申信息
5.3.1 获取字符串长度
长度字符串名.length();

String a = “建团一百周年”

Int b = a. length();

5.3.2 获取指定的字符
String a = “建团一百周年”

Char b = a. chrAt (3); //百
代码如下

public class dd {

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "床前明月光，疑是地上霜。";    // 创建字符串对象str
       char chr = str.charAt(4);                // 将字符串str中索引位置为4的字符赋值给chr
       System.out.println("字符串中索引位置为4的字符是：" + chr); // 输出chr
   }

}

5.3.3 获取子字符串索引位置
String a = “建团一百周年”

Int b = a.indexof(“百”)； //3

String a = “abacadaeaf”

1.Int b = a.indexof(“a”)； //取第一个0

2.Int b= a.lastindexof (“a”);//最后一个8

3.Int b = a.indexof(“a”,3)；//第3位后面的a 4

4.Int c = a. lastindexof (“a”,7)；//第7位是最后一位，a取前面的一位 64
代码如下

public class dd {

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "12345abcde";
               // 获取字符串str中"abc"首次出现的索引，赋值给charIndex
       int charIndex = str.indexOf("abc");
               // 判断：index的值不等于-1
       if (charIndex != -1) {
                   // 如果index不等于-1，则执行此行代码，说明str中存在“abc”字符串
       System.out.println("str中存在abc字符串");
       } else {
       // 如果index等于-1，则执行此行代码，说明str中没有“abc”字符串
       System.out.println("str中没有abc字符串");
               }
   }

}

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "We are the world";
       // 获取字符串中"r"第一次出现的索引位置
       int firstIndex = str.indexOf("r");
       // 获取字符串中"r"第二次出现的索引位置，从第一次出现的索引位置之后开始查找
       int secondIndex = str.indexOf("r", firstIndex + 1);
       // 获取字符串中"r"第三次出现的索引位置，从第二次出现的索引位置之后开始查找
       int thirdIndex = str.indexOf("r", secondIndex + 1);
       // 输出三次获取的索引位置
       System.out.println("e第一次出現的索引位置是：" + firstIndex);
       System.out.println("e第二次出現的索引位置是：" + secondIndex);
       System.out.println("e第三次出現的索引位置是：" + thirdIndex);
   }

}

    public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "Let it go!Let it go!";    // 创建字符串对象
       int gIndex = str.lastIndexOf("g");   // 返回”g“最后一次出现的位置
       int goIndex = str.lastIndexOf("go");   // 返回”go“最后一次出现的位置
       int oIndex = str.lastIndexOf("o");   // 返回”o“最后一次出现的位置
       System.out.println("字符串\"Let it go!Let it go\"中:\n");
       System.out.println("\"g\"最后一次出现的位置是：" + gIndex);
       System.out.println("\"o\"最后一次出现的位置是：" + oIndex);
       System.out.println("\"go\"最后一次出现的位置是：" + goIndex);
   }

}

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "01a3a56a89";
       // 返回字母"a"最后一次出现的索引位置
       int lastIndex = str.lastIndexOf("a");
       // 返回字母"a"的索引位置otherIndex
       // 满足0<=fiveBeforeIndex<=5条件，在满足条件的结果集中，返回最大的数字
       int fiveBeforeIndex = str.lastIndexOf("a", 5);
       // 返回字母"a"的索引位置otherIndex
       // 满足0<=threeBeforeIndex<=3条件，在满足条件的结果集中，返回最大的数字
       int threeBeforeIndex = str.lastIndexOf("a", 3);
       System.out.println("字符串\"01a3a56a89\"中：\n");
       System.out.println("字母\"a\"最后一次出现的位置是：" + lastIndex);
       System.out.println("从索引位置5开始往回搜索，字母\"a\"最后一次出现的位置：" + fiveBeforeIndex);
       System.out.println("从索引位置3开始往回搜索，字母\"a\"最后一次出现的位置：" + threeBeforeIndex);
   }

}

5.3.5 获取字符数组

char[] ch = 字符串名. toCharArray();

String a = "建团一百周年";

char[] ch = str.toCharArray();

代码如下

public class dd {

   public static void main(String[] args) {
           // TODO 自动生成的方法存根
           String str = "这是一个字符串";//创建一个字符串
           char[] ch = str.toCharArray();//将字符串转换成字符数组
           for (int i = 0; i < ch.length; i++) {//遍历字符数组
               System.out.println("数组第" + i + "个元素为：" + ch[i]);//输出数组的元素
       }
       }
   }

5.3.6 判断子字符串是否存在

boolean b = 字符串名.contains(字串);

String a = "建团一百周年";

boolean b = a.contains(一百)；

代码如下

public class dd {
   public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String str = "今天的菜单有：蒸羊羔，蒸熊掌，蒸鹿尾。烧花鸭，烧雏鸡，烧子鹅，卤煮咸鸭，酱鸡，腊肉，松花小肚。";
        System.out.println(str);// 输出字符串
        boolean request1 = str.contains("腊肉");// 判断字符串中是否有“腊肉”的字样
        System.out.println("今天有腊肉吗？" + request1);
        boolean request2 = str.contains("汉堡");// 判断字符串中是否有“汉堡”的字样
        System.out.println("今天有汉堡吗？" + request2);
    }

}

5.4字符串的操作

5.4.1 截取字符串

substring(前序号，后序号)

String a = "建团一百周年";

String b = a.contains(2,4);

代码如下

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "为革命保护视力，眼保健操开始！";
       String substr = str.substring(8);       //从第8位开始截取字符串
       System.out.println("字符串str的后半句是：" + substr);
   }

}

public class dd {
   public static void main(String[] args) {
           // TODO 自动生成的方法存根
           String str = "闭门造车，出门合辙。";
           // 从0开始（即从头开始）截取至4-1索引位置的子字符串
           String substr = str.substring(0, 4);
           System.out.println("字符串str的前半句是：" + substr);

       }

   }

5.4.2字符串替换

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str="明月几时有，把酒问青天";
       String restr=str.replace("月", "日");   //将str中的”月“全部替换成”日“
       System.out.println("字符串str替换之后的效果："+restr);
   }
}

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "0123456789abc\\d";
       // 使用replace()将符合"\\d"表达式的字符串替换"?"
       String restr = str.replace("\\d", "?");
       // 使用replaceAll()将符合"\\d"表达式的字符串替换"?"
       String restrAll = str.replaceAll("\\d", "?");
       // 输出结果
       System.out.println("字符串str：" + str);
       System.out.println("使用replace()替换的结果：" + restr);
       System.out.println("使用replaceAll()替换的结果：" + restrAll);
   }

}

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "8I want to marry you, so I need you！";
       // 将开头的数字替换成两个双引号""
       String noNumber = str.replaceFirst("\\d", "");
       // 将第一次出现的"you"替换成"her"
       String youToHer = noNumber.replaceFirst("you", "her");
       // 输出结果
       System.out.println("替换之后的结果是："+youToHer);
   }

}

5.4.3 字符串分割

字符串.replace(字串<可传正规表达式>，次数)；

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "从前有座山,山里有个庙,庙里有个小松鼠";
       // 让字符串按照","进行分割
       String[] strArray = str.split(",");
       // 使用for循环，循环输出数字所有元素
       for (int i = 0; i < strArray.length; i++) {
           System.out.println("数组第" + i + "索引的元素是：" + strArray[i]);
   }
   }
}

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "a1b2,c,d e f|gh";
       // 使用","分割
       String[] a1 = str.split(",");
       // 使用空格分割
       String[] a2 = str.split(" ");
       // 使用"|"分割
       String[] a3 = str.split("\\|");
       // 使用正则表达式分割，本行用数字分割
       String[] a4 = str.split("\\d");
       // 同时用","、空格、"|"、数字分割，用符号"|"连接所有分隔符
       String[] a5 = str.split(",| |\\||\\d");
       // 显示str的原值
       System.out.println("str的原值：[" + str + "]");
       // 使用for-each循环展示","分割的结果
       System.out.print("使用\",\"分割：");
       for (String b : a1) {
           System.out.print("[" + b + "]");
       }
       System.out.println();       // 换行
       // 使用for-each循环展示空格分割的结果
       System.out.print("使用空格分割：");
       for (String b : a2) {
           System.out.print("[" + b + "]");
       }
       System.out.println();
       // 使用for-each循环展示"|"分割的结果
       System.out.print("使用\"|\"分割：");
       for (String b : a3) {
           System.out.print("[" + b + "]");
       }
       System.out.println();
       // 使用for-each循环展示数字分割的结果
       System.out.print("使用數字分割：");
       for (String b : a4) {
           System.out.print("[" + b + "]");
       }
       System.out.println();
       // 使用for-each循环展示所有分隔符同时分割的结果
       System.out.print("同時使用所有分隔符：");
       for (String b : a5) {
           System.out.print("[" + b + "]");
       }
       System.out.println();
   }

}

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = "192.168.0.1";
       // 按照"."进行分割
       String[] firstArray = str.split("\\.");
       // 按照"."进行两次分割
       String[] secondArray = str.split("\\.", 2);
       // 输出str原值
       System.out.println("str的原值为：[" + str + "]");
       // 输出全部分割的结果
       System.out.print("全部分割的结果：");
       for (String a : firstArray) {
           System.out.print("[" + a + "]");
       }
       System.out.println();// 换行
       // 输出分割两次的结果
       System.out.print("分割两次的结果：");
       for (String a : secondArray) {
           System.out.print("[" + a + "]");
       }
       System.out.println();
   }

}

5.4.4大小写转换

字符串.trim();

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = " abc ";
       String shortStr = str.trim();
       System.out.println("str的原值是：[" + str + "]");
       System.out.println("去掉首尾空白的值：[" + shortStr + "]");
   }

}

5.4.5 去除空白内容

trim()方法可以返回字符串的副本，忽略首尾触碰.语法如下：

字符串.trim();

public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = " abc ";
       String shortStr = str.trim();
       System.out.println("str的原值是：[" + str + "]");
       System.out.println("去掉首尾空白的值：[" + shortStr + "]");
   }

}

   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str = " a b cd e f g ";
       String shortStr = str.replaceAll("\\s", "");
       System.out.println("str的原值是：[" + str + "]");
       System.out.println("去掉首尾空白的值：[" + shortStr + "]");
   }

}

5.4.6 比较字符串是否相等

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String tom, jerry;
       // 直接引入字符串常量
       tom = "I am a student";
       jerry = "I am a student";
       System.out.println("直接引入字符串常量的比较结果：" + (tom == jerry));
       // 使用new创建信对象
       tom = new String("I am a student");
       jerry = new String("I am a student");
       System.out.println("使用new创建对象的比较结果：" + (tom == jerry));
   }
}

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str1 = "Hello";
       String str2 = new String("Hello");
       String str3 = new String("你好");
       String str4 = str2;
       System.out.println("str1 == str2 的结果：" + (str1 == str2));
       System.out.println("str1 == str3 的结果：" + (str1 == str3));
       System.out.println("str1 == str4 的结果：" + (str1 == str4));
       System.out.println("str2 == str4 的结果：" + (str2 == str4));
       System.out.println("str1.equals(str2) 的结果：" + str1.equals(str2));
       System.out.println("str1.equals(str3) 的结果：" + str1.equals(str3));
       System.out.println("str1.equals(str4) 的结果：" + str1.equals(str4));
   }

}

public class dd {
   public static void main(String[] args) {
       // TODO 自动生成的方法存根
       String str1 = "abc";
       // 创建字符串对象，内容全部大写
       String str2 = "ABC";
       // 比较两个字符串的内容是否相等
       System.out.println("区分大小写的结果："+str1.equals(str2));
       // 比较两个字符串的内容是否相等，不区分大小写
       System.out.println("不区分大小写的结果："+str1.equalsIgnoreCase(str2));
   }

}

5.4.7 格式化字符串可变字符串

String 类的静态format()方法用于创建格式化的字符串

import java.util.Date;
public class dd {


      public static void main(String[] args) {
          // TODO 自动生成的方法存根
          Date date = new Date(); //创建 Date 对家 date
          String year = String.format("%tY", date); //将date进行格式化
          String month =String.format("%tB", date);
          String day=String.format("%td", date);
          System.out.println("今年是:" + year + "年"); //输出信息
          System.out.println("现在是:"+month);
          System.out.println("今天是:"+day+"号");
      }

   }

import java.util.Date;
public class dd {
      public static void main(String[] args) {
          // TODO 自动生成的方法存根
          Date date = new Date(); //主方法 //创建Date对象date
              String hour= String.format("%tH", date); //将date进行格式化
              String minute=String.format("%tM", date);
              String second = String.format("%tS", date);//输出的信息
              System.out.println("现在是: " + hour + "时" + minute + "分" + second + "秒");
      }
   }

import java.util.Date;
public class dd{
      public static void main(String[] args) {
          // TODO 自动生成的方法存根
          Date date = new Date(); //创建 Date对象date
          String time = String.format("%tc", date); //将 date格式化
          String form = String.format("%tF", date);//将格式化后的日期时间输出
          System.out.println("全部的时间信息是:"+ time);
          System.out.println("年-月-日格式:"+form);
      }
   }

public class dd {
           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               // 输出字符
                       String str1 = String.format("%c", 'X');
                       System.out.println("字母x大写：" + str1);
                       // 输出数字
                       String str2 = String.format("%d", 1251 + 3950);
                       System.out.println("1251+3950的结果是：" + str2);
                       // 输出小数点后两位
                       String str3 = String.format("%.2f", Math.PI);
                       System.out.println("π取两位小数点：" + str3);
                       // 输出布尔值
                       String str4 = String.format("%b", 2 < 3);
                       System.out.println("2<3的结果是：" + str4);
                       // 输出哈希散列码，等同Integer.toHexString(3015);
                       String str5 = String.format("%h", 3510);
                       System.out.println("3510的hashCode值：" + str5);
                       // 输出8进制
                       String str6 = String.format("%o", 33);
                       System.out.println("33的8进制结果是：" + str6);
                       // 输出16进制
                       String str7 = String.format("%x", 33);
                       System.out.println("33的16进制结果是：" + str7);
                       // 输出科学计数法
                       String str8 = String.format("%e", 120000.1);
                       System.out.println("120000.1用科学计数法表示：" + str8);
                       // 输出带有效位数和指数的16进制浮点值
                       String str9 = String.format("%a", 40.0);
                       System.out.println("40.0的十六进制浮点值：" + str9);
                       // 输出百分号和数字
                       System.out.println(String.format("天才是由%d%%的灵感，%d%%的汗水。", 1, 99));
           }

       }

public class dd {
           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               // 让字符串输出的最大长度为5，不足长度在前端补空格
                       String str1 = String.format("%5d", 123);
                       System.out.println("输出长度为5的字符串|" + str1 + "|");
                       // 让字符串左对齐
                       String str2 = String.format("%-5d", 123);
                       System.out.println("左对齐|" + str2 + "|");
                       // 在8进制前加一个0
                       String str3 = String.format("%#o", 33);
                       System.out.println("33的8进制结果是：" + str3);
                       // 在16进前加一个0x
                       String str4 = String.format("%#x", 33);
                       System.out.println("33的16进制结果是：" + str4);
                       // 显示数字正负号
                       String str5 = String.format("%+d", 1);
                       System.out.println("我是正数：" + str5);
                       // 显示数字正负号
                       String str6 = String.format("%+d", -1);
                       System.out.println("我是负数：" + str6);
                       // 在正数前补一个空格
                       String str7 = String.format("% d", 1);
                       System.out.println("我是正数，前面有空格" + str7);
                       // 在负数前补一个负号
                       String str8 = String.format("% d", -1);
                       System.out.println("我是负数，前面有负号" + str8);
                       // 让字符串输出的最大长度为5，不足长度在前端补0
                       String str9 = String.format("%05d", 12);
                       System.out.println("前面不够的数用0填充：" + str9);
                       // 用逗号分隔数字
                       String str10 = String.format("%,d", 123456789);
                       System.out.println("用逗号分隔：" + str10);
                       // 正数无影响
                       String str11 = String.format("%(d", 13);
                       System.out.println("我是正数，我没有括号：" + str11);
                       // 让负数用括号括起来
                       String str12 = String.format("%(d", -13);
                       System.out.println("我是负数，我有括号的：" + str12);
           }

       }

5.5.1 StringBuffer 类的常用方法
1.创建StringBuffer类

创建一一个新的StringBuffer对象必须用new方法，而不能像String对象那样直接引用字符串常量。

StringBuffer sbf = new StringBuffer() ；//创建一个对象，无初始值

StringBuffer sbf = new StringBuffer ("abc") ；//创建一个对象，初始值为“abc"

StringBuffer sbf = new StringBuffer(32)； //创建一个对象，初始容量为32个字符

2. append()方法

将参数转换成字符串，将所得字符串中的字符追加到此序列中。

sbf：append (obj);

sbf：任意StingBuffer 对象。

5.5.1 StringBuffer类的常用方法

public class dd {
               public static void main(String[] args) {
                   // TODO 自动生成的方法存根
                       StringBuffer sbf =new StringBuffer("门前大桥下,");//创建
                       sbf.append("游过一群鸭,");//追加字符串常量
                       StringBuffer tmp =new StringBuffer("快来快来数一数,");//
                       sbf.append(tmp);
                       int x = 24678;
                       sbf.append(x);//追加整型变量
                       System.out.println(sbf.toString());//输出
               }

           }

public class dd {
           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               StringBuffer sbf = new StringBuffer("0123456");
               System.out.println("sbf的原值是：" + sbf);
               sbf.setCharAt(3, 'A');                        // 将索引为3的字符改成'A'
               System.out.println("修改后的值是：" + sbf);
           }

       }

public class dd {

           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               StringBuffer sbf = new StringBuffer("0123456");
               System.out.println("sbf的原值为："+sbf);
               sbf = sbf.insert(5, "F");   //在索引为5的位置插入"F"，将返回值赋给sbf自己
               System.out.println("修改之后的值为："+sbf);
           }

       }

public class dd {

           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               StringBuffer sbf = new StringBuffer("同一个世界，同一个梦想");
               System.out.println("sbf的原值为：" + sbf);
               sbf = sbf.reverse();// 将字符序列sbf反转
               System.out.println("修改之后的值为：" + sbf);
           }

       }

lic class dd {
           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               StringBuffer sbf = new StringBuffer("天行健，君子以自强不息");
               System.out.println("sbf的原值为："+sbf);
               sbf = sbf.delete(4, 7);   //删除从索引4开始至索引7之前的内容
               System.out.println("删除之后的值为："+sbf);
           }

       }

public class dd{

           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               StringBuffer sbf = new StringBuffer("ABCDEFG");// 创建字符串序列
               int lenght = sbf.length();// 获取字符串序列的长度
               char chr = sbf.charAt(5); // 获取索引为5的字符
               int index = sbf.indexOf("DEF");// 获取DEF字符串所在的索引位置
               String substr = sbf.substring(0, 2);// 截取从索引0开始至索引2之间的字符串
               StringBuffer tmp = sbf.replace(2, 5, "1234");// 将从索引2开始至索引5之间的字符序列替换成"1234"
               System.out.println("sbf的原值为：" + sbf);
               System.out.println("sbf的长度为：" + lenght);
               System.out.println("索引为5的字符为：" + chr);
               System.out.println("DEF字符串的索引位置为：" + index);
               System.out.println("索引0开始至索引2之间的字符串：" + substr);
               System.out.println("替换后的字符串为：" + tmp);
           }

       }

5.5.2 StringBuilder类的使用方法

StringBuilder类与StringBuffer类具有兼容的 API，所以两者的使用方法也相同。

public class dd {
           public static void main(String[] args) {
               // TODO 自动生成的方法存根
               StringBuilder sbd = new StringBuilder();
               System.out.println("sbd的原值为空");
               sbd.append("我是StringBuilder类");
               System.out.println("sbd追加字符串：" + sbd);
               int length = sbd.length();
               System.out.println("sbd的长度为：" + length);
               sbd = sbd.insert(length - 1, "123456");
               System.out.println("插入字符串：" + sbd);
               sbd = sbd.delete(sbd.length() - 1, sbd.length());
               System.out.println("删除最后一个字：" + sbd);
               sbd = sbd.reverse();
               System.out.println("反序输出：" + sbd);
           }

       }

5.5.3 StringBuffer、StringBuilde String之间的关系


 public class dd {		   
 
			public static void main(String[] args) {
				// TODO 自动生成的方法存根
				String str = "String";
				// String转换成StringBuffer
				StringBuffer sbf = new StringBuffer(str);
				// String转换成StringBuilder
				StringBuilder sbd = new StringBuilder(str);
				// StringBuffer转换成String
				str = sbf.toString();
				// StringBuilder转换成String
				str = sbd.toString();
				// StringBuffer转换成StringBuilder
				StringBuilder bufferToBuilder = new StringBuilder(sbf.toString());
				// StringBuilder转换成StringBuffer
				StringBuffer builderToBuffer = new StringBuffer(sbd.toString());
			}
		 
		}

public class dd {		   	 
			public static void main(String[] args) {
				// TODO 自动生成的方法存根
				String str = ""; // 创建空字符串
				// 定义对字符串执行操作的起始时间
				long starTime = System.currentTimeMillis();
				for (int i = 0; i < 10000; i++) { // 利用for循环执行10000次操作
					str = str + i; // 循环追加字符串
				}
				long endTime = System.currentTimeMillis(); // 定义对字符串操作后的时间
				long time = endTime - starTime; // 计算对字符串执行操作的时间
				System.out.println("String循环1万次消耗时间：" + time); // 将执行的时间输出
		 
				StringBuilder builder = new StringBuilder(""); // 创建字符串生成器
				starTime = System.currentTimeMillis(); // 定义操作执行前的时间
				for (int j = 0; j < 10000; j++) { // 利用for循环进行操作
					builder.append(j); // 循环追加字符
				}
				endTime = System.currentTimeMillis(); // 定义操作后的时间
				time = endTime - starTime; // 追加操作执行的时间
				System.out.println("StringBuilder循环1万次消耗时间：" + time); // 将操作时间输出
		 
				StringBuilder builder2 = new StringBuilder(""); // 创建字符串生成器
				starTime = System.currentTimeMillis(); // 定义操作执行前的时间
				for (int j = 0; j < 50000; j++) { // 利用for循环进行操作
					builder2.append(j); // 循环追加字符
				}
				endTime = System.currentTimeMillis(); // 定义操作后的时间
				time = endTime - starTime; // 追加操作执行的时间
				System.out.println("StringBuilder循环5万次消耗时间：" + time); // 将操作时间输出
				}
				}