Java基础篇--字符串处理(StringBuffer)

字符串处理

在Java中最常将字符串作为String类型对象来处理。同时String中也提供了很多操作字符串的函数(可自行查阅资料),而本篇将介绍StringBuffer如何操作字符串。

StringBuffer是使用缓冲区的,本身也是操作字符串的,但与String类不同,String类中的内容一旦声明之后不可改变,改变的只是其内存地址的指向,而StringBuffer中的内容是可以改变的,

对于StringBuffer而言,本身是一个具体的操作类,所以不能像String那样采用直接赋值的方式进行对象实例化,必须通过构造方法完成。

StringBuffer连接字符操作

  • 当一个字符串的内容需要被经常改变时就要使用StringBuffer
  • 在StringBuffer中使用append()方法,完成字符串的连接操作

实例操作一:字符串连接操作(append)

代码:

package 字符串处理;
public class StringBufferDemo01{
    public static void main(String args[]){
        StringBuffer buf = new StringBuffer() ;    // 声明StringBuffer对象
        buf.append("Hello ") ;                    // 向StringBuffer中添加内容
        buf.append("World").append("!!!") ;        // 可以连续调用append()方法
        buf.append("\n") ;                        // 添加一个转义字符
        buf.append("数字 = ").append(1).append("\n") ;    // 添加数字
        buf.append("字符 = ").append(‘C‘).append("\n");     // 添加字符
        buf.append("布尔 = ").append(true) ;    // 添加布尔值
        System.out.println(buf) ;            // 直接输出对象,调用toString()
    }
};

打印结果:

Hello World!!!
数字 = 1
字符 = C
布尔 = true

实例操作二:字符串添加内容(insert)

public class StringBufferDemo03{
    public static void main(String args[]){
        StringBuffer buf = new StringBuffer() ;    // 声明StringBuffer对象
        buf.append("World!!") ;        // 添加内容
        buf.insert(0,"Hello ") ;        // 在第一个内容之前添加内容
        System.out.println(buf) ;
        buf.insert(buf.length(),"偶my耶~") ;    // 在最后添加内容
        System.out.println(buf) ;
    }
};

打印内容

Hello World!!
Hello World!!偶my耶~

实例操作三:字符串反转(reverse)

package 字符串处理;
public class StringBufferDemo04{
    public static void main(String args[]){
        StringBuffer buf = new StringBuffer() ;    // 声明StringBuffer对象
        buf.append("World!!") ;        // 添加内容
        buf.insert(0,"Hello ") ;        // 在第一个内容之前添加内容
        String str = buf.reverse().toString() ;    // 将内容反转后变为String类型
        System.out.println(str) ;        // 将内容输出
    }
};

打印内容:

!!dlroW olleH

实例操作四:替换字符串指定内容(replace)

public class StringBufferDemo05{
    public static void main(String args[]){
        StringBuffer buf = new StringBuffer() ;    // 声明StringBuffer对象
        buf.append("Hello ").append("World!!") ;        // 向StringBuffer添加内容
        buf.replace(6,11,"偶my耶") ;        // 将world的内容替换
        System.out.println("内容替换之后的结果:" + buf) ;    // 输出内容
    }
};

打印内容:

内容替换之后的结果:Hello 偶my耶!!

实例操作五:字符串截取(substring,delete)

package 字符串处理;
public class StringBufferDemo06{
    public static void main(String args[]){
        StringBuffer buf = new StringBuffer() ;    // 声明StringBuffer对象
        buf.append("Hello ").append("World!!") ;        // 向StringBuffer添加内容
        buf.replace(6,11,"偶my耶") ;        // 将world的内容替换
        String str = buf.substring(6,11) ;    // 截取指定范围的内容
     // String str = buf.delete(6,11).toString() ;// 删除指定范围中的内容
        System.out.println(buf);
        System.out.println("内容替换之后的结果:" + str) ;    // 输出内容
    }
};        

打印结果

Hello 偶my耶!!
内容替换之后的结果:偶my耶!

