黑马程序员——Java基础---常见对象1

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

Scanner

位于java.util包中,是键盘的输入类最早出现在 出现在JDK1.5版本。

创建：

   new Scanner(System.in)

   传递InputStream类型,传递是InputStream类的对象

   传递的是子类对象

  Scanner(InputStream source) 

  

   nextInt() 接收int类型数据

   nextLine() 接收字符串一整行

测试用例：

import java.util.Scanner;//倒包

public class ScannerDemo {

public static void main(String[] args) {

method_1();

}

public static void method_1(){

Scanner sc = new Scanner(System.in);

//接收键盘输入的一行

String line = sc.nextLine();

System.out.println(line);

//接收键盘输入整数

int x = sc.nextInt();

System.out.println(x);

----------------------------------------------------------------

//接收整数

int x = sc.nextInt();//123 回车键 \r\n

System.out.println(x);

 

sc = new Scanner(System.in);

//接收键盘一行

String line = sc.nextLine();//接收 \r\n

System.out.println(line);

}

/*

 * boolean hasNextXXX()

 * boolean hasNextInt() 判断出,输入的类型是不是int

 * 如果是返回true,不是返回false

 */

public static void method(){

Scanner sc = new Scanner(System.in);

//接收int参数,但是保险,必须对输入的内容,判断一下

//hasNextInt()

if(sc.hasNextInt()){

int x = sc.nextInt();

System.out.println(x);

}

}

}

Object类

  Object是所有类的父类,包括数组，也就是说任何的类都直接或者间接的继承了Object类，用老师的话说，它就是一个“上帝类”。

  

     构造方法

     public Object(){}  第一行绝对不是super()，因为Object是最高父类

     

 Object类中的方法

  protected Object clone() 克隆对象

  public boolean equals(Object obj) 对象之间的比较性

  public int hashCode() 返回对象的哈希值

  public String toString() 返回对象的字符串表现形式

  public void wait() 导致当前线程等待

  public void notify() 唤醒等待中的线程

  public void nofifyAll() 唤醒全部等待中的线程

  protected void finalize() 垃圾回收器

  public Class getClass() 返回类的class文件对象

     

    private static native void registerNatives();

    native 本地

         内存图: 栈,堆,方法区,本地方法栈,寄存器

         凡是被native修饰的方法,运行时期,进入本地方法栈中运行

         本地方法:

           这样的方法,非JAVA代码编写,C++写的

           本地方法,调用操作系统中的功能

           

 面试细节

   clone  finalize 方法权限受保护

   Object所有类的父类,为什么方法权限受保护

       受保护权限:对外中的子类,可以调用,必须持有super才能调用

       父类构造保护的方法,只能是子类方法中super才能调用

           

 问 == 和equals区别

       == 基本类型 引用类型

       基本类型,比较符合两边具体数值

      引用类型,比较的对象的内存地址

      

   equals 默认比较也是对象内存地址

        重写equals建立自己的对象的比较方式

 

  Object类方法

   返回字符串,方法名toString()

   输出语句中sop,默认调用对象的toString()方法

   了解Object类的方法toString的源代码

   通过toString方法看到的是对象的地址

    对于使用者来讲,看对象的地址,没有意义

     

   重写父类方法toString(),建立自己的字符串表现形式,不想用户看到地址

   看到的应该是类中的成员变量的值

  方法toString里面,就是返回类的成员变量

   如果用户直接打印对象,看到的是成员变量的数值,不是地址了

   方便用户观看,仅此而已

 不能修改成员

测试用例： 

//定义Person类做演示

class Person extends Object{

private String name;

private int age;

Person(String name,int age){

this.age = age;

this.name =  name;

}

public String toString(){

/*

 * getClass().getName()运行结果 包名.类名

 * @

 * Integer.toHexString 类名调用的静态方法,将十进制转成十六进制

 * hashCode() 返回对象的哈希值码,计算结果就是一个十进制数而已

 */

//return getClass().getName()+"@"+Integer.toHexString(hashCode());

return name +"..."+age;

}

}

 

