1.用字节流复制一张图片
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestIO {
public static void main(String[] args) throws IOException {
//将指定图片,上传一份到项目里来!
//文件时在存储设备中的--》读到程序中来--》写入到存储设备种
//输入流
FileInputStream fis = new FileInputStream("C:\\Users\\87980\\Desktop"
+ "\\360截图20200316150348671.jpg");
//3317456 ---- 4M 够
byte[] cache = new byte[1024*1024*4];
int len = 0;//代表每次读到的字节
FileOutputStream fos = new FileOutputStream("E:\\qianfengjava\\day31\\wo.jpg");
while((len = fis.read())!=-1) {//只要不读到-1
fos.write(len);//读多少写多少
}
//释放资源!
fis.close();
fos.close();
}
}
2.对象实例化
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.Arrays;
public class TestObjectStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
OutputStream os = new FileOutputStream("E:\\qianfengjava\\day31\\obj.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
// oos.writeInt(30);//把基本数据类型的数据写入到文件里以数据的形式存储(块数据)
// oos.writeDouble(3.5);
// oos.writeBoolean(true);
// oos.flush();
//------------
InputStream is = new FileInputStream("E:\\qianfengjava\\day31\\obj.txt");
ObjectInputStream ois = new ObjectInputStream(is);
// int result = ois.read();
// int result = ois.readInt();//必须读相对应的类型,写的什么类型就读什么类型
// System.out.println(result);
Object o = ois.readObject();//下一个读到的3.5不是一个Object,所以报错
// System.out.println(o);
Student stu = new Student("张三",12,"男",100d,new Address("北京","123456"),new int[] {1,2,3});
Student stu2 = new Student("李四",16,"男",100d,new Address("北京","123456"),new int[] {1,2,3});
Student stu3 = new Student("王五",20,"男",100d,new Address("北京","123456"),new int[] {1,2,3});
oos.writeObject(stu);//对象写入
oos.writeObject(stu2);//对象写入
oos.writeObject(stu3);//对象写入
oos.flush();
// Object obj = ois.readObject();
// Student s = (Student)obj;
// System.out.println(obj);
// System.out.println(s.name);
//
// Object obj2 = ois.readObject();
// Student s2 = (Student)obj2;
// System.out.println(obj2);
// System.out.println(s2.name);
//
// Object obj3 = ois.readObject();
// Student s3 = (Student)obj3;
// System.out.println(obj3);
// System.out.println(s3.name);
// Object obj4 = ois.readObject();//对象没了,读到了末尾
// Student s4 = (Student)obj4;
// System.out.println(obj4);
// System.out.println(s4.name);
while(true) {
try {
Object obj1 = ois.readObject();
System.out.println(obj1.toString());
}catch(Exception e) {
//到达文件末尾 获得EOFException 就停止循环
break;
}
}
//static 依旧是属于类的,会影响序列化
}
}
//对象自身要支持序列化
//属性也要支持序列化,String是直接的,Integer和Double是间接的,因为它们有一个共同的父类Number实现了Sreializable接口
class Student implements Serializable{//实现了此接口,对象才可以序列化
String name;
Integer age;
String sex;
Double score;
transient Address add;//transient修饰的属性不参与序列化
//数组:基本数据类型可以序列化
int[] nums = new int[3];
//引用数据类型必须实现Serializable接口
public Student(String name, Integer age, String sex, Double score, Address add, int[] nums) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.score = score;
this.add = add;
this.nums = nums;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score + ", nums="
+ Arrays.toString(nums) + "]";
}
}
class Address implements Serializable{
String position;
String zipCode;
public Address(String position, String zipCode) {
super();
this.position = position;
this.zipCode = zipCode;
}
@Override
public String toString() {
return "Address [position=" + position + ", zipCode=" + zipCode + "]";
}
}
3.输入字节流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestFileInputStream {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("target.txt");
//int n = fis.read();//一次读一个字节
//System.out.println((char)n);
//读到-1,就代表到达了文件的末尾!
// while(true) {
// int n = fis.read();//一次读一个字节
// if(n==-1) {//文件末尾
// break;//停止读的操作
// }
// System.out.println((char)n);
// }
byte[] bytes = new byte[4];//该数组作为读取时的存储
while(true) {
int count = fis.read(bytes);//每次读取到的有效字节个数
if(count == -1) {
break;
}
//读多少个,打印多少个!
for(int i=0;i<count;i++) {
System.out.print((char)bytes[i]);
}
System.out.println("\n");
}
}
}
4.输出字节流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestOutputStream {
public static void main(String[] args) throws IOException{
//1.输出字节流OutputStream
//2.输出字节节点流,具有实际传输数据的功能(文件路径,boolean append) true代表追加,不覆盖
//路径正确 但是文件不存在,则会自动创建一个文件
//绝对路径:"E:\\target.txt" 必须存在!
//相对路径:"Files\\target.txt" 与上一种形式等价。相对于当前项目的路径下,寻找该路径和文件
FileOutputStream fos = new FileOutputStream("E:\\qianfengjava\\day31\\target.txt");
FileInputStream fis = new FileInputStream("E:\\qianfengjava\\day31\\target.txt");
//String s = "你";
//byte[] bs = s.getBytes();
//System.out.println(bs[0]+"\t"+bs[1]);
//fos.write(bs);
fos.write(65); //输出单个字节
fos.write(66);
fos.write(67);
fos.write('D');
byte[] bytes = new byte[] {65,66,67,68,69,70,'G'};
fos.write(bytes);//一次输出一组字节!
//字节数组 起始下标 长度
fos.write(bytes,1,3);
//ABCDABCDEFGBCD
System.out.println((char)fis.read());//读取到A
System.out.println((char)fis.read());//读取到B
byte[] b = new byte[10];
System.out.println(fis.read(b));//返回值为数组中有效字符个数
System.out.println(fis.read(b));//返回值为数组中有效字符个数
System.out.println((char)b[0]);//
System.out.println((char)b[1]);//
System.out.println((char)b[2]);//
System.out.println((char)b[3]);//
System.out.println((char)b[4]);//
byte[] b2 = new byte[10];
System.out.println(fis.read(b2,1,3));//继续按顺序读取fis节点输入流中的数据,读取到的字节数
//据放入到b2数组,从下标1开始,长度为3,返回值为有效字节数(2,因为放入C,D
//两个字符后没有了)
System.out.println(b2[0]);//0
System.out.println((char)b2[1]);//C
System.out.println((char)b2[2]);//D
System.out.println(b2[3]);//0
}
}
5.字节过滤流
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestBufferedOutput {
public static void main(String[] args) throws IOException {
//有参构造需要一个字节输出节点流
//先创建字节输出节点流
FileOutputStream fos = new FileOutputStream("E:\\qianfengjava\\day31");
//增强节点流
BufferedOutputStream bos = new BufferedOutputStream(fos);
//过滤流的write方法,是先写入到缓冲区数组里!
bos.write('A');
bos.write('B');
bos.write('C');
bos.write('D');
bos.flush();//刷新缓冲区(将缓冲区的数据,一次性写入到文件中,并清空当前缓冲区)
bos.write('E');
bos.write('F');
// bos.flush();
bos.close();//级联的执行了flush();,释放资源的同时,将缓冲器的数据一次性写入到文件里
}
}
6.File类
import java.io.File;
import java.io.IOException;
public class TestFiles {
public static void main(String[] args) throws IOException, InterruptedException {
File file = new File("E:\\test\\work.txt");
// System.out.println(file.canExecute());//所有可以打开的文件或文件夹,都是可执行的
// System.out.println(file.canWrite());//能不能修改文件
// System.out.println(file.canRead());//能不能执行文件
//
// System.out.println(file.createNewFile());//新建一个文件,如果不存在的话
//
// System.out.println(file.delete());//如果文件存在则删除,返回true
// Thread.sleep(2000);
// file.deleteOnExit();//JVM终止时,执行删除文件
System.out.println(file.exists());//路径文件或目录是否存在
System.out.println(file.getAbsolutePath());//绝对
System.out.println(file.getPath());//相对
System.out.println(file.getName());//文件名 名字.后缀
System.out.println(file.getFreeSpace()/1024/1024/1024);//获取硬盘的空闲空间,单位G
System.out.println(file.getTotalSpace()/1024/1024/1024);//获取硬盘总空间 单位G
System.out.println(file.getParent());//指定文件的上一级目录
System.out.println(file.isDirectory());//判断是否为文件夹
System.out.println(file.isFile());//判断是否为文件
System.out.println(file.isHidden());//判断文件是否为隐藏
System.out.println((System.currentTimeMillis()-file.lastModified())/1000/60);//获取文件最后一次修改时间
System.out.println(file.length());//文件内容的字节长度
System.out.println(file.canWrite());
file.mkdirs();
}
}
import java.io.File;
import java.io.FileFilter;
public class TestListFiles {
public static void main(String[] args) {
File file = new File("E:\\qianfengjava");
String[] fileNames = file.list();//获取文件夹中的所有文件(包含文件夹)的名字 String类型
for(String fname : fileNames) {//遍历
System.out.println(fname);
}
File[] files = file.listFiles(new MyFilter());//获取文件夹中的所有文件(包含文件夹)的对象 File类型
for(File f : files) {
System.out.println(f.getName());
}
// for(File f : files) {
// if(f.isFile()) {//判断是否是一个文件
// if(f.getName().endsWith(".doc")) {//判断结尾是否是.doc
// System.out.println(f.getName());
// }
// }
// System.out.println(f.getName()+":"+f.isFile());
// }
}
}
class MyFilter implements FileFilter{//过滤器,筛选出以.doc结尾的文件
@Override
public boolean accept(File pathname) {//true就保存,false就过滤
// TODO Auto-generated method stub
if(pathname.isFile()) {//先判断是不是一个文件
if(pathname.getName().endsWith(".doc")) {//再判断是不是以.doc结尾
return true;//保存
}
}
return false;//过滤
}
}
import java.io.File;
import java.io.FileFilter;
public class TestShowAllFiles {
static int count = 0;
public static void main(String[] args) {
//1.遍历E盘下,所有是.class为结尾的文件!
File file = new File("E:\\");
showall(file);
System.out.println("一共"+count+"个文件");
}
public static void showall(File dir) {
File[] files = dir.listFiles(new FileFilter() {//这是一个匿名内部类
@Override
public boolean accept(File f) {
if(f.isDirectory()) {//判断是否是文件夹 是的话保存到files数组
return true;
}
if(f.isFile()) {//判断是否是文件
if(f.getName().endsWith(".class")) {//判断是否是以.class结尾
return true;
}
}
return false;
}
});
//循环遍历输出
if(files != null) {//先判断数组不是空再进行遍历,否则会空指针异常
for(File f : files) {
if(f.isFile()) {//如果是文件 打印
System.out.println(f.getName());
count++;//每输出一个加1,计数.class结尾文件的数量
}else {
showall(f);//如果是文件夹 递归调用,再次过滤符合要求的内容
}
}
}
}
}
7.字符流
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class TestBuffered {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("Files\\buf.txt");
// BufferedWriter bw = new BufferedWriter(fw);//过滤流
// bw.write("Hello");
// bw.newLine();//根据平台提供的换行符
//过滤流! 比BufferedWriter更为方便!提供了println()打印后换行的方法
PrintWriter pw = new PrintWriter(fw);
pw.write("Hello");
pw.write("world");
pw.write("SayGoodBye");
pw.flush();
//-----------字符输入过滤流
FileReader fr = new FileReader("Files\\buf2.txt");
BufferedReader br = new BufferedReader(fr);
String str = br.readLine();//文件末尾返回的是null
System.out.println(str);
}
}
8.桥转换流
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
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.io.PrintWriter;
import java.io.UnsupportedEncodingException;
public class TestConvertStream {
public static void main(String[] args) throws IOException {
//1.字节输出流
OutputStream os = new FileOutputStream("Files\\convert.txt");//这是一个字节输出流
//编码 2.转换为字符输出流
OutputStreamWriter osw = new OutputStreamWriter(os,"GBK");//指定输出的数据 编码格式
osw.write("你好世界");
osw.flush();
//换行输出 3.包装字符过滤流
PrintWriter pw = new PrintWriter(osw);
// PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream));
pw.println("你好世界");
pw.println("你好java");
pw.println("你好web");
pw.flush();
//----------------
//字节输出流
InputStream is = new FileInputStream("Files\\convert.txt");
//解码 2.转换为字符输入流
InputStreamReader isr = new InputStreamReader(is,"GBK");
char[] chars = new char[4];
isr.read(chars);
for(int i=0;i<chars.length;i++) {
System.out.print(chars[i]);
}
//3.包装祖父过滤流
BufferedReader br = new BufferedReader(isr);
while(true) {
String s = br.readLine();
if(s==null) {
}
}
}
}
9.字符编码
import java.io.UnsupportedEncodingException;
public class TestEncodiong {
public static void main(String[] args) throws UnsupportedEncodingException {
String str = "你好世界123abc";//文本内容!
//编码 文本--》二进制
byte[] bs = str.getBytes("GBK");//获得字符串的二进制表现形式
for (int i = 0; i < bs.length; i++) {
System.out.println(bs[i]);
}
//解码 二进制---》文本
String str2 = new String(bs,"BIG5");
System.out.println(str2);
byte[] bs2 = str2.getBytes("BIG5");
String str3 = new String(bs2,"GBK");
System.out.println(str3);
String s1 = "你好陶喆abc123";
//编码 字符集是一致的
byte[] b = s1.getBytes("UTF-8");
//解码 字符集是一致的
String s2 = new String(b,"UTF-8");
System.out.println(s2);
}
}