实例操作六:查找指定内容(indexOf)

package 字符串处理;
public class StringBufferDemo08{
    public static void main(String args[]){
        StringBuffer buf = new StringBuffer() ;    // 声明StringBuffer对象
        buf.append("Hello ").append("World!!") ;        // 向StringBuffer添加内容
        if(buf.indexOf("Hello")==-1){
            System.out.println("没有查找到指定的内容") ;
        }else{    // 不为01表示查找到内容
            System.out.println("可以查找到指定的内容") ;
        }
    }
};

打印内容

可以查找到指定的内容

在StringBuffer中还有许多的函数就不一一介绍了!想要更深去了解可查阅相关资料,

下面介绍一个使用String和StringBuffer来操作字符串的案列

案列之小写金额变大写金额

package com.lh.bean;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class StringUtil {
    private String money;        //转换之前的数字金额
    private String submoneyCN[]={"","拾","佰","仟"};                                    //表示数字位数的数组
    private String numberCNN[]={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};    //大写数字的数组
    private String je="零壹贰叁肆伍陆柒捌玖";        //大写的数字(0-9)
    private String cdw="万仟佰拾亿仟佰拾万仟佰拾元角分";    //金额单位
    public StringUtil(){}        //默认的构造方法
    public void setMoney(String money){
        this.money=money;
    }
    public String getMoney(){
        return convert(this.money);

    }
    /**
     * 转换数字金额为大写金额
     * @return 返回转换后的大写金额
     */
    public String convert(String money){
      String formatCN="";
      int point=money.indexOf(".");                //判断字符串是否包含小数点
      if(point!=-1){
        String money1=money.substring(0,point);    //小数点之前的部分
        String money1_1=(new StringBuffer(money1).reverse()).toString();//字符串倒序
        String money2=money.substring(point+1);    //小数点之后的部分
        if(money2.length()<2){                    //如果小数点后的部分少于两位,用"0"补齐
            if(money2.length()==0)
                money2="00";
            else
                money2+="0";
        }
        else                                    //如果小数点后的位数大于2位,则只前2位
            money2=money.substring(point+1,point+3);
        int len = money1_1.length();            //字符串反转之后,小数点之前的字符位数
        int pos=len-1;
        String sigle="";
        boolean allhavenum=false;
        boolean havenum=false;
        boolean mark=false;                       //设置一个开关变量,若当前数为"0",将该值设为true;不为"0"时设为false
        /**以下代码为读出小数点左面的部分*/
        while(pos>=0){
            sigle=money1_1.substring(pos,pos+1);//截取1位数字,比如数字1234.56,将左侧的字符串反转,值为4321,则截取的值为1

            /**读取“亿单元”的代码。
             * 假设读取10024531042.34。
             * 小数点左面反转后为:24013542001
             * pos的初始值为10
             * mark的初始值为false
             * havenum的初始值为false
             * */
            if(pos>=8&&pos<12){
                if(!sigle.equals("0")){           //如果当前值不为"0"
                    if(!mark){                    //如果当前值的前一位数不为"0"
                        formatCN+=numberCNN[Integer.parseInt(sigle)]+submoneyCN[pos%4];
                    }
                    else{                         //如果当前值不为"0",但该值的前一位数为"0"
                        if(allhavenum){             //如果在当前值之前有不为"0"的数字出现。该条件用来处理用户输入的如:0012.34的数值
                            formatCN+="零";
                        }
                        formatCN+=numberCNN[Integer.parseInt(sigle)]+submoneyCN[pos%4];
                        mark=false;
                    }
                    havenum=true;
                    allhavenum=true;            //变量allhavenum表示小数点左面的数中是否有不为"0"的数字;true表示有,false表示无
                }
                else{                              //如果当前值为"0"
                    mark=true;
                }
                if(pos%4==0&&havenum){             //如果当前数字为该单元的最后一位,并且该单元中有不为"0"的数字出现
                    formatCN+="亿";
                    havenum=false;
                }
            }
            /**读取“万单元”的代码*/
            if(pos>=4&&pos<8){
                if(!sigle.equals("0")){
                    if(!mark)
                        formatCN+=numberCNN[Integer.parseInt(sigle)]+submoneyCN[pos%4];
                    else{
                        if(allhavenum){
                            formatCN+="零";
                        }
                        formatCN+=numberCNN[Integer.parseInt(sigle)]+submoneyCN[pos%4];
                        mark=false;
                    }
                    havenum=true;
                    allhavenum=true;
                }
                else{
                    mark=true;
                }
                if(pos%4==0&&havenum){
                    formatCN+="万";
                    havenum=false;
                }
            }
            /**读取“个、十、百、千”的代码*/
            if(pos>=0&&pos<4){
                if(!sigle.equals("0")){
                    if(!mark)
                        formatCN+=numberCNN[Integer.parseInt(sigle)]+submoneyCN[pos%4];
                    else{
                        if(allhavenum){
                            formatCN+="零";
                        }
                        formatCN+=numberCNN[Integer.parseInt(sigle)]+submoneyCN[pos%4];
                        mark=false;
                    }
                    havenum=true;
                    allhavenum=true;
                }
                else{
                    mark=true;
                }
            }
            pos--;
        }
        /**碰到小数点时的读法*/
        if(allhavenum)        //如:00.34就不能读为:元3角4分.变量allhavenum表示小数点左面的内容中是否有数字出现
            formatCN+="元";
        else                 //如果小数点左面的部分都为0如:00.34应读为:零元3角4分
            formatCN="零元";
        /**以下代码为读出小数点右面的部分 */
        if(money2.equals("00"))
            formatCN+="整";
        else{
            /**读出角,如120.34读为:1佰2拾元零3角4分;123.04读为:1佰2拾3元零4分*/
            if(money2.startsWith("0")||(allhavenum&&money1.endsWith("0"))){
                formatCN+="零";
            }
            if(!money2.startsWith("0")){
                formatCN+=numberCNN[Integer.parseInt(money2.substring(0,1))]+"角";
            }
            //读出分,如:12.30读1拾2元3角零分
            formatCN+=numberCNN[Integer.parseInt(money2.substring(1))]+"分";
        }
      }
      else{
          formatCN="输入的格式不正确!格式:888.00";
      }
      return formatCN;
    }
    public static void main(String[] args) throws IOException {
        System.out.println("输入要转换的金钱:");
        BufferedReader  br=new BufferedReader(new InputStreamReader(System.in));
        String money = br.readLine();
      StringUtil SU=  new StringUtil();
        System.out.println(SU.convert(money));
    }
}

