java中处理中文输入,不需要用到的类是
Java把不同类型的输入、输出抽象为流stream,分为输入流和输出流,用统一的接口来表示
Java开发环境中提供了包java.io,其中包括一系列的类来实现输入/输出处理
InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先
public abstract class InputStream implements Closeable
public abstract class OutputStream implements Closeable, Flushable
具体子类: ByteArrayInputStream, FileInputStream, FilterInputStream, ObjectInputStream,
PipedInputStream, SequenceInputStream, StringBufferInputStream
InputStream
InputStream类是一个抽象类,方法包括:
int read()
int read(byte[])
int read(byte[],int,int)
void close()关闭流
int available()报告流中直接可读的字节数
skip(long)跳过流中指定的字节
OutputStream
OutputStream也是一个抽象类。它的主要方法包括:
void write(int)
void write(byte[])
void write(byte[],int,int)
其中第一个方法的int型的参数对应要写入的字节,后两个方法的参数与InputStream类似。
void close() 关闭输出流
void flush() 强行将写入缓冲区中剩余的数据写入
File file = new File(“d:\\FileTest.java”);
if (file.exists()) {
try (InputStream is = new FileInputStream(file);) {
byte[] buffer = new byte[8192];
int len = is.read(buffer);
while (len 0) {
System.out.write(buffer, 0, len);
len = is.read(buffer);
}
} catch (Exception e) {
e.printStackTrace();
}
}
InputSream 和 OutputStream 中定义了 read() 和 write() 方法,它们被派生流类重载。字节流是字节序
列,它与外部设备中的字节存在着一一对应的关系,不存在字符的转换,被读写字节的个数与外部设备中的字节个数是相同的
基本输入输出方法
System类是Java语言中一个功能强大、非常有用的类,它提供了标准输入/输出及运行时的系统信息
System类不能创建对象,也就是说,System类的所有属性和方法都是静态的,引用时要以System 作为前缀
System.in与System.out是System类的两个静态属性,分别对应了系统的标准输入/输出流 System类管理标准输入输出流和错误流
System.out:把输出送到缺省的显示(通常是显示器),是PrintStream的对象
System.in:从标准输入获取输入(通常是键盘),是InputStream的对象
System.err:把错误信息送到缺省的显示,是PrintStream的对象
同时使用System.out和System.err输出信息不能保证显示顺序就是执行顺序,为了避免这种情况在测试代码执行中经常使用System.err输出
FileInputStream、FileOutputStream 顺序读取文件
PipedInputStream、PipedOutputStream 管道
ByteArrayInputStream、ByteArrayOutputStream 内存读写
FilterInputStream、FilterOutputStream 过滤流(有多线程同步)
DataInputStream、DataOutputStream 对数据类型读写,有多线程同步
BufferedInputStream、BufferedOutputStream 缓冲类型读写
1 、使用字节流进行文件的单字节复制
FileInputStream是InputStream的子类,FileInputStream属于节点流,用于按字节读取文件内容
FileOutputStream是OutputStream的子类,FileOutputStream属于节点流,用于按字节输出数据到文件中
//FileInputStream中read方法的定义
/**
从指定的输入流中按字节读取数据,如果读到流的末尾则返回-1,否则返回读取到的数据。如果文件不存
在则异常FileNotFoundException【IOException的子类】
*/
public int read() throws IOException {
return read0();
}
//FileOutputStream中write方法的定义
//属性,用于表示是否进行文件的追加操作而不是覆盖操作
private final boolean append;
//构造器方法的定义,其中name是文件名称,默认采用覆盖操作
public FileOutputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null, false);
}
//按照字节执行写出int数据,自动会去除多余的字节。如果文件不存在则自动创建新文件,如果
文件已经存在则按照append的值决定采用的是追加操作还是覆盖操作
public void write(int b) throws IOException {
write(b, append);
}
private native void write(int b, boolean append) throws IOException; //
由VM采用对等类的方式提供实现
public class Test1 {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream(“c:/面向对象文档.txt”);
OutputStream os = new FileOutputStream(“test.txt”);) {
int kk;
while ((kk = is.read()) != -1) {
os.write(kk);
}
}
}
}
2 、读取 A.java 文件并在控制台上显示
如何使用控制台输出 : System.out 字节流
分析:使用字节流从 A.java 中一个字节一个字节的读取内容,然后再使用 System.out.print 方法输出即可
注意:读取操作返回的 int 的取值范围为 0-255 ,则表示这里不会有符号位,所以 is.read()==-1 不是只适合于文本文件
File ff = new File(“T1.java”);
if (ff.exists()) {// 如果文件存在则进行拷贝操作,否则提示文件不存在
InputStream is = new FileInputStream(ff);
OutputStream os = new FileOutputStream(“t1.bak”);
while (true) {
int kk = is.read();// 返回值应该是0-255,如果返回-1表示流已经结束
if (kk 0)break;
os.write(kk);
}
is.close();
os.close();
} else
System.out.println(“T1.java文件不存在”);
InputStream基本输入类
InputStream类是基本的输入类。它定义了所有输入流所需的方法。
public abstract int read() throws IOException读取一个字节并以整数的形式返回,0-255。如果 返回-1已到输入流的末尾。
public int read(byte b[]) throws IOException读取一系列字节并存储到一个数组,返回实际读取的 字节数。如果已经读到输入流的末尾则返回-1
public void close() throws IOException 关闭输入流并释放资源
public int read(byte b[],int offset,int length) throws IOException功能为从输入流中读数据。这一 方法有几种重载形式,可以读一个字节或一组字节。当遇到文件尾时,返回-1。最后一种形式中的 offset是指把结果放在b[]中从第offset个字节开始的空间,length为长度
public long skip (long n) throws IOEnception 从输入流跳过几个字节。返回值为实际跳过的字节数
OutputStream基本输出类
三个重载形式都是用来向输出流写数据的
public abstract void write(int b)向输入流写入一个字节数据,该字节为参数的低8位。
public void write(byte b[],int offset,int length)将一个字节类型的数组中的从指定位置offset开始 的length个字节写入到输出流
public void close( ) 关闭输出流,释放资源
public void write(byte b[])将一个字节类型的数组中的数据写入到输出流
public void flush() 清除缓冲区,将缓冲区内尚未写出的数据全部输出
字符流
在顶层有 Reader 和 Writer 两个抽象类。 Reader 和 Writer 中定义了 read() 和 write() 方法,它们被派生流类重载
Reader 抽象类的定义
public abstract class Reader implements Readable, Closeable {
//BIO,读取一个有效的字符,返回值为0到65535的整数,如果到达流的末尾则返回-1
public int read() throws IOException
//BIO,读取字符存储到char数组中,返回读取的字符个数,流结束则返回-1
public int read(char cbuf[]) throws IOException
//关闭流,同时释放资源
abstract public void close() throws IOException;
Writer 抽象类的定义
public abstract class Writer implements Appendable, Closeable, Flushable {
//写出一个字符到字符流,要写的字符包含在给定整数值的16个低位;16个高位被忽略。
public void write(int c) throws IOException
//将字符数组中的指定部分内容压入到字符流,从off开始共len个字符
abstract public void write(char cbuf[], int off, int len) throws
IOException;
/关闭流,同时释放资源
abstract public void close() throws IOException;
相关的子类
InputStreamReader、OutputStreamWriter桥接流,用于自动实现字节流和字符流的转换
FileReader、FileWriter文件流,用于实现针对文本文件的读写操作
CharArrayReader、CharArrayWriter内存流,用于实现针对char数组的读写操作
PipedReader、PipedWriter管道流,用于线程之间的通讯
FilterReader、FilterWriter过滤流的父类
BufferedReader、BufferedWriter缓存流,用于在流中添加缓冲区
StringReader、StringWriter内存流,用于实现针对字符串的读写操作
使用字符流实现 txt 文件的读取显示【其中包含中文】
编写一个程序,读取文件 test.txt 的内容并在控制台输出。如果源文件不存在,则显示相应的错误信息。
字符流 Reader
int read()读取一个字符并以整数的形式返回0-65535,如果返回-1则已到输入流末尾
int read(char[] cbuf)读取一系列字符并存储到一个数组中,返回实际读取的字符数,如果读到输入流末尾则返回-1
void close()关闭输入流并释放内存资源
int read(char[] cbuf, int off, int len) 读取len个字符并存储到一个数组中,从off位置开始,返回实
际读取的字符数,如果读取到输入流末尾则返回-1
long skip(long n)跳过n个字符不读,返回实际跳过的字节数
字符流 Writer
void write(int c) 将字符(int数组的低8位)压入到字符流中
void write(char[] cbuf, int off, int len)将字符数组中的指定部分内容压入到字符流中,从off开始共len个字符
void write(String str) 将字符串中的内容压入到字符流中
void close() 关闭流并释放所占用的资源
void write(String str, int off, int len) 将字符串中的指定部分内容压入到字符流中,从下标off开始共len个字符
void flush()刷新缓冲区,将缓冲区中的数据全部送出到目标地,然后清空缓冲区
void write(char[] cbuf) 将字符数组中的所有数据压入到字符流中
一般来说:一次读写一个字符效率太低,可以引入 char[] 数组提高执行效率
小结
在学些BIO时记忆父类的方法,区分子类的实现不同
InputStream中的方法 read(byte[]):int; Reader中方法read(char[]):int 如果到达流末尾 则-1
OutputStream中的方法 write(byte[],0,len):void;Writer中的方法 write(char[],0,len)/write(String)
一般在使用中,如果读取数据使用字节流,则写出数据采用的也是字节流;不建议混用,除非引入 桥接流
文件流
FileInputStream(“file-name”) FileInputStream(File) FileNotFoundException
FileReader(“file-name”) FileReader(File) FileNotFoundException
FileOutputStream(“file-name”) FileOutputStream(“file-name”,true) 默认文件覆盖,如果 参数true表示追加
FileWriter(“file-name”) FileWriter(“file-name”,true)
一般不使用单字节或者单字符的操作方法,使用数组
注意:try(){}是推荐写法,否则应该使用try{}finally{}结构保证流的关闭
针对二进制文件不建议使用字符流,建议使用字节流进行操作,否则有可能拷贝文件出现问题:
如果针对文本文件则建议使用字符流,因为编码使用比较方便
文章知识点与官方知识档案匹配
Java技能树类和接口类和面向对象
89124 人正在系统学习中
点击阅读全文
打开CSDN,阅读体验更佳
java用于输入输出流的类_java输入输出流_lsgn的博客
java输入输出流 java IO综述 在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable。 Java I/O主要包括如下几个层次,包含三个部分: …
java常见输入输出类型_3分钟秒懂大数据的博客
输入:每行输入一个数,连续输入n行,遇到0结束输入,然后输出结果。 importjava.util.ArrayList; importjava.util.Scanner; publicclassTest4{ publicstaticvoidmain(String[] args){ Scannersc=newScanner(System.in); …
25、JAVA进阶——输入输出流
一、认识Java的流 二、使用字节流读写文本文件 1、使用字节流类FileInputStream读文本文件 2、使用字节流类FileOutputStream写文本文件 三、使用字符流读写文本文件 1、使用字符流类BufferedReader和FileReader读文本文件 2、使用字符流类BufferedWrite和FileWrite写文本文件 四、读写二进制文件 1、 使用字节流读二进制文件 2、 使用字节流写二进制文件 五、序列化和反序列化 1、认识序列化 2、序列化保存对
继续访问
java 输入类_java 输入输出类
java中输入输出类如果理不清思路的话就会很混乱!一.File类提供与操作系统无关的文件操作!可以查看api文档了解它的方法二.输出操作:1.把信息输出到屏幕上最简单的操作就是使用标准输出:System.out.println();下面讨论一下流方式的输出,与之相关的类如下OutputStreamWriter:它提供字符流到字节流的转换,换句话说它写入字符数据然后按照指定字符集转换为字节数据Buf…
继续访问
JAVA的输入输出_努力的地球人的博客_java输出
Java的输入 Scanner类 为了使用scanner类,我们首先需要导入java.util.Scanner包 import java.util.Scanner; 1 创建scanner对象,从用户获取输入 //创建scanner对象 Scanner str=new Scanner(System.in); //接受用户输入 int w=str.nextIn…
java输入输出_java中输入输出总结_weixin_39609407的博客
标准输入studin,对象是键盘。 标准输出stdout,对象是屏幕。 标准错误输出stderr,对象也是屏幕。 二、java.io包中的数据流和文件类 字节流:从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。
Java——不同数据类型的输入输出方式与转化方式
java 中不同数据类型的 输入方法 输出格式 与 转化方式
继续访问
Java文本输出常用类
package com.ss.extract; import java.io.*; import org.apache.log4j.Logger; /** * 结果输出类 * @author Shu */ public class ResultOutput { private …
继续访问
1.Java基础入门 -(2)输入输出类_菜鸟的小虫子的博客
一. Java Scanner 类 java.util.Scanner是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入。 Scanner 对象的基本语法: Scanner in= new Scanner(System.in); 示例1: 输入结果: …
java的输入输出流类型_理解JAVA输入输出流_天接云涛的博客
1、字节流抽象类 InputStream输入流 OutputStream输出流 2、字符流抽象类 Reader 输入字符流 Writer 输出字符流 四、JAVA中流体系架构 有一些对流进行操作的基本的方法,我们以文件输入输出流进行说明: …
java的输出类
System.out这个类是PrintStream类,定义如下 public class PrintStream extends FilterOutputStream PrintStream都是用print的相关函数输出到控制台上。print的实现都是用write(String s)实现。 而,PrintWriter这个输出类,也同样实现输出:PrintWriter extends …
继续访问
Java中的各种输出形式
一、Java中的各种输出形式: package cn.jl.lwj; public class Demo00 { public static void main(String[] args) { //标识符定义 区分大小写 int a = 5; int A = 6; //区分大小写 int Class = 6; int age = 5; //定义常量 final int AGE_MAX = 30;…
继续访问
java中的BIO基础-3
java中的io基础
继续访问
Java学习-IO流进阶
缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。
继续访问
IO进阶之高级IO
高级IO
继续访问
Java中的IO进阶操作
Java中的IO进阶操作 一、序列化和反序列化 常用于多台服务器之间进行java对象的数据传递。 1.概念 序列化 是指程序中准备好的Java对象,永久的保存在磁盘中,这个过程其实是一个out的动作。 ObjectOutputStream:通过在流中使用文件可以实现对象的持久存储。 创建对象:ObjectOutputStream(OutputStream out) 常用方法: void writeObject(Object obj):将指定的对象写入ObjectOutputStream 反序列化 是指把
继续访问
Java IO最详解,欢迎提出意见
Java IO 详解 初学java,一直搞不懂java里面的io关系,在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术,所以自己来整理一下,有错的话请指正,也希望大家提出宝贵意见。 首先看个图:(如果你也是初学者,我相信你看了真个人都不好了,想想java设计者真是煞费苦心啊!) 这是java io 比较基本的一些处理流,除此之外我们还会…
继续访问
java输出类型_java中各种类型的输入输出
import java.lang.Exception;import java.lang.String;import java.util.Scanner;public class test {public static void main(String[] args) {Scanner s = new Scanner(System.in);char ch;System.out.print(“Char…
继续访问
java中输入流的类_Java中的输入/输出流类
Java中包含的输入/输出流类 1.java.io包中的接口 (1)处理字节流的有DataInput接口和DataOutput接口,RandomAccessFile同时实现了这两个接口; (2)处理对象流的有ObjectInput接口和ObjectOutput接口,ObjectInputStream类实现了ObjectInput接口,ObjectOutputStream类实现了ObjectOutp…
继续访问
使用java的输入/输出类
1. 什么是IO? I:input 输入 通常做读取操作(将不同数据源的数据读入到内存中,也叫读取流) O:output 输出通常做写入操作(将内存中的数据写入到不同的数据源,也叫写入流) 2. 理解流的概念。 想像一下自来水公司要把水输到用户家里,应该先把自来水公司到用户家里的连接水管建好,再将水输出去。管道里输送的是水,但IO里输送的是字节。 u流是…
继续访问
Java中的输入/输出流类
Java中包含的输入/输出流类 1.java.io包中的接口 (1)处理字节流的有DataInput接口和DataOutput接口,RandomAccessFile同时实现了这两个接口; (2)处理对象流的有ObjectInput接口和ObjectOutput接口,ObjectInputStream类实现了ObjectInput接口,ObjectOutputStream类实现了ObjectOutp…
继续访问
最新发布 【Java基础】自定义一个格式输出类
在项目实际开发中,后端接口都按照一定的格式输出给前端调用,在返回中包括状态码和接口的主要作用等注释,再包含实际的data。
继续访问
IO流(进阶提高)
本篇文章继上一篇IO流(小试牛刀)继续更新JavaIO流的知识。 常见IO流的结构图解: 回顾一下IO的基本接口知识: ————————————————————我是不起眼的分割线———————————————————————— IO的序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程;Java反序列化是指把字节序列恢复为Java对象的过…
继续访问
java进阶8——IO流
File类 File概述 File文件和目录路径名的抽象表示形式。即,Java中把文件或者目录(文件夹)都封装成File对象。也就是说如果我们要去操作硬盘上的文件,或者文件夹只要找到File这个类即可。 File类的构造函数 File(String pathname); // 将一个字符串路径封装成File对象 File(String parent,String child);…
继续访问
Java IO流进阶之常用流(一)
请多参考JDK文档:或 转换流——OutputStreamWriter类和InputStreamReader类 字节与字符的转换流: OutputStreamWriter:是Writer类的子类,将输出的字符流变为字节流。 InputStreamRe…
继续访问
详解JAVA I/O之二——java.io层次结构
br /java I/O(Input/Output)学习——java.io层次结构文章分类:Java编程stream代表的是任何有能力产出数据的数据源,或是任何有能力接收数据的接收源。在Java的IO中,所有的stream(包括Inputstream和Out stream)都包括两种类型: br /(1)字节流 br /br / 表示以字节为单位从stream中读取或往stream中写入信息,即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据,
java 设计模式用了哪些
在JDK(Java Development Kit)类库中,开发人员使用了大量设计模式,正因为如此,我们可以在不修改JDK源码的前提下开发出自己的应用软件,研究JDK类库中的模式实例也不失为学习如何使用设计模式的一个好方式。
创建型模式:
(1) 抽象工厂模式(Abstract Factory)
• Java.util.Calendar#getInstance()
• java.util.Arrays#asList()
• java.util.ResourceBundle#getBundle()
• java.NET.URL#openConnection()
• java.sql.DriverManager#getConnection()
• java.sql.Connection#createStatement()
• java.sql.Statement#executeQuery()
• java.text.NumberFormat#getInstance()
• java.lang.management.ManagementFactory (所有getXXX()方法)
• java.nio.charset.Charset#forName()
• javax.xml.parsers.DocumentBuilderFactory#newInstance()
• javax.xml.transform.TransformerFactory#newInstance()
• javax.xml.xpath.XPathFactory#newInstance()
(2) 建造者模式(Builder)
• java.lang.StringBuilder#append()
• java.lang.StringBuffer#append()
• java.nio.ByteBuffer#put() (CharBuffer, ShortBuffer, IntBuffer,LongBuffer, FloatBuffer 和DoubleBuffer与之类似)
• javax.swing.GroupLayout.Group#addComponent()
• java.sql.PreparedStatement
• java.lang.Appendable的所有实现类
(3) 工厂方法模式(Factory Method)
• java.lang.Object#toString() (在其子类中可以覆盖该方法)
• java.lang.Class#newInstance()
• java.lang.Integer#valueOf(String) (Boolean, Byte, Character,Short, Long, Float 和 Double与之类似)
• java.lang.Class#forName()
• java.lang.reflect.Array#newInstance()
• java.lang.reflect.Constructor#newInstance()
(4) 原型模式(Prototype)
• java.lang.Object#clone() (支持浅克隆的类必须实现java.lang.Cloneable接口)
(5) 单例模式 (Singleton)
• java.lang.Runtime#getRuntime()
• java.awt.Desktop#getDesktop()
结构型模式:
(1) 适配器模式(Adapter)
•java.util.Arrays#asList()
•javax.swing.JTable(TableModel)
•java.io.InputStreamReader(InputStream)
•java.io.OutputStreamWriter(OutputStream)
•javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
•javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()
(2) 桥接模式(Bridge)
• AWT (提供了抽象层映射于实际的操作系统)
•JDBC
(3) 组合模式(Composite)
•javax.swing.JComponent#add(Component)
•java.awt.Container#add(Component)
•java.util.Map#putAll(Map)
•java.util.List#addAll(Collection)
•java.util.Set#addAll(Collection)
(4) 装饰模式(Decorator)
•java.io.BufferedInputStream(InputStream)
•java.io.DataInputStream(InputStream)
•java.io.BufferedOutputStream(OutputStream)
•java.util.zip.ZipOutputStream(OutputStream)
•java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
(5) 外观模式(Facade)
•java.lang.Class
•javax.faces.webapp.FacesServlet
(6) 享元模式(Flyweight)
•java.lang.Integer#valueOf(int)
•java.lang.Boolean#valueOf(boolean)
• java.lang.Byte#valueOf(byte)
•java.lang.Character#valueOf(char)
(7) 代理模式(Proxy)
• java.lang.reflect.Proxy
•java.rmi.*
行为型模式:
(1) 职责链模式(Chain of Responsibility)
•java.util.logging.Logger#log()
•javax.servlet.Filter#doFilter()
(2) 命令模式(Command)
• java.lang.Runnable
• javax.swing.Action
(3) 解释器模式(Interpreter)
• java.util.Pattern
• java.text.Normalizer
• java.text.Format
• javax.el.ELResolver
(4) 迭代器模式(Iterator)
• java.util.Iterator
• java.util.Enumeration
(5) 中介者模式(Mediator)
• java.util.Timer (所有scheduleXXX()方法)
• java.util.concurrent.Executor#execute()
• java.util.concurrent.ExecutorService (invokeXXX()和submit()方法)
• java.util.concurrent.ScheduledExecutorService (所有scheduleXXX()方法)
•java.lang.reflect.Method#invoke()
(6) 备忘录模式(Memento)
•java.util.Date
•java.io.Serializable
•javax.faces.component.StateHolder
(7) 观察者模式(Observer)
•java.util.Observer/java.util.Observable
•java.util.EventListener (所有子类)
•javax.servlet.http.HttpSessionBindingListener
•javax.servlet.http.HttpSessionAttributeListener
•javax.faces.event.PhaseListener
(8) 状态模式(State)
•java.util.Iterator
•javax.faces.lifecycle.LifeCycle#execute()
(9) 策略模式(Strategy)
• java.util.Comparator#compare()
• javax.servlet.http.HttpServlet
• javax.servlet.Filter#doFilter()
(10) 模板方法模式(Template Method)
•java.io.InputStream, java.io.OutputStream, java.io.Reader和java.io.Writer的所有非抽象方法
•java.util.AbstractList, java.util.AbstractSet和java.util.AbstractMap的所有非抽象方法
•javax.servlet.http.HttpServlet#doXXX()
(11) 访问者模式(Visitor)
•javax.lang.model.element.AnnotationValue和AnnotationValueVisitor
•javax.lang.model.element.Element和ElementVisitor
•javax.lang.model.type.TypeMirror和TypeVisitor
Java中StringBuffer类append方法的使用
参数将被转换成字符串,就好象使用了 String.valueOf 方法一样。然后,将所得字符串中的字符追加到此序列。 参数:obj – 一个 Object。 返回:此对象的一个引用。 另请参见:String.valueOf(java.lang.Object), append(java.lang.String)appendpublic StringBuffer append(String str) 将指定的字符串追加到此字符序列。按顺序追加 String 变量中的字符,使此序列增加该变量的长度。如果 str 为 null,则追加 4 个字符 “null”。 假设此字符序列的长度在执行 append 方法前为 n。如果 k 小于 n,则新字符序列中索引 k 处的字符等于原序列中索引 k 处的字符;否则它等于参数 str 中索引 k-n 处的字符。 参数:str – 一个 string。 返回:此对象的一个引用。appendpublic StringBuffer append(StringBuffer sb) 将指定的 StringBuffer 追加到此序列中。按顺序将 StringBuffer 参数中的字符追加到此 StringBuffer 中,并使 StringBuffer 在长度上增加该参数的长度。如果 sb 为 null,则将 4 个 “null” 字符追加到此 StringBuffer 中。 在执行 append 方法前,让 StringBuffer 中包含的原有字符序列的长度为 n。如果 k 小于 n,则新字符序列中索引 k 处的字符等于原有字符序列中索引 k 处的字符;否则它等于参数 sb 中索引 k-n 处的字符。 该方法在 this(目标)对象上实现同步,但不在源(sb)上实现同步。 参数:sb – 要追加的 StringBuffer。 返回:该对象的一个引用。 从以下版本开始:1.4 appendpublic StringBuffer append(CharSequence s) 将指定的 CharSequence 追加到该序列。按顺序将 CharSequence 参数中的字符追加到该序列中,使该序列增加该参数的长度。 该方法的结果与调用 this.append(s, 0, s.length()) 的结果完全相同; 该方法在 this(目标)对象上实现同步,但不在源(s)上实现同步。 如果s 为 null,则追加 4 个 “null” 字符。 指定者:接口Appendable 中的 append参数:s – 要追加的 CharSequence。 返回:此对象的一个引用。 从以下版本开始:1.5 appendpublic StringBuffer append(CharSequence s, int start, int end) 将指定 CharSequence 的子序列追加到此序列。按顺序追加参数 s 中的字符,即从索引 start 开始到索引 end 结束的此序列的内容。此序列增加的长度为 end – start。 假设此字符序列的长度在执行 append 方法前为 n。如果 k 小于 n,则新字符序列中索引 k 处的字符等于原序列中索引 k 处的字符;否则它等于参数 s 中索引 k+start-n 处的字符。 如果s 为 null,则认为 s 参数包含 4 个字符 “null”,并以此为根据追加字符。 指定者:接口Appendable 中的 append参数:s – 要追加的序列。 start – 要追加的子序列的起始索引。 end – 要追加的子序列的结束索引。 返回:此对象的一个引用。 抛出:IndexOutOfBoundsException 如果 start 或 end 为负;或者 start 大于 end;或者 end 大于 s.length() 从以下版本开始:1.5 appendpublic StringBuffer append(char[] str) 将char 数组参数的字符串表示形式追加到此序列。按顺序将数组参数中的字符追加到此序列的内容中。此字符将增加该参数的长度。 该方法的总体效果与以下操作过程的效果相同:先使用 String.valueOf(char[]) 方法将参数转换为字符串,然后将所得字符串的字符追加到此字符序列。 参数:str – 要追加的字符。 返回:此对象的一个引用。appendpublic StringBuffer append(char[] str, int offset, int len) 将char 数组参数的子数组的字符串表示形式追加到此序列。将char 数组 str 中的字符按顺序追加到此序列的内容中,从索引 offset 开始。此字符的长度将增加 len。 该方法的最终效果与以下操作过程的效果相同:先使用 String.valueOf(char[]) 方法将参数转换为字符串,然后将所得字符串的字符追加到此字符序列。 参数:str – 要追加的字符。 offset – 要追加的第一个 char 的索引。 len – 要追加的 char 的数量。 返回:此对象的一个引用。appendpublic StringBuffer append(boolean b) 将boolean 参数的字符串表示形式追加到序列。参数将被转换成字符串,就好象使用了 String.valueOf 方法一样。然后,将所得字符串中的字符追加到此序列。 参数:b – 一个 boolean 值。 返回:此对象的一个引用。 另请参见:String.valueOf(boolean), append(java.lang.String)appendpublic StringBuffer append(char c) 将char 参数的字符串表示形式追加到此序列。参数将被追加到此序列。此序列的长度将增加 1。 该方法的最终效果与以下操作过程的效果相同:先使用 String.valueOf(char[]) 方法将参数转换为字符串,然后将所得字符串的字符追加到此字符序列。 指定者:接口Appendable 中的 append参数:c – 一个 char 值。 返回:此对象的一个引用。appendpublic StringBuffer append(int i) 将int 参数的字符串表示形式追加到此序列。参数将被转换成字符串,就好象使用了 String.valueOf 方法一样。然后,将所得字符串中的字符追加到此序列。 参数:i – 一个 int 值。 返回:此对象的一个引用。 另请参见:String.valueOf(int), append(java.lang.String)