文章目录
1、字符集
1.1、字符编码
1.2、编码encode
getBytes
package CoreJavaColume.Chapter15;
import java.io.UnsupportedEncodingException;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 17:48
* 编码:字符串---》字节
*/
public class ContentEncode {
public static void main(String[] args) throws UnsupportedEncodingException {
String msg = "性命生命使命";
//编码:获取字节数组
byte[] datas = msg.getBytes();//默认使用工程字符集 utf-8
System.out.println(datas.length);
//编码:其他字符集
datas = msg.getBytes("UTF-16LE");
System.out.println(datas.length);
}
}
1.3、解码decode
package CoreJavaColume.Chapter15;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 17:53
* 解码: 字节数组---》字符
*/
public class ContentDecode {
public static void main(String[] args) {
String msg = "性命生命使命";
//编码:获取字节数组
byte[] datas = msg.getBytes();//默认使用工程字符集 utf-8
//解码
msg = new String(datas);
System.out.println(msg);
}
}
1.4、乱码原因
- 字节数不够
- 字符集不统一
2、字节流与字符流
底层
2.1、IO标准步骤
确定源
选择流
操作:读和写
释放系统资源
标准
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 20:16
* 第一个程序:理解操作步骤
*/
public class IOTEST02 {
public static void main(String[] args) {
//1、创建元
File src = new File("abc.txt");
InputStream is = null;
//2、选择流
try {
is = new FileInputStream(src);
//3、操作
int temp;
while((temp=is.read())!=-1){
System.out.println((char)temp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(is!=null){
is.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.2、文件字节流 FileInputStream和FileOutPutStream
分段读取
2.2.1、FileInputStream
public static void main(String[] args) {
//1、创建元
File src = new File("abc.txt");
InputStream is = null;
//2、选择流
try {
is = new FileInputStream(src);
//3、操作(分daunt读取)
byte[] flush = new byte[1024];//缓冲容器
int len = -1;//接受长度
while((len=is.read(flush))!=-1){
//字节数组---》字符串(解码)
System.out.println(new String(flush,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(is!=null){
is.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.2.2、FileOutPutStream
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 20:33
* 文件字节输出流
*/
public class IOTEST04 {
public static void main(String[] args) {
//1、创建源
File dest = new File("dest");
//2、选择流
OutputStream os = null;
try{
os=new FileOutputStream(dest);
//3、操作(写出)
String msg = "IO is so easy";
byte[] datas = msg.getBytes();//字符串->字节数组 (编码)
os.write(datas,0,datas.length);
os.flush();//刷新数据
}catch (FileNotFoundException e){
}catch (IOException E){
} finally{
if(os!=null){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.2.3、文件拷贝
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 20:46
* 拷贝文件
*/
public class IOTEST02 {
public static void main(String[] args) {
//1、创建元
File src = new File("abc.txt");
File dest = new File("dest");
//2、选择流
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(src);
os=new FileOutputStream(dest);
//3、操作(分daunt读取)
byte[] car = new byte[3];//缓冲容器
int len = -1;//接受长度
while((len=is.read(car))!=-1){
//字节数组---》字符串(解码)
System.out.println(new String(car,0,len));
//复制
os.write(car,0,len);
os.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源,先打开的后关闭
try {
if(is!=null){
is.close();}
if(os!=null){
osclos
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.3、文件字符流FileReader和FileWriter
2.3.1、FileReader
public class IOTEST05 {
public static void main(String[] args) {
//1、创建元
File src = new File("abc.txt");
//2、选择流
Reader reader = null;
try {
reader = new FileReader(src);
//3、操作(分daunt读取)
char[] car = new char[1024];//缓冲容器
int len = -1;//接受长度
while((len=reader.read(car))!=-1){
//字符数组---》字符串(解码)
System.out.println(new String(car,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(reader!=null){
reader.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.3.2、FileWriter
//1、创建源
File dest = new File("dest");
//2、选择流
Writer writer = null;
try{
writer=new FileWriter(dest);
//3、操作(写出)
String msg = "手动蝶阀vsdvsv";
writer.write(msg);
writer.flush();//刷新数据
2.4、字节数组流ByteArrayInputStream和ByteArrayOutputStream
这里操作的是内存,不同于上面的文件
与电脑内存打交道
2.4.1、ByteArrayInputStream
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 21:13
* 字节数组流 :ByteArrayInputStream
*/
public class IOTEST07 {
public static void main(String[] args) {
//1、创建元
byte[] src = "talk is cheap,show me the code".getBytes();
//2、选择流
InputStream is = null;
try {
is = new ByteArrayInputStream(src);
//3、操作(分daunt读取)
byte[] car = new byte[5];//缓冲容器
int len = -1;//接受长度
while((len=is.read(car))!=-1){
//字符数组---》字符串(解码)
System.out.println(new String(car,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(is!=null){
is.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.4.2、ByteArrayOutputstream
- 创建源:内部维护
- 选择流:不关联源
- 操作(写出内容)
- 释放资源:可以不用
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/11 0011 21:18
*/
public class IOTEST08 {
public static void main(String[] args) {
//1、创建源
byte[] dest = null;
//2、选择流(新增方法)
ByteArrayOutputStream bos = null;
try{
bos =new ByteArrayOutputStream();
//3、操作(写出)
String msg = "show me the code";
byte[] datas = msg.getBytes();//字符串----》字节数组(编码)
bos.write(datas,0,datas.length);
bos.flush();
//获取数据
dest = bos.toByteArray();
System.out.println(dest.length);
}catch (FileNotFoundException e){
}catch (IOException E){
} finally{
if(bos!=null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3、装饰器模式
[外
放大声音
package CoreJavaColume.Chapter15;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 17:22
*/
public class DecoratorTest01 {
public static void main(String[] args) {
Person p = new Person();
p.say();
Amplifier amplifier = new Amplifier(p);
amplifier.say();
}
}
interface Say{
void say();
}
class Person implements Say{
//属性
private int voice = 10;
public int getVoice() {
return voice;
}
public void setVoice(int voice) {
this.voice = voice;
}
@Override
public void say() {
System.out.println("人的声音为"+this.getVoice());
}
}
class Amplifier implements Say{
private Person p;
public Amplifier(Person p) {
this.p = p;
}
@Override
public void say() {
System.out.println("人的声音为"+p.getVoice()*100);
}
public Person getP() {
return p;
}
public void setP(Person p) {
this.p = p;
}
}
模拟咖啡
package CoreJavaColume.Chapter15;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 17:27
* 模拟咖啡:
* 1、抽象组件:需要装饰的抽象对象(接口或抽象类)
* 2、具体组件:需要装饰的对象
* 3、抽象装饰类:包含了对抽象组件的引用以及装饰共有的方法
* 4、具体装饰类:被装饰的对象
*
*/
public class DecoratorTest02 {
public static void main(String[] args) {
Drink coffee = new Coffee();
Drink sugar = new Sugar(coffee);
System.out.println(sugar.info()+"---->"+sugar.cost());
Drink milk = new Milk(sugar);
System.out.println(milk.info()+"---->"+milk.cost());
}
}
interface Drink{
double cost();//费用
String info();//说明
}
//具体组件
class Coffee implements Drink{
private String name = "原味咖啡";
@Override
public double cost() {
return 10;
}
@Override
public String info() {
return name;
}
}
//抽象的装饰类
abstract class Decorate implements Drink{
@Override
public double cost() {
return this.drink.cost();
}
@Override
public String info() {
return this.drink.info();
}
//对抽象组件的引用
private Drink drink;
public Decorate(Drink drink) {
this.drink = drink;
}
}
//具体装饰类
class Milk extends Decorate{
public Milk(Drink drink) {
super(drink);
}
@Override
public double cost() {
return super.cost()*4;
}
@Override
public String info() {
return super.info()+"加入了牛奶";
}
}
class Sugar extends Decorate{
public Sugar(Drink drink) {
super(drink);
}
@Override
public double cost() {
return super.cost()*2;
}
@Override
public String info() {
return super.info()+"加入了糖";
}
}
4、字节缓冲流BufferedInputStream和BufferedOutputStream
- 缓冲流提高了性能
- 底层还是包装了节点流
- 释放原则从里到外
4.1、BufferedInputStream
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 17:41
* 加入缓冲流
*/
public class Bufferedtest01 {
public static void main(String[] args) {
//1、创建元
File src = new File("abc.txt");
//2、选择流
InputStream is = null;
BufferedInputStream bis = null;
try {
is = new FileInputStream(src);
bis = new BufferedInputStream(is);
//3、操作(分daunt读取)
byte[] car = new byte[1024];//缓冲容器
int len = -1;//接受长度
while((len=is.read(car))!=-1){
//字节数组---》字符串(解码)
System.out.println(new String(car,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(bis!=null){
bis.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.2、BufferedOutPutStream
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 17:41
* 加入缓冲流
*/
public class Bufferedtest01 {
public static void main(String[] args) {
//1、创建元
File dest = new File("123.txt");
BufferedOutputStream bos = null;
try {
bos=new BufferedOutputStream(new FileOutputStream(dest));
//3、操作(分daunt读取)
bos.write(12223);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(bos!=null){
bos.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5、字符缓冲流BufferedReader和BufferedWriter
readLine()
6、转换流InputStreamReader和OutputStreamWriter
- 字节流转换为字符流,方便处理
- 可以指定字符集
6.1、InputStreamReader(解码)
InputStreamReader
是从字节流到字符流的桥梁:它读取字节,并使用指定的charset
将其解码为字符;它使用的字符集可以由名称指定,或者接受平台的默认字符集
6.2、OutputStreamWriter(编码)
outputStreamWriter
是从字符流到租借流的桥梁每次调用
write()
方法都会使编码转换器在给定的字符上被调用。所得到的字节在写入底层输出流之前累积在缓冲区中。
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 18:05
* 转换流:InputStreamReader OutputStreamWriter
* 1、以字符流的形式操作字节流
* 2、指定字符集
*/
public class ConvertTest {
public static void main(String[] args) {
//操作System.in和SYS
try( BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
) {
//循环获取键盘的输入
String msg = "";
while(!msg.equals("exit")){
msg=reader.readLine();//循环读取
writer.write(msg);//循环写出
writer.newLine();
writer.flush();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
7、数据流 DataInputStream和DataOutputStream
package CoreJavaColume.Chapter15;
import java.io.*;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 19:28
* 数据流
*/
public class DataStreamTest {
public static void main(String[] args) {
try(DataOutputStream dos=new DataOutputStream(new FileOutputStream("abc.txt"));
DataInputStream dis = new DataInputStream(new FileInputStream("abc.txt"))
){
//操作数据类型
dos.writeUTF("便捷");
dos.writeInt(18);
dos.writeChar('a');
dos.flush();
String msg = dis.readUTF();
System.out.println(msg);
int t = dis.readInt();
System.out.println(t);
char s = dis.readChar();
System.out.println(s);
}catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
8、对象流(序列化与反序列化)ObjectInputStream和oBjectOUtputStream
不是所有对象都可以序列化:实现Serializable的接口
某些数据不想序列化 transient
package CoreJavaColume.Chapter15;
import java.io.*;
import java.util.Date;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/2/12 0012 19:39
* 对象流:
* 1、写出后读取
* 2、读取的顺序和写出的顺序保持一致
* 3、不是所有的对象都可以序列化 Serializable
*/
public class ObjectStreamTest {
public static void main(String[] args) {
try(ObjectOutputStream dos=new ObjectOutputStream(new FileOutputStream("abc.txt"));
ObjectInputStream dis = new ObjectInputStream(new FileInputStream("abc.txt"))
){
//操作数据类型
dos.writeUTF("便捷");
dos.writeInt(18);
dos.writeChar('a');
dos.writeObject(new Date());
dos.flush();
String msg = dis.readUTF();
System.out.println(msg);
int t = dis.readInt();
System.out.println(t);
char s = dis.readChar();
System.out.println(s);
Date date = (Date)dis.readObject();//反序列化
System.out.println(date);
}catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}