时间: 2024-10-10 09:49:01

Java基础篇--字符串处理(StringBuffer)的相关文章

JAVA基础篇—String和StringBuffer

区别: (1)String类对象为不可变对象,一旦你修改了String对象的值,隐性重新创建了一个新的对象,释放原String对象,StringBuffer类对象为可修改对象,可以通过append()方法来修改值 (2)String类对象的性能远不如StringBuffer类. String s=new "hallo";创建了两个对象,字符串在常量池中,s指向String字符串对象,String字符串对象指向 常量池中字符串 小例: String str=" zxcvbnm

java基础篇---I/O技术(三)

接上一篇java基础篇---I/O技术(二) Java对象的序列化和反序列化 什么叫对象的序列化和反序列化 要想完成对象的输入或输出,还必须依靠对象输出流(ObjectOutputStream)和对象输入流(ObjectInputStream).使用对象输出流输出序列化对象的步骤,有时也成序列化,而使用对象输入流读入对象的过程,有时也称为反序列化 一个对象产生之后实际上是在内存中为其开辟了一个存储空间,方便存储信息. 对象序列化就是把一个对象变成二进制的数据流的一个方法,通过对象序列化可以反驳的

java基础篇IO流的规律

前两篇降了IO流中的字节流和字符流复制的例子,今天来总结一下IO流的规律 掌握好IO流的规律,再开发中会很好用 下面来总结一下: 1,明确源和目的 源:输入流 InputStream 和Reader 目的:输出流 OutputStream 和Writer 2,操作的数据是否是纯文本. 是:使用字符流 不是:使用字节流 3,当体系明确后,在明确要使用哪个具体的对象,通过设备来进行区分 源设备: 内存,硬盘,键盘 目的设备: 内存,硬盘,控制台 这里的源就是你想进行的操作,比如说你想从c盘复制一个文

