IO
IO流
1.概述
Input Output
>IO流用来处理设备之间的数据传输
>Java对数据的操作是通过流的方式
>Java用于操作流的对象都在IO包中
>流按操作数据分为两种：字节流与字符流
>流按流向分为：输入流，输出流
>字节流的抽象基类InputStrea,OutputStream
>字符流的抽象基类Reader,Writer
>注：由这四个类派生出来的子类名称都是以其父类名作为子类明的后缀
1、IO流(FileWriter)
public static void main(String args[]) throws Exception{
//创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件
//而且该文件会被创建到指定目录下，如果该目录下已有同名的文件，将被覆盖。
//其实该步就是明确数据要存放的目的地
FileWriter fw=new FileWriter("g:/java/java基础1/demo.txt",true);//为true表示不覆盖已有文件，并且续写，不写true直接覆盖
//调用writer方法，将字符串写入到流中，会产生异常
fw.write("abc");
fw.write("def");
//刷新该流的缓冲。将数据刷新到文件中
fw.flush();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲的数据。
fw.close();
}
1.1.IO异常处理方式和文件的续写
FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
1.2.换行
windows中，换行是 \r\n
linux 是\n
2、IO流(FileReader)
public static void main(String args[]) throws Exception{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的，如果不存在，会发生异常 FileNotFoundException
FileReader fr = new FileReader("Demo.txt");
//read()方法，读取一个字符，每次读一个，并且会接着上一个往下读，若达到末尾，则返回-1
int ch = 0;
while( (ch=fr.read())!=-1){
System.out.print((char)ch);
}
}
文本文件读取方式二
int read(char[] cbuf) 将字符读入数组。
public static void main(String args[]) throws Exception{
FileReader fr = new FileReader("Demo.txt");
//定义一个字符串数组，用于存储到的字符
//该 read(char[])返回的是读到的字符个数
char[] buf = new char[1024];
int num = 0;
while((num = fr.read(buf))!=-1){
System.out.println(num+"..."+new String(buf,0,num));
}
}
2.2IO流(拷贝文本文件)
import java.io.*;
class Demo{
public static void main(String args[]) throws Exception{
copy_2();
}
public static void copy_1() throws Exception{
//创建目的地
FileWriter fw = new FileWriter("Demo_copy.java");
//与已有文件关联
FileReader fr = new FileReader("Demo.java");
int ch = 0;
while((ch = fr.read())!=-1){
fw.write(ch);
}
fw.close();
fr.close();
}
public static void copy_2() throws IOException{
//创建目的地
FileWriter fw = null;
//与已有文件关联
FileReader fr = null;
try{
fw = new FileWriter("Demo_copy.java");
fr = new FileReader("Demo.java");
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1){
fw.write(buf,0,len);
}
}catch(IOException e){
throw new RuntimeException("读写失败");
}finally{
if(fr!=null)
try{
fr.close();
}catch(IOException e){
}
if(fw!=null)
try{
fw.close();
}catch(IOException e){
}
}
}
}
3.字符流的缓冲区(BufferedReader)
>缓冲区的出现提高了对数据的读写效率
>对应类BufferdWriter和BufferdReader
>缓冲区要结合流才可以使用
>在流的基础上对流的功能进行了增强
例：
import java.io.*;
class Demo{
public static void main(String args[]) throws IOException{
BufferedWriter bw = null;
BufferedReader br = null;
String ch = null;
FileReader reader = reader = new FileReader("dome.txt");
FileWriter writer = writer = new FileWriter("Copydome.txt");
// 为了提高字符写入效率，加入了缓冲技术
// 只要将需要被提高的流对象作为参数传递给缓冲区的构造函数即可,不用关闭流，只关闭缓存就行
br = new BufferedReader(reader);
bw = new BufferedWriter(writer);
// 当没有数据时返回null
// 无论是读一行还是读多个字符都是使用read()一个一个的读
while ((ch = br.readLine()) != null) {
bw.write(ch);
bw.newLine(); // 写入一个行分隔符。 跨平台
// 缓冲只读取换行符之前的数据，不读换行符 bw.newLine();
// 只要用到缓冲区就要记得刷新
bw.flush();
}
if (bw != null) {
bw.close();
}
if (br != null) {
br.close();
}
}
}
3.3模拟BufferedReadLine
public class MyBufferedReader extends Reader {
private Reader r;
MyBufferedReader(Reader r) {
this.r = r;
}
// 读一行的方法
public String myReaderLine() throws IOException {
// 定义一个临时容器，原bufferreader封装的字符数组。
// 为了演示方便，定义了一个Stringbuffer容器，因为最终还是要将数据变成字符串
StringBuffer sb = new StringBuffer();
int ch = 0;
while ((ch = r.read()) != -1) {
if (ch == '\r') {
continue;
}
if (ch == '\n') {
return sb.toString();
} else {
sb.append((char) ch);
}
}
// 防止最后一行没有换行的情况
if (sb.length() != 0) {
return sb.toString();
}
return null;
}
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
// TODO Auto-generated method stub
return r.read(cbuf, off, len);
}
@Override
public void close() throws IOException {
// TODO Auto-generated method stub
r.close();
}
}
4、IO流(LineNumberReader)
跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
import java.io.*;
class Demo{
public static void main(String args[]) throws IOException{
FileReader fr = new FileReader("Demo.java");
LineNumberReader lnr = new LineNumberReader(fr);
String line = null;
lnr.setLineNumber(2);
while((line=lnr.readLine())!=null){
System.out.println(lnr.getLineNumber()+":"+line);
}
lnr.close();
}
}
4.2、模拟LineNumberReader
import java.io.*;
class Demo{
public static void main(String args[]) throws IOException{
FileReader fr = new FileReader("Demo.java");
myLineNumberReader lnr = new myLineNumberReader(fr);
String line = null;
while((line=lnr.myReadLine())!=null){
System.out.println(lnr.myGetLineNumber()+":"+line);
}
lnr.close();
}
}
class myLineNumberReader{
private BufferedReader br = null;
private int lineNumber = 0;
myLineNumberReader(FileReader fr){
br = new BufferedReader(fr);
}
public void lineNumberadd(){
lineNumber++;
}
public int myGetLineNumber(){
return lineNumber;
}
public String myReadLine() throws IOException{
lineNumberadd();
return br.readLine();
}
public void close() throws IOException{
br.close();
}
}
5.IO流(字节流inputStream读写操作)
import java.io.*;
public class Demo{
public static void main(String args[]){
FileOutputStream fos = null;
FileInputStream fis = null;
try{
fos = new FileOutputStream("yujinxiang.jpg");
fis = new FileInputStream("d:\\java\\yujinxiang.jpg");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
}catch(IOException e){
throw new RuntimeException("复制文件失败");
}finally{
try{
if(fis!=null){
fis.close();
}
}catch(IOException e){
throw new RuntimeException("读取关闭失败");
}
try{
if(fos!=null){
fos.close();
}
}catch(IOException e){
throw new RuntimeException("写入关闭失败");
}
}
}
}
5.2.字节流的缓冲区
BufferedInputStream
BufferedInputStream
5.3通过缓冲区复制文本文件
package ioStreaam.implement;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Bufferediostrean {
public static void main(String[] args) {
copyFile();
}
public static void copyFile() {
long start = System.currentTimeMillis();
MyBufferInputStream bis = null;
BufferedOutputStream bos = null;
FileInputStream fis = new FileInputStream("摇摆哥.mp3");
FileOutputStream fos = new FileOutputStream("Copy摇摆哥.mp3");
int num = 0;
bis = new MyBufferInputStream(fis);
bos = new BufferedOutputStream(fos);
while ((num = bis.myRead()) != -1) {
bos.write(num);
System.out.println(num);
}
if (bis != null) {
bis.myClose();
}
if (bos != null) {
bos.close();
}
long end = System.currentTimeMillis();
System.out.println("拷贝时间为：" + (end - start) + " 毫秒！");
}
}
5.4模拟字节流的缓冲区
class MyBufferedInputStream{
private InputStream in;
private byte[] buf = new byte[1024];
private int pos =0,count = 0;
MyBufferedInputStream( InputStream in){
this.in = in;
}
//一次读一个字节，从缓冲区（字节数组）获取
public int myRead(){
//通过 in 对象 读取硬盘上数据，并存储 buf 中
if(count==0){
count = in.read(buf);
if(count<0)
return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b&255;
}else if(count>0){
byte b = buf[pos];
count--;
pos++;
return b&0xff;
}
}
public void myclose(){
in.close();
}
}
6.IO流(读取键盘录入)
System.out:对应的是标准输出设备：控制台
System.in:对应的是标准输入设备：键盘
import java.io.*;
public class Demo{
public static void main(String args[]) throws IOException{
InputStream in = System.in;
StringBuilder sb = new StringBuilder();
while(true){
int ch = in.read();
if(ch=='\r')
continue;
if(ch=='\n'){
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}else{
sb.append((char)ch);
}
}
}
}
7.IO流(读取转换流InputStreamReader)
通过键盘录入一行数据，并打印其大写，发现其实就是读一行数据的原理，也就是readLine方法来完成键盘录入的一行数据的读取呢？
import java.io.*;
public class Demo{
public static void main(String args[]) throws IOException{
//获取键盘录入对象
InputStream in = System.in;
//将字节流对象转换成字符流对象，使用转换流，InputStreamReader
InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符进行缓冲区技术高效操作，使用bufferedReader
BufferedReader bufr = new BufferedReader(isr);
//以上可以用一句话代替
//BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line = bufr.readLine())!=null){
if(line.equals("over")){
break;
}
System.out.println(line.toUpperCase());
}
bufr.close();
}
}
8.IO流(写入转换流 OutputStreamWriter)
import java.io.*;
public class Demo{
public static void main(String args[]) throws IOException{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line = bufr.readLine())!=null){
if(line.equals("over")){
break;
}
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
9.IO流(流操作规律-1)
流操作的基本规律：最痛苦的就是流对象有很多，不知道该用那一个
通过明确来完成。
(1)、明确源和目的
源：输入流 InputStream Reader
目的：输出流 OutputStream Writer
(2)、操作的数据是否是纯文本
是：字符流
不是：字节流
(3)、当体系明确后，再明月要使用那个具体的对象
通过设备来进行区分：
源设备：内存 硬盘 键盘
目的设备：内存 硬盘 控制盘
10.IO流(改变标准输入输出设备)
static void setIn(InputStream in)
重新分配“标准”输入流。
static void setOut(PrintStream out)
重新分配“标准”输出流。
12.IO流(系统信息)
import java.io.*;
import java.util.*;
import java.text.*;
import java.text.*;
public class Demo{
public static void main(String args[]) throws IOException{
Properties prop = System.getProperties();
prop.list(new PrintStream("demo.txt"));
}
}
13.File类
1、用来将文件或者文件夹封装成对象
2、方便对文件与文件夹进行操作
3、File对象可以作为参数传递给流的构造函数。
4、了解File类中的常用方法
static String separator 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
13.1操作
1.创建
File f1 = new File("c:\\java\\demo.txt"); 创建File对象
boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false
boolean mkdir() 创建此抽象路径名指定的目录。
2、删除
boolean delete() 删除此抽象路径名表示的文件或目录。
void deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
3、判断
boolean canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。
boolean canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
int compareTo(File pathname) 按字母顺序比较两个抽象路径名
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
boolean isAbsolute() 测试此抽象路径名是否为绝对路径名。
boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
注意：判断类型时候。必须先判断是否存在
4，获取
System.out.println(f.renameTo(f2)); 把f2名称和路径改为f2的文件
5、文件列表
static File[] listRoots() 列出可用的文件系统根。
String[] list() 包含隐藏文件返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
6，列出目录下所有内容-带层次
//层次
public static String getlevel(int level){
StringBuilder sb=new StringBuilder();
sb.append("|---");
for(int x=1;x<level;x++){
sb.insert(0, "| ");
}
return sb.toString();
}
//递归
public static void showDir(File dir,int xx){
xx++;
System.out.println(getlevel(xx)+dir+"的所有文件：");
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory()){
showDir(files[x],xx);
//System.out.println();
}
else{
System.out.println(files[x]);
}
}
}
14.IO流(Properties类)
14.1.
简述
Properties 是 hashtable 的子类
也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串
是集合中和IO技术相结合的集合容器
该对象特点：可以用于键值对形式的配置文件。
那么在加载数据时候，需要数据有固定格式：键=值
14.2.
存取
//设置和获取元素
public static void setAndGet(){
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
System.out.println(prop.toString());
String value = prop.getProperty("lisi");
System.out.println(value);
prop.setProperty("lisi","98");
Set<String> names = prop.stringPropertyNames();
for(String s : names){
System.out.println(s+":"+prop.getProperty(s));
}
}
}
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[])throws IOException{
setAndGet();
}
//设置和获取元素
public static void setAndGet(){
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
System.out.println(prop.toString());
String value = prop.getProperty("lisi");
System.out.println(value.tostring());
prop.setProperty("lisi","98");
Set<String> names = prop.stringPropertyNames();
for(String s : names){
System.out.println(s+":"+prop.getProperty(s));
}
}
}
14.3
Properties存取配置文件
String getProperty(String key)用指定的键在此属性列表中搜索属性。
String getProperty(String key, String defaultValue)用指定的键在属性列表中搜索属性。
void list(PrintStream out)将属性列表输出到指定的输出流。
void list(PrintWriter out)将属性列表输出到指定的输出流。
void load(InputStream inStream)从输入流中读取属性列表（键和元素对）。
void load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
store(OutputStream out, String comments)将此 Properties 表中的属性列表（键和元素对）写入输出流。
14.4Properties练习
//修改信息
public static void loadDemo() throws IOException {
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("propertiesinfo.txt");
prop.load(fis);//读取文件
prop.setProperty("huhu", "29");// 修改集合信息
FileOutputStream fos = new FileOutputStream("propertiesinfo.txt");
prop.store(fos, "haha");//将此 Properties 表中的属性列表（键和元素对）写入输出流
System.out.println(prop);
prop.list(System.out);
fos.close();
fis.close();
}
//读
public static void reader() throws IOException {
BufferedReader bfr = null;
FileReader fr;
fr = new FileReader("propertiesinfo.txt");
bfr = new BufferedReader(fr);
String line = null;
while ((line = bfr.readLine()) != null) {
String[] lines = line.split("=");
setAndget(lines);
}
bfr.close();
}
public static void setAndget(String[] lines) {
Properties prop = new Properties();
prop.setProperty(lines[0], lines[1]);
Set<String> names = prop.stringPropertyNames();
for (String s : names) {
System.out.println(s + ":" + prop.getProperty(s));
}
}
15.打印流
PrintWriter 与 PrintStream可以直接操作输入流和文件
例：打印流PrintStream)
public static void main(String[] args) throws IOException {
System.out.println("请输入信息！！");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("printwriter.txt")), true);
String line = null;
while ((line = br.readLine()) != null) {
if ("over".equals(line)) {
break;
}
out.println(line.toUpperCase());
// out.flush();
}
out.close();
}
16.序列流
SequenceInputStream对多个流进行合并
例：合并文件
public static void main(String args[])throws Exception{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration <FileInputStream> en = v.elements(); //返回此向量的组件的枚举
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("4.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
例：切割文件
public static void splitfile() throws Exception{
FileInputStream fis=new FileInputStream("11.xv");
FileOutputStream fos=null;
byte[] by=new byte[1024*1024];
int len=0,count=1;
while((len=fis.read(by))!=-1){
fos=new FileOutputStream((count++)+".part");
counts=count;
fos.write(by,0,len);
fos.close();
}
fis.close();
}
public static void merge() throws IOException{
ArrayList< FileInputStream> al=new ArrayList<FileInputStream>();
for(int i=1;i<=6;i++){
al.add(new FileInputStream(i+".part"));
}
final Iterator<FileInputStream> it=al.iterator();
FileOutputStream fos=new FileOutputStream("hebing11.xv");
Enumeration<FileInputStream> en=new Enumeration<FileInputStream>() {
@Override
public FileInputStream nextElement() {
// TODO Auto-generated method stub
return it.next();
}
@Override
public boolean hasMoreElements() {
// TODO Auto-generated method stub
return it.hasNext();
}
};
SequenceInputStream sis=new SequenceInputStream(en);
int line=0;
while((line=sis.read())!=-1){
fos.write(line);
}
sis.close();
fos.close();
}
public static void main(String[] args) throws Exception {
//splitfile();
merge();
}
17.操作对象流ObjectInputStream 与 ObjectOutputStream
想要序列化必须实现，java.io.Serializable 接口。
定义ID：static final long serialVersionUID = 42L;
transient int age;//普通变量被transient修饰后，也不能被序列化
static int age; //静态是不能静态化的
例：对象的序列化
import java.io.*;
public class Demo{
public static void main(String[] args) throws Exception{
writeObj();
readObj();
}
public static void writeObj() throws Exception{
//存的文件一搬以object作为扩展名
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("demo.txt"));
//可以存入多个对象
//取得时候，readObject()几次就去几个
oos.writeObject(new Person("lisi",39,"kr"));
oos.close();
}
public static void readObj() throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("demo.txt"));
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void System.out.println(Object obj){
System.out.println(obj);
}
}
18.管道流（PipedInputStream和PipedOutputStream）
输入输出可以直接进行连接，通过结合线程使用
import java.io.*;
public class Demo{
public static void main(String[] args) throws Exception{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
Read r = new Read(in);
Write w =new Write(out);
new Thread(r).start();
new Thread(w).start();
}
public static void System.out.println(Object obj){
System.out.println(obj);
}
}
class Read implements Runnable{
private PipedInputStream in;
Read(PipedInputStream in){
this.in = in;
}
public void run(){
try{
byte[] buf = new byte[1024];
int length = in.read(buf);
String s = new String(buf,0,length);
System.out.println(s);
in.close();
}catch(Exception e){
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable{
private PipedOutputStream out;
Write(PipedOutputStream out){
this.out = out;
}
public void run(){
try{
Thread.sleep(3000);
out.write("piped lai la".getBytes());
out.close();
}catch(Exception e){
throw new RuntimeException("管道输出流失败");
}
}
}
19.IO流(RandomAccessFile)
(1)、随机访问文件，自身具备读写的方法
(2)、通过skipBytes(int x),seek(int x)来达到随机访问。
例：
import java.io.*;
public class Demo{
public static void main(String[] args) throws Exception{
//write();
//read();
}
public static void write() throws Exception{
RandomAccessFile raf = new RandomAccessFile("demo.txt","rw");
// raf.seek(8);//调整对象中指针
raf.write("李四".getBytes());
//raf.write(97);//write写入int的最低八位
raf.writeInt(97); //writeInt写入int 的 全部 4个八位
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
public static void read() throws Exception{
RandomAccessFile raf = new RandomAccessFile("demo.txt","rw");
byte[] buf = new byte[4];
//read为读单个字节 readInt() 为读4个字节
raf.read(buf);
String str = new String(buf);
System.out.println(str);
raf.seek(0);//调整对象中指针
raf.skipBytes(8); //跳过指定的字节数,只能往后跳，不能往回跳
int num = raf.readInt();
System.out.println(num);
raf.close();
}
}
20.基本数据类型的流对象DataStream
1、操作基本数据类型DataInputStream 与 DataOutputStream
例：
import java.io.*;
public class Demo{
public static void main(String[] args) throws Exception{
//writeData();
//readData();
writeUTFDemo();
readUTFDemo();
//writeUTFNormal();
}
public static void writeData() throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("demo.txt"));
dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(9887.543);
dos.close();
}
public static void readData() throws IOException {
DataInputStream dos = new DataInputStream(new FileInputStream("demo.txt"));
System.out.println(dos.readInt());
System.out.println(dos.readBoolean());
System.out.println(dos.readDouble());
dos.close();
}
public static void writeUTFDemo() throws IOException{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("demo.txt"));
dos.writeUTF("你好");
}
public static void readUTFDemo() throws IOException{
DataInputStream dis = new DataInputStream(new FileInputStream("demo.txt"));
System.out.println(dis.readUTF());
dis.close();
}
}
2、操作字节数ByteArrayInputStream 与ByteArrayOutputStream
例：
import java.io.*;
public class Demo{
public static void main(String[] args) throws Exception{
//数据源
ByteArrayInputStream bis = new ByteArrayInputStream("abcdefg".getBytes());
//数据目的
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int by = 0;
while((by=bis.read())!=-1){
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
}
}
3、操作字符数组CharArrayReader 与 CharArrayWriter
4、操作字符串StringReader 与 StringWriter
21.IO流(转换流的字符编码)
字符编码
1、字符流的出现是为了方便操作字符
2、更重要的是加入了编码转换
3、通过子类转换流来完成
(1)、InputStreamReader
(2)、OutputStreamWriter
4、在两个对象进行构造的时候可以加入字符集
1.
import java.io.*;
public class Demo{
public static void main(String[] args) throws Exception{
writeText();
readText();
}
public static void writeText() throws Exception{
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("demo.txt"),"UTF-8");
osw.write("你好");
osw.close();
}
public static void readText() throws Exception{
InputStreamReader isw = new InputStreamReader(new FileInputStream("demo.txt"),"UTF-8");
char[] buf = new char[20];
int len = isw.read(buf);
String str = new String(buf,0,len);
System.out.println(str);
isw.close();
}
}
2、不同表的字符解码
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String[] args) throws Exception{
String s = "你好";
byte[] bs1 = s.getBytes("GBK");//可以传入字符集。s.getBytes("utf-8");
String s1 = new String(bs1,"iso8859-1");
byte[] bs2 = s1.getBytes("iso8859-1");
String s2 = new String(bs2,"GBK");
System.out.println(s2);
}
public static void System.out.println(Object obj){
System.out.println(obj);
}
}
3、字符编码-联通
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String[] args) throws Exception{
String s = "联通";
byte[] by = s.getBytes("gbk");
for(byte b : by){
System.out.println(Integer.toBinaryString(b&255));
}
}
}