public class ObjectDemo1 {

public static void main(String[] args) {

Person p = new Person("lisi",23);

System.out.println(p);

//Person类继承Object类,可以直接使用父类方法toString()

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

String s  = "abc";

System.out.println(s);

}

}

/*

 * Object类的方法equals(Object obj)

 * 返回布尔值,参数类型  Object obj

 * 对象之间的比较性,用来比较对象的

 * 剖析Object类的方法 equals源代码

 * Object类的源代码中,equals方法默认比较的是对象中的地址

 * 

 * 既然对象都是new出来的,所以地址肯定也是不同的

 * 比较对象的地址有意义吗

 * 

 * 重写equals方法,建立对象自己的比较方式

 * 比较的成员变量的值

 */

class Cat{}

class Student{

private int age;

Student(int age){

this.age = age;

}

//重写equals方法,建立Student类自己的比较方式

//两个对象中成员变量age的值,如果一样返回true

public boolean equals(Object obj){

//判断obj是不是null,如果是,就不需要比较

if(obj == null)

return false;

//判断this和obj是不是同一个对象,如果是不要比较

if(this == obj)

return true;

// return this == obj ;

//this.age  == obj.age

//将提升父类类型的obj,转成Student类型

//目标类型  变量 = (目标类型)要被转换的变量;

//强制转换之前,判断,传递的参数obj是不是Student类型

//如果是,可以强转,不是Student类型,不要比了

if(obj instanceof Student){

  Student s = (Student)obj;

  return this.age == s.age;

}

return false;

}

}

 

public class ObjectDemo2 {

public static void main(String[] args) {

//建立2个Student类的对象

Student s1 = new Student(15);

Student s2 = new Student(15);

//调用方法equals进行比较

boolean b  = s1.equals(s1);

System.out.println(b);

}

}

 

 

 

/*

 * 对Object 类的方法,进行整理

 * 重写 toString equals 依赖类成员变量

 */

//定义工作者类

class Worker{

private String name;

private int age;

Worker(String name,int age){

this.age = age;

this.name = name;

}

/*

 * 重写父类方法equals

 * 重写目的,建立Worker类自己的比较方法,比较两个对象的年龄

 */

public boolean equals(Object obj){

//判断参数是不是null

if( obj == null )

return false;

//判断this和obj是不是同一个对象

if(this == obj )

return true;

//判断参数obj是不是Worker类对象,如果是就强制转换

if(obj instanceof Worker){

Worker w = (Worker)obj;

return this.age == w.age;

}

return false;

}

/*

 * 重写父类的方法toString

 * 重写目的,打印对象的时候,直接输出成员变量的值

 * 重写方法中,直接返回成员变量值

 */

public String toString(){

return "Worker "+ name + ".." + age;

}

}

public class ObjectDemo3 {

public static void main(String[] args) {

Worker w1 = new Worker("花千骨", 356); 

Worker w2 = new Worker("白子画", 356); 

// System.out.println(w2);

boolean b = w1.equals(w2);

System.out.println(b);

}

}

 

 

 

/*

 * 对象变成垃圾后,垃圾回收器调用方法finalize

 * 垃圾收取,自动方式,不需要开发人员去处理

 * Object

 * final finalize finally

 */

 

class Teacher{

public void finalize(){

System.out.println("对象被收垃圾了");

}

}

 

public class ObjectDemo4 {

public static void main(String[] args) {

new Teacher();

new Teacher();

new Teacher();

new Teacher();

new Teacher();

new Teacher();

System.gc();

new Teacher();

new Teacher();

new Teacher();

}

}

String类

概述

        String是字符串的类类型，用于描述字符串事物。字符串是一个特殊的对象。

 构造方法

 

   String(byte[] bytes)传递字节数组   byte -128-127

      将参数字节数组变成字符串

      

   String(bytes[] bytes,int offset,int length)传递字节数组,两个整数

        将字节数组中的一部分变成字符串

        

   String(char[] ch) 传递字符数组

       将字符数组变成字符串

       

       

   String(char[] ch,int offset,int length)传递字符数组

        将字符数组一部分转成字符串

        第一个参数开始索引,第二个参数获取几个