Java 基础篇之反射

Java 基础篇之反射 反射# 使用反射获取程序运行时的对象和类的真实信息. 获取 Class 对象# 每个类被加载之后,系统会为该类生成一个对应的 Class 对象,通过该 Class 对象可以访问到 JVM 中的这个类. 使用 Class 类的 forName(String clazzName) 静态方法.字符串参数的值是某个类的全限定类名,必须包含完整的包名 调用某个类的 class 属性 调用某个对象的 getClass() 方法.该方法是 java.lang.Object 类中的一个方

黑马程序员——Java基础篇之对象归要

1.static关键字 1.1.static可以修饰成员变量,成员方法,还有类(其中这里的类是内部类) 1.2.static修饰的部分会随着类的加载而加载: 加载过程:当JVM执行static修饰的代码时,会在内存的共享区给static部分开辟一个空间,供该类持有,static部分不是某个对象的部分,而是该类共有的,所以当一个函数会被多个对象调用时,最好定义成static,这样比较节省空间. 1.3.静态方法只能访问静态成员 原因:如果静态方法中调用了非静态的变量,那么由于静态方法是随着类的加载

Java基础篇Socket网络编程中的应用实例

说到java网络通讯章节的内容,刚入门的学员可能会感到比较头疼,应为Socket通信中一定会伴随有IO流的操作,当然对IO流比较熟练的哥们会觉得这是比较好玩的一章,因为一切都在他们的掌握之中,这样操作起来就显得非常得心应手,但是对于IO本来就不是多熟悉的哥们来说就有一定的困难了,在搞清楚IO流操作机制的同时还必须会应用到Socket通信中去,否则会对得到的结果感到非常郁闷和懊恼,下面就和大家一起分享一下自己遇到一点小麻烦后的感触以及给出的解决办法. 要求:客户端通过Socket通信技术上传本地一

Java基础篇(02):特殊的String类,和相关扩展API

本文源码:GitHub·点这里 || GitEE·点这里 一.String类简介 1.基础简介 字符串是一个特殊的数据类型,属于引用类型.String类在Java中使用关键字final修饰,所以这个类是不可以继承扩展和修改它的方法.String类用处极广泛,在对String对象进行初始化时,和基本类型的包装器类型一样,可以不使用new关键字构造对象.(是真的妖娆...) 2.类构造和方法 String类结构 特点:final关键字修饰,实现Serializable序列化接口,Comparable

Java面试题(Java基础篇)

Java 基础 1.JDK 和 JRE 有什么区别? JDK:Java Development Kit 的简称,java 开发工具包,提供了 java 的开发环境和运行环境. JRE:Java Runtime Environment 的简称,java 运行环境,为 java 的运行提供了所需环境. 具体来说 JDK 其实包含了 JRE,同时还包含了编译 java 源码的编译器 javac,还包含了很多 java 程序调试和分析的工具.简单来说:如果你需要运行 java 程序,只需安装 JRE 就

再回首,Java温故知新(八):Java基础之字符串

字符串是Java中使用频率最高的类,但是它却不属于基本类型,而是预定义了String类来表示.从String类的源码可以看到,String是基于char[]实现的,而且Java中的String是不可变字符串,即String初始化之后不可更改. 估计到这就有人问了,字符串不是都可以改的吗?下面两种不都是更改吗? String a = "123"; a = "1234"; a = a + "F"; 这里需要指出的是,字符串在内存中的存放分为两部分,首