admin管理员组文章数量:1568418
1.字节数组输入流
字节数组是属于内存的，不需要额外从磁盘文件中调度，有几点需要注意：F.所有的东西都可以转成字节数组，方便进行传输；S.不建议量非常大，否则内存容易爆满 T .不需要关闭
package cn.io.java.mhz;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* 字节数组输入流
* 1.创建源：字节数组 不能太大
* 2.选择流
* 3.操作
* 4.释放资源 ，可以不用处理
* @author MHZ
*
*/
public class MyJavaIODemo011 {
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.操作
byte[] flush = new byte[10];
int len = is.read(flush);
while(len!=-1)
{
String str = new String(flush);
System.out.println(str);
len = is.read(flush);
}
}catch(IOException E)
{
E.printStackTrace();
}finally {
try {
if(null!=is)
{
is.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
}
}
2.字节数组输出流
package cn.io.java.mhz;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* 字节数组输出流 ByteArrayOutputStream
* @author MHZ
*
*/
public class MyJavaIODemo012 {
public static void main(String[] args)
{
//1.创建源
byte[] dest = null;
//2.选择流(新增方法)
ByteArrayOutputStream os = null;
try {
os = new ByteArrayOutputStream();
//3.操作（写出）
String msg = "talk is cheap show me the code";
byte[] str = new byte[50];
str = msg.getBytes();
os.write(str,0,str.length);
os.flush();
//获取数据
dest = os.toByteArray();
System.out.println(dest.length);
String s = new String(dest);
System.out.println(s);
}catch(IOException E)
{
E.printStackTrace();
}finally {
try {
if(null!=os)
{
os.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
}
}
3.IO综合：图片的复制
将图片通过字节流转成字节数组，再通过字节数组转成字节流变成另一个图片文件
package cn.io.java.mhz;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* IO综合
* 字节流与字节数组输入输出流的综合
* @author MHZ
*
*/
public class MyJavaIODemo013 {
public static void main(String[] args)
{
byte[] pic = fileToByteArray("C:\\Users\\asus\\eclipse-workspace\\Java-IO\\bg.jpg"); //内存中有一张图片
//System.out.println(pic.length);
//还原成图片
byteArrayToFile(pic,"bg2.jpg");
}
/**
* 将图片读取到字节数组中
* 1.将图片到程序 FileInputStream
* 2.程序到字节数组ByteArrayOutputStream
*/
public static byte[] fileToByteArray(String filePath)
{
//创建源
File src = new File(filePath);
byte[] dest = null;
//选择流
InputStream is = null;
ByteArrayOutputStream BAOS = null;
try {
is = new FileInputStream(src);
BAOS = new ByteArrayOutputStream();
//操作(分段读取)
byte[] str = new byte[1024];
int len = is.read(str,0,str.length);
while(len!=-1)
{
BAOS.write(str,0,len);
len = is.read(str,0,len);
}
BAOS.flush();
return BAOS.toByteArray();
}catch(FileNotFoundException E)
{
E.printStackTrace();
}catch(IOException E)
{
E.printStackTrace();
}finally {
try {
if(null!=is)
{
is.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
try {
if(null!=BAOS)
{
BAOS.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
return null;
}
/**
* 字节数组写出到图片
*1.字节数组到程序中
*2.程序到文件
*/
public static void byteArrayToFile(byte[] str,String filePath)
{
//创建源
InputStream is = null;
OutputStream os =null;
//选择流
File src = new File(filePath);
try {
is = new ByteArrayInputStream(str);
os = new FileOutputStream(src);
byte[] flush = new byte[1024];
int len = is.read(flush,0,flush.length);
while(len!=-1)
{
os.write(flush,0,flush.length);
os.flush();
len = is.read(flush,0,flush.length);
}
os.flush();
}catch(IOException E)
{
E.printStackTrace();
}finally {
try {
if(null!=os)
{
os.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
try {
if(null!=is)
{
is.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
}
}
4.装饰设计模式
package cn.io.java.mhz;
/**
* 装饰类
* @author MHZ
*
*/
public class DecorateTest001 {
public static void main(String[] args)
{
Person p = new Person();
p.say();
//装饰类,实际上就是类与类之间的关系,将原类放入后面类的构造器中，并调用原来类的成员方法
Amplifier am = new Amplifier(p);
am.say();
}
}
interface Say{
void say();
}
class Person implements Say{
private int voice = 10;
@Override
public void say()
{
System.out.println("人的声音为："+this.getVoice());
}
public int getVoice() {
return voice;
}
public void setVoice(int voice) {
this.voice = voice;
}
}
//放大器
class Amplifier implements Say{
private Person p;
Amplifier(Person p){
this.p=p;
}
public void say()
{
System.out.println("人的声音为："+this.p.getVoice()*100);
System.out.println("噪音。。。");
}
}package cn.io.java.mhz;
/**
* 模拟咖啡
* 装饰设计模式
* 1.抽象组件：需要装饰的抽象对象
* 2.具体组件：需要装饰的对象
* 3.抽象装饰类：包含了对抽象组件的引用以及装饰者共有的方法
* 4.具体的装饰类：被装饰的对象
* @author MHZ
*
*/
public class DecorateTest002 {
public static void main(String[] args)
{
Drink coffee = new Coffee();
System.out.println(coffee.info()+coffee.cost());
Drink suger = new Suger(coffee);
System.out.println(suger.info()+suger.cost());
Drink milk = new Milk(coffee);
System.out.println(milk.info()+milk.cost());
milk = new Milk(suger);
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 this.name;
}
}
//抽象装饰类
abstract class Decorate implements Drink{
private Drink drink;
public Decorate(Drink drink)
{
this.drink = drink;
}
@Override
public double cost()
{
return this.drink.cost();
}
@Override
public String info()
{
return this.drink.info();
}
}
//具体装饰类
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 Suger extends Decorate{
public Suger(Drink drink)
{
super(drink);
}
@Override
public double cost()
{
return super.cost()*2;
}
@Override
public String info()
{
return super.info()+"加入了 糖";
}
}5.字节缓冲流BufferedInputStream&&BufferedOutputStream，它们是处理流（装饰流）
缓冲流的作用：提升性能，装饰流必建立在节点流的基础上，在通知系统释放资源的时候，只需释放最外层的处理流，系统会由内向外自动的去释放资源，如果手动通知，那么也需要由内向外书写
写法非常简单，只需要一点小修改即可，性能有不少提升。
package cn.io.java.mhz;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* 字节缓冲流，用来提升性能
* BufferedInputStream处理流
* 在字节流中加入装饰流（处理流）
* @author MHZ
*
*/
public class MyJavaIODemo014 {
public static void main(String[] args)
{
//创建源
File src = new File("C:\\Users\\asus\\eclipse-workspace\\Java-IO\\Copy.txt");
//创建流
InputStream is =null;
BufferedInputStream bis =null;
try {
is = new FileInputStream(src);
bis = new BufferedInputStream(is); //对字节流进行处理
//也可以直接像下面这条语句这样直接套用字节缓冲流
// is = new BufferedInputStream(new FileInputStream(src));
//操作（分段读取）
byte[] flush = new byte[1024];
int len = is.read(flush,0,flush.length);
while(len!=-1)
{
String str = new String(flush,0,len);
System.out.println(str);
len = is.read(flush,0,flush.length);
}
}catch(FileNotFoundException E)
{
E.printStackTrace();
}catch(IOException E)
{
E.printStackTrace();
}finally {
//关闭的时候，关闭外层的处理流即可，系统会自动去释放内部的节点流
try {
if(null!=bis)
{
bis.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
}
}
6.字符缓冲流BufferedWriter&&BufferedReader
使用字符缓冲流来完成纯文本的复制
package cn.io.java.mhz;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
/**
* 字符缓冲流进行文件的复制,仅限于纯文本
* BufferedWriter&&BufferedReader
* @author MHZ
*
*/
public class MyJavaIODemo015 {
public static void main(String[] args)
{
FileCopy1("C:\\Users\\asus\\eclipse-workspace\\Java-IO\\src\\mhz.txt","Copy4.txt");
}
//把文件拷贝封装成一个方法
public static void FileCopy1(String url1,String url2)
{
//创建源
File src = new File(url1);
File src1 = new File(url2);
//选择流
Reader read = null;
Writer write = null;
try {
read = new BufferedReader(new FileReader(src));
write = new BufferedWriter(new FileWriter(src1));
//操作(分段读取)
char[] flush = new char[1024];
//读取的时候，不需要像原来那样先读取一个字符数组，直接使用readLine
int len = read.read(flush,0,flush.length);
while(len!=-1)
{
write.write(flush);
write.append("\r\n");
write.flush();
len = read.read(flush,0,flush.length);
}
write.flush();
}catch(FileNotFoundException E) {
E.printStackTrace();
}catch(IOException E)
{
E.printStackTrace();
}finally {
//先打开的后关闭，关闭最外侧的处理流即可
try{
if(null!=write)
{
write.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
try {
if(null!=read)
{
read.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
}
}
7.转化流，将字节流转化成字符流，避免乱码的问题，一般用于纯文本的操作
package cn.io.java.mhz;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/**
* 转化流 ： InputStreamReader OutputStreamWriter
* 字节流与字符流的转化
* 使用字符流处理纯文本的内容，当文件中都是纯文本的内容时，可以使用字符流来处理，同时可以指定字符集
* @author MHZ
*
*/
public class MyJavaIODemo016 {
public static void main(String[] args)
{
//操作System.in和System.out,System.in和System.out都是操作字节流
//两个转化流，将字节流转化成字符流
try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));){
//循环获取键盘的输入，exit退出，输出此内容
String msg = "";
while(!msg.equals("exit"))
{
msg = reader.readLine();
writer.write(msg);
//writer.append("\r\n");
writer.newLine();
writer.flush(); //强制刷新，如果不强制刷新，内容就会残留到管道内
}
}catch(IOException E) {
E.printStackTrace();
}
}
}
8.转化流还可以指定字符集，爬取了百度的源码
使用了转化流和缓冲流
package cn.io.java.mhz;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.URL;
/**
* 转化流的应用，字符流处理纯文本比较方便
* 下载百度的源码
* @author MHZ
*
*/
public class MyJavaIODemo017 {
public static void main(String[] args)
{
//指定字符集
//操作网络流，下载百度的源码
BufferedReader br = null;
BufferedWriter bw = null;
try{
//创建流
InputStream is = new URL("http://www.baidu").openStream();
//转化流 缓冲流 需要指定正确的字符集
br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("baidu.html"),"UTF-8"));
String s = br.readLine();
while(s!=null)
{
bw.write(s,0,s.length());
bw.newLine();
bw.flush();
s = br.readLine();
}
bw.flush();
}catch(IOException E){
E.printStackTrace();
}finally {
try {
if(null!=bw)
{
bw.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
try {
if(null!=br)
{
br.close();
}
}catch(IOException E)
{
E.printStackTrace();
}
}
}
}
9.数据流，可以处理一些基本的数据类型
要注意：1.先写后读 2.读取的顺序要和写入的顺序保持一致
package cn.io.java.mhz;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
/**
* 数据流
* 1.先写出，后读取
* 2.读取的顺序和写出一致
* @author MHZ
*DataOutputStream DataInputStream方便处理基本数据类型
*/
public class MyJavaIODemo018 {
public static void main(String[] args) throws IOException
{
//写出
//创建源 一种是文件，一种是字节数组
ByteArrayOutputStream b = new ByteArrayOutputStream();
File src = new File("dx.txt");
//选取数据流
OutputStream out = new FileOutputStream(src);
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream((b)));
DataOutputStream x = new DataOutputStream(new BufferedOutputStream(out));
//操作数据类型+数据
dos.writeUTF("编程");
dos.writeInt(20);
dos.writeBoolean(false);
dos.writeChar('x');
dos.flush();
byte[] s = b.toByteArray();
x.writeChar('5');
x.writeInt(10);
x.writeBoolean(false);
x.writeBoolean(false);
x.writeChar('f');
x.writeDouble(1.00);
x.flush();
//System.out.println(s.length);
//读取
InputStream in = new FileInputStream(src);
DataInputStream read = new DataInputStream(new BufferedInputStream(in));
DataInputStream dis = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(s)));
//顺序与写出一致 如果不一致就会发生错误
String msg = dis.readUTF();
int age = dis.readInt();
boolean flag = dis.readBoolean();
char ch = dis.readChar();
System.out.println(age);
System.out.println(msg);
char f = read.readChar();
System.out.println(f);
int k = read.readInt();
System.out.println(k);
boolean flag1 = read.readBoolean();
System.out.println(flag1);
}
}
10.对象流
F.先写后读，和数据流相同 S.读取顺序和写入顺序一致 T.不是所有的对象都可以实现序列化，序列化又称为持久化，对象流中要求对象实现序列化，那么首先需要实现Serializable接口，完成序列化
package cn.io.java.mhz;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;
/**
* 对象流
* 1.先写出，后读取
* 2.读取的顺序和写出一致
* 3.不是所有的对象都可以序列化，必须先实现Serializable接口,序列化也叫持久化
* @author MHZ
*DataOutputStream DataInputStream方便处理基本数据类型
*/
public class MyJavaIODemo019 {
public static void main(String[] args) throws IOException, ClassNotFoundException
{
//写出 ------------------------------->序列化
//创建源 一种是文件，一种是字节数组
ByteArrayOutputStream b = new ByteArrayOutputStream();
//选取对象流 写入对象流的对象必须首先实现序列化
ObjectOutputStream dos = new ObjectOutputStream(new BufferedOutputStream((b)));
//操作数据类型+数据
dos.writeUTF("编程");
dos.writeInt(20);
dos.writeBoolean(false);
dos.writeChar('x');
//加入对象
dos.writeObject("我爱我家");
dos.writeObject(new Date());
dos.writeObject(new Employee("mhz",21,"student")); //此时这个对象并未实现序列化，要想进行序列化需要加入Serializable接口
dos.flush();
byte[] s = b.toByteArray();
//读取 -----------------------> 反序列化
ObjectInputStream dis = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(s)));
//顺序与写出一致 如果不一致就会发生错误
String msg = dis.readUTF();
int age = dis.readInt();
boolean flag = dis.readBoolean();
char ch = dis.readChar();
System.out.println(age);
System.out.println(msg);
Object x =dis.readObject();
System.out.println(x.toString());
Object x1 =dis.readObject();
System.out.println(x1.toString());
System.out.println(((Employee)dis.readObject()).toString());
dos.close();
dis.close();
b.close();
}
}
/**
* 如下面这个类所示，要想写入对象流，就必须首先实现Serializable接口
* @author MHZ
*
*/
class Employee implements Serializable{
String name;
int age;
String pos;
//构造器
public Employee(String name, int age, String pos) {
super();
this.name = name;
this.age = age;
this.pos = pos;
}
public Employee()
{
}
//set get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getPos() {
return pos;
}
public void setPos(String pos) {
this.pos = pos;
}
@Override
public String toString()
{
return "name:"+this.name+"--->"+"age:"+this.age+"--->"+"pos:"+this.pos+"\n";
}
}
版权声明：本文标题：Java IO---02 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://m.elefans.com/dianzi/1727613908a1123037.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论