特点

        字符串是常量,它的值在创建之后不能更改。

   JAVA语言中,只要写个双引号 "" 字符串对象, 就是String类的对象

   可以"".String类的方法

      字符串的底层实现原理：

      其实可以将字符串看成是一个字符数组  char[]

      

      private final char value[]

   String类,字符串表示,用的是字符数组  "abc"   char[] value = {'a','b','c'}

        数组建立好了,变成最终数组,长度,还是里面的内容,不可改变         

 

演示用例：

证明String的不变性

public static void main(String[] args) {

String s = "abc";

System.out.println(s);

method(s);

System.out.println(s);

}

public static void method(String s){

  s = s +"w";

}

}

 

注意：

区分 String s1 = "abc";

String s2 = new String("abc");

 

public static void main(String[] args) {

String s1 = "abc";

String s2 = new String("abc");

System.out.println(s1);

System.out.println(s2);

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

/*

 * String s1 = "abc"创建了1个字符串对象abc

 * String s2 = new String("abc")创建了2个对象

 * 1个对象是new String(),第二个对象是"abc"

 * 

 * s1直接指向abc对象

 * s2指向的是new String()对象

 */

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

/*

 *  s1.equals是真

 *  String类继承Object,重写了方法equals比较的是字符的实际内容

 *  不是地址

 */

}

 

常见操作方法

 

1. String类中判断方法 -- 计算结果都是真假 boolean

  1.1 public boolean equals(Object obj)

    String类继承Object,重写equals方法,建立字符串自己的比较方式

          比较的不是字符串的内存,而是比较实际的字符的具体内容,是不是完全相等,如果全等返回true。

/*

* String类判断两个字符串是不是全等

* equals("")  适合于密码验证

*/

public static void method(){

String s1 = "abc";

String s2 = new String("abc");

//s1对象,调用String类的方法equals传递s2

boolean b = s1.equals(s2);

System.out.println(b);

}

  1.2 public boolean equalsIgnoreCase(String s)

          比较两个字符串是否相等,忽略大小写

    /*

 * String类判断两个字符串是不是相等

 * 忽略大小写

 * equalsIgnoreCase("") 做验证码

 */

public static void method_1(){

String s1 = "hello";

String s2 = "HELLo";

//s1对象,调用String类的方法equalsIgnoreCase传递s2

boolean b = s1.equalsIgnoreCase(s2);

System.out.println(b);

}       

  1.3 public boolean contains(String s)

         判断一个字符串中,是否包含另一个字符串,全包含返回true

          /*

 * String类判断一个字符串中是否包含另一个字符串

 * contains("")

 */

public static void method_2(){

String s1 = "hello world";

String s2 = "wo";

//s1对象调用String类的方法contains传递s2

//判断字符串s1中,是不是完全包含s2

boolean b = s1.contains(s2);

System.out.println(b);

}

  1.4 public boolean startsWith(String s)

         判断一个字符串,是否以另一个字符串开头,是开头返回true

   /*

 * String类判断一个字符串是否以另一个字符串开头

 * startsWith("")

 */

public static void method_3(){

String s1 = "HelloWorld.java";

String s2 = "H";

//s1对象调用String类方法startsWith传递s2

//判断s1是不是以s2开头

boolean b = s1.startsWith(s2);

System.out.println(b);

}

  1.5 public boolean endsWith(String s)

        判断一个字符串,是否以另一个字符串结尾,是结尾返回true

         /*

 * String类判断一个字符串是否以另一个字符串结尾

 * endsWith("")

 */

public static void method_4(){

String s1 = "HelloWorld.java";

String s2 = ".java";

//s1对象调用String类的方法endsWith传递s2

//判断s1是不是以s2结尾

boolean b = s1.endsWith(s2);

System.out.println(b);

}

  1.6 public boolean isEmpty()

       判断一个字符串中是不是空的,如果一个字符串中一个字符都没有,返回true ""

/*

 * String类判断一个字符串中是否有字符

 * isEmpty()

 */

public static void method_5(){

String s = "";

//s1对象调用String类的方法isEmpty()

boolean b = s.isEmpty();

System.out.println(b);

}

 2. String类中的获取方法

  2.1 public char charAt(int index)

       获取字符串中,指定的索引上的单个字符  "abcd"  返回指定索引上的单个字符

        /*

 * String类获取指定索引上的单个字符

 * charAt(int index)传递索引,返回字符

 * 索引没有??出现字符串越界异常

 * StringIndexOutOfBoundsException

 */

public static void method(){

String s = "how are you";

//s对象调用String类方法charAt传递索引

char ch = s.charAt(3);

System.out.println(ch);

}

  2.2 public int indexOf(char ch)

      获取指定的字符,在字符串中第一次出现的索引    ,如果找不到字符,返回-1

       /*

 * String类获取字符在字符串中第一次出现的索引

 * indexOf(char ch)传递字符,返回第一次出现索引

 * 没有这个字符,返回-1 (负数不能是索引)

 */

public static void method_1(){

String s = "fine thank you";

//s对象调用String类方法indexOf传递字符

int index = s.indexOf('H');

System.out.println(index);

}

  2.3 public int indexOf(char ch, int fromIndex)

     获取指定的字符,在字符串中第一次出现的索引 ,指定开始查找的索引,如果找不到字符,返回-1

      /*

 * String类获取字符在字符串中第一次出现的索引

 * 指定开始查找索引

 * indexOf(char ch,int fromIndex)传递字符,开始查找的索引

 * 没有这个字符,返回-1 (负数不能是索引)

 */

public static void method_2(){

String s = "fine thank you";

//s对象调用String类方法indexOf传递字符,指定索引

int index = s.indexOf('n',8);

System.out.println(index);

}

  2.4 public int indexOf(String s)

    获取指定的字符串,在另一个字符串中第一次出现的索引,如果找不到字符串,返回-1

     /*

 * String类获取一个字符串在另一个字符串中第一次出现的索引

 * indexOf(String s)传递字符串

 * 如果找不到返回-1

 */

public static void method_3(){

String s = "fine thank you";

//s对象调用String类的方法indexOf传递字符串

int index = s.indexOf("tha");

System.out.println(index);

}

  2.5 public int indexOf(String s, int fromIndex)

    获取指定的字符串,在另一个字符串中第一次出现的索引,指定开始查找的索引,如果找不到字符串,返回-1

    /*

 * String类获取一个字符串在另一个字符串中第一次出现的索引

 * 指定开始查找的索引

 * indexOf(String s,index fromIndex)传递字符串,开始查找索引

 * 如果找不到返回-1

 */

public static void method_4(){

String s = "fine thank you";

//s对象调用String类方法indexOf传递字符串,传递索引

int index = s.indexOf("han",7);

System.out.println(index);

}

  2.6 public int lastIndexOf(char ch)

   获取指定的字符,在字符串中最后一次出现的索引,反向查找,如果找不到返回-1

    /*

 * String类获取一个字符在一个字符串中最后一次出现的索引

 * lastIndexOf(char ch)传递字符

 * 如果找不到返回-1

 */

public static void method_5(){

String s = "fine thank you";

//s对象调用String方法lastIndexOf传递字符

int index = s.lastIndexOf('n');

System.out.println(index);

}

  2.7 public int lastIndexOf(char ch,int formIndex)

    获取指定的字符,在字符串中最后一次出现的索引,反向查找,指定开始查找的索引,如果找不到返回-1

    /*

 * String类获取一个字符在一个字符串中最后一次出现的索引

 * 指定开始查找的索引

 * lastIndexOf(char ch,int fromIndex)传递字符,传递开始查找索引

 * 如果找不到返回-1

 * 从开始索引,向前查找

 */

public static void method_6(){

String s = "abmcmdemfgmh";

//s对象调用String类方法lastIndexOf传递字符,传递开始查找索引

int index = s.lastIndexOf('m',6);

System.out.println(index);

}

  2.8 public int length()

    获取字符串的长度 ,返回的是字符串中字符的个数

       数组的属性  数组名.length     字符串的方法  字符串.length()

   /*

 * String类获取字符串中字符个数

 * 字符串长度

 * length()

 */

public static void method_7(){

String s = "khjgfdmhyfbvdcmkjngfbvdc";

int length = s.length();

System.out.println(length);

}

  2.9 public String substring(int begin,int end)

        获取字符串的一部分,开始索引,结束索引,返回新的字符串

 

/*

 * String类的获取字符串的一部分

 * 截取字符串

 * substring(int begin ,int end)

 * 包含头,不包含尾

 */

public static void method_8(){

String s = "abcdefghijk";

s = s.substring(2,5);

System.out.println(s);

String s1 = "abcdefg";

//从开始索引,后面全要

s1 = s1.substring(2);

System.out.println(s1);

}

3. String类转换方法

   3.1 public byte[]  getBytes()

        将字符串转成字节数组 ,查询本机默认编码表  

         /*

 * String类将字符串转成字节数组 查询编码表 getBytes()

 */

public static void method() {

// ""可以直接调用String类的方法

// byte[] bytes = "abcd".getBytes();

byte[] bytes = "换成中文".getBytes();

for (int x = 0; x < bytes.length; x++) {

System.out.println(bytes[x]);

}

 

byte[] bytes2 = { -69, -69, -77, -55, -42, -48, -50, -60 };

String s = new String(bytes2);

System.out.println(s);

}

   3.2 public char[]  toCharArray()

       将字符串转成字符数组,不查询编码表 

              /*

 * String类将字符串转成字符数组

 * 不查询编码表

 * toCharArray()

 */

public static void method_1(){

//""调用String类方法

char[] ch = "abcde".toCharArray();

for(int x = 0 ; x < ch.length ;x++){

System.out.println(ch[x]);

}

}

   3.3 public String toUpperCase()

        将字符串全部转成大写字母  

         public static void method_2(){

String s = "A5Bcd*eFGhJIk中lMn";

//s对象调用String类的方法toUpperCase

String upper = s.toUpperCase();

System.out.println(upper);

 

   3.4 public String toLowerCase()

          将字符串全部转成小写字母  

           /*

 * String类将字符串转成小写

 * toLowerCase

 */

//s对象调用String类的方法toLowerCase

String lower = s.toLowerCase();

System.out.println(lower);

}

   3.5 public String concat(String s)

           将两个字符串连接起来  +

            /*

 * String类将两个字符串连接

 * concat(String s)

 */

public static void method_3(){

String s = "abc".concat("qq");

System.out.println(s);

//String s = "abc"+"qq";

}

   3.6 public static String valueOf(传递任意数据类型)

         将任意数据类型变成字符串

/*

 * String类将任意数据类型变成字符串

 * static valueOf(写任意数据类型)

 */

public static void method_4(){

String s = String.valueOf(false);

//s = false+"";

System.out.println(s);

}

 4. String类其他功能

   4.1 public String[] split(String s)

        切割字符串,传递参数就是一个切割的标准

         abc de fgh jk

          /*

 * String类切割字符串方法

 * split(切割标准)返回新的字符串数组

 */

public static void method(){

//String s = "abWcWdefgWhijWkl";

String s = "192.168.123.45";

//s对象调用String类的方法split 传递标准

String[] str = s.split("\\.");

for(int x = 0 ; x < str.length ; x++){

System.out.println(str[x]);

}

}

   4.2 public String replace(char oldChar,char newChar)

        替换字符串,被替换以前的,替换以后的新字符

         /*

 * String类替换字符串方法

 * replace()传递老字符,新字符

 * 返回新的字符串

 */

public static void method_1(){

String s = "www.itcast.cn";

//s对象调用方法replace传递2个字符

s = s.replace('t', 'M');

System.out.println(s);

}

   4.3 public String replace(String oldString,String newString)

       替换字符串,被替换以前的字符串,替换以后的新字符串

        /*

 * String类替换字符串方法

 * replace传递老的字符串,新的字符串

 * 返回新的字符串

 */

public static void method_2(){

String s = "www.itcast.cn";

//s对象调用方法replace传递2个字符串

s = s.replace("cast", "CAST");

System.out.println(s);

}

   4.4 public String trim()

        去掉字符串两端空格,返回新的字符串,中间空格不理会

         /*

 * String类去掉字符串两端空格

 * trim()返回新字符串

 * 注册,登录使用

 */

public static void method_3(){

String s = "  aa bb cc   ";

System.out.println(s);

//s对象调用String类方法trim

s = s.trim();

System.out.println(s);

}

   4.5 public int compareTo(String s)

         两个字符串进行比较,称为字符串的自然顺序,字典顺序abcd  ABCD

         按照字符串的字典顺序进行比较

         返回值是整数,比较后出现三种结果  s1.compareTo(s2)

         s1小于s2  < 0 负数

         s1等于s2  = 0

         s1大于s2  > 0 正数

         char c = '以'

public static void method_4(){

String s1 = "abc";

String s2 = new String("bbc");

//s1对象调用String类的方法compareTo传递s2

int number = s1.compareTo(s2);

System.out.println(number);

}

 实例练习：

/*

 * woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”

 * 中java出现了5次

 * 实现步骤:

 *   1. 定义int计数器,保存字符串出现次数

 *   2. 字符串使用查找功能indexOf

 *     indexOf -1 程序结束,找完了

 *   3. indexOf结果不是-1

 *     计数器++

 *     截取字符串  indexOf结果+被找的字符串长度

 */

public static void test_2(){

String big = "woaijavawozhenaijavawozhejavandeaijavawozhendehenaijavaxinbuxijavanwoaijavagun";

String small = "java";

//定义计数器

int count = 0 ;

//定义变量,记录indexOf计算结果

int index = 0 ;

//开始循环查找,结束条件是 indexOf = -1

while (  ( index = big.indexOf(small)) !=-1  ){

//计数器++

count++;

//对字符串进行截取,索引确定 index + 字符串的长度

big = big.substring(index+small.length());

}

System.out.println(count);

}

/*

 * 举例：键盘录入”abc” 输出结果：”cba”

 * 键盘录入 Scanner类方法nextLine

 * 字符串转成字符数组

 * 数组反转 -- 数组的最远端换位

 * 字符数组变成字符串

 */

public static void test_1(){

//键盘输入

Scanner sc = new Scanner(System.in);

String s = sc.nextLine();

//字符串转成字符数组 toCharArray()

char[] ch = s.toCharArray();

//对数组进行反转,数组中元素确实进行了位置交换

for(int x = 0,y = ch.length-1 ; x < y ; x++,y--){

char temp = ch[x];

ch[x] = ch[y];

ch[y] = temp;

}

//将数组变成字符串

//String构造方法

String s1 = new String(ch);

System.out.println(s1);

}

/*

 * 举例：int[] arr = {1,2,3}; 输出结果：[1, 2, 3] 

 * 获取数组每个元素,进行字符串的拼接

 */

public static void test(){

int[] arr = {1,2,3};

//定义字符串,保存一半中括号

String s = "[";

//数组遍历

for(int x = 0 ; x < arr.length ; x++){

//判断变量x是不是到达了数组的最大索引

if(x != arr.length-1)

//s = s + arr[x]+", ";

s = s.concat(arr[x]+", ");

else

//s = s + arr[x]+"]";

s = s.concat(arr[x]+"]");

}

System.out.println(s);

}

 StringBuffer

概述

        StringBuffer是字符串缓冲区，缓冲区用于存储String数据，所以也称之为容器。。

  

常见操作

 1、StringBuffer类的添加功能

   数据添加到字符串缓冲区中

   append  追加

   insert  插入

/*

 * 在缓冲区的指定索引位置上插入数据

 * insert(索引,要添加数据)

 */

public static void method_1(){

StringBuffer buffer = new StringBuffer();

buffer.append("abcdefg");

System.out.println(buffer);

//调用StringBuffer类的方法insert 第3索引上添加6

buffer.insert(3, 6);

System.out.println(buffer);

}

/*

 * 向缓冲区追加数据

 * append(任意类型)

 * 方法的返回值是  StringBuffer类型

 * 方法是StringBuffer类的对象

 * public StringBuffere append(XX){

 *   return this;

 * }

 * 谁调用我,我返回谁

 * */

public static void method(){

//创建缓冲区对象

StringBuffer buffer = new StringBuffer();

//调用StringBuffer类的方法append追加数组

buffer.append(3.1).append(false).append(12).append('a');

System.out.println(buffer);

}

2、   StringBuffer类的删除方法

     deleteCharAt(int index)删除指定索引上的单个字符

     delete(int begin,int end)删除指定索引内的字符

/*

 * StringBuffer类的删除方法

 * delete(int begin,int end)

 * JAVA凡是开始结尾下标,包含头,不包含尾

 */

public static void method_1(){

StringBuffer buffer = new StringBuffer();

buffer.append(1234567);

//删除范围 1-4索引

buffer.delete(1,4);

System.out.println(buffer);

}

/*

 * StringBuffer类的删除方法

 * deleteCharAt(int index)

 */

public static void method(){

StringBuffer buffer = new StringBuffer();

buffer.append(1234567);

//删除3索引上的字符

buffer.deleteCharAt(3);

System.out.println(buffer);

}

3、  StringBuffer类其他方法

    setCharAt(int index,char ch)

第一个要修改的索引,修改后的字符

/*

 * 修改指定索引上的字符

 * setCharAt(int index ,char ch)

 */

private static void method() {

StringBuffer buffer = new StringBuffer();

buffer.append("abcdef");

//修改第一索引上字符,修改成m

buffer.setCharAt(1, 'm');

System.out.println(buffer);

}

    

    replace(int start,int end,String str)

    将一个索引范围内的数据,全部替换成指定的字符串

     /*

 * 替换缓冲区中指定的字符

 * 开始和结束的索引

 * replace(int start,int end,String str)

 */

private static void method_1() {

StringBuffer buffer = new StringBuffer();

buffer.append("abcdef");

//替换缓冲区 1-3索引,替换为itcast

buffer.replace(1, 3, "itcast");

System.out.println(buffer);

}

    reverse()

将缓冲区中的内容反转

/*

 * 反转缓冲区

 * reverse()

 */

private static void method_2() {

StringBuffer buffer = new StringBuffer();

buffer.append("abcdef");

//反转缓冲区

buffer.reverse();

System.out.println(buffer);

}

4、   String对象和StringBuffer对象之间的相互转换

     不变对象,转成可变对象  String->StringBuffer

     可变对象,转成不可变对象 StringBuffer -> String

/*

 * StringBuffer -> String

 * StringBuffer类的方法toString()

 */

public static void method_1(){

StringBuffer buffer = new StringBuffer();

buffer.append(123);

buffer.append(false);

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

String s = buffer.toString();

System.out.println(s);

}

/*

 * String -> StringBuffer

 * 两种方式

 *  StringBuffer类构造方法

 *  StringBuffer类append

 */

public static void method(){

StringBuffer buffer = new StringBuffer("abc");

buffer.append("1234");

}

练习 用例：

利用StringBuffer将数组拼接成字符串

 * 采用字符串缓冲区对象StringBuffer类实现

 * 节约内存,运行速度就快了

 * append取代字符串 + 操作

 * 缓冲区变成字符串

 */

public static String test(){

int[] arr = {1,2,3};

//创建缓冲区对象

StringBuffer buffer = new StringBuffer();

buffer.append("[");

for(int x = 0 ; x < arr.length ;x++){

if( x!=arr.length-1)

buffer.append(arr[x]+", ");

else

buffer.append(arr[x]+"]");

}

return buffer.toString();

}

 StringBuilder

StringBuilder类方法,和StringBuffer完全一样

  

  StringBuffer,出现JDK1.0

  StringBuilder,出现JDK1.5

 

  StringBuilder类运行速度比StringBuffer快

  

  StringBuffer线程安全

  StringBuilder线程不全的

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------