1.拼接路径
package cn.jbit.lesson.sep;
import java.io.File;
/**
* IO路径
* @author penny
*
*/
public class PathDemo01 {
public static void main(String[] args) {
String path = "D:\\e- java\\T\\622K~~$WS5SR}9S~[E5JS5S.png";
System.out.println(File.separator);
//建议
//1./
path = "D:/e- java/T/622K~~$WS5SR}9S~[E5JS5S.png";
System.out.println(path);
//2.常量拼接
path = "D:"+File.separator+"e- java"+File.separator+"T"+File.separator+"622K~~$WS5SR}9S~[E5JS5S.png";
System.out.println(path);
}
}
2.构造File对象的方法
package cn.jbit.lesson.sep;
import java.io.File;
/**
* 构造器
* @author MacBook
*
*/
public class FileDemo02 {
public static void main(String[] args) {
String path = "D:/e- java/T/622K~~$WS5SR}9S~[E5JS5S.png";
//1.构造File对象,
File src = new File(path);
System.out.println(src.length());
//2.从父路径名字符串和子路径名字符串创建新的 File实例
src = new File("D:/e- java/T","622K~~$WS5SR}9S~[E5JS5S.png");
System.out.println(src.length());
//3.从父抽象路径名和子路径名字符串创建新的 File实例
src=new File(new File("D:/e- java/T"),"622K~~$WS5SR}9S~[E5JS5S.png");
System.out.println(src.length());
}
}
3.文件状态标准代码
package cn.jbit.lesson.sep;
import java.io.File;
/**
* 文件状态标准代码
* @author MacBook
*
* 文件状态：
* 1.不存在：exists
* 2.存在
* 文件：isFile
* 文件夹：isDirectory
*
*
*/
public class FileStatus {
public static void main(String[] args) {
File src=new File("xxx");
if(null==src || !src.exists()) {
System.out.println("文件不存在");
}else {
if(src.isFile()) {
System.out.println("文件操作！");
}else {
System.out.println("文件夹操作");
}
}
}
}
4.createNewFile & delete
package cn.jbit.lesson.sep;
import java.io.File;
import java.io.IOException;
/**
* createNewFile 创建文件
* 注意：1.不能创建文件夹，只能创建文件
* 2.不存在才创建(返回true)
* 3.con是操作系统的设备名，不能正确的被创建
*
* delete 删除已经存在的文件
* @author MacBook
*
*/
public class FileDemo03 {
public static void main(String[] args) throws IOException {
//创建新的文件
File src = new File("D:/e- java/T/io.png");
boolean flag = src.createNewFile();
System.out.println(flag);
//并不是文件夹，而是一个没有后缀的文件
src = new File("D:/e- java/T");
flag = src.createNewFile();
System.out.println(flag);
//删除
flag = src.delete();
System.out.println(flag);
}
}
5.创建目录
package cn.jbit.lesson.sep;
import java.io.File;
/**
* 创建目录
* 1.mkdir():确保上级目录存在，不存在创建失败
* 2.mkdirs():上级目录可以不存在，不存在一同创建
* 推荐使用mkdirs
* @author MacBook
*
*/
public class DirDemo01 {
public static void main(String[] args) {
File dir = new File("D:/e- java/T/dir/test");
//创建目录 mkdirs()
boolean flag = dir.mkdirs();
System.out.println(flag);
//mkdir
dir = new File("D:/e- java/T/dir/test01");
flag = dir.mkdir();
System.out.println(flag);
}
}
6.下一级信息
package cn.jbit.lesson.sep;
import java.io.File;
/**
* 列出下一级
* 1、list():列出下级名称
* 2、listFile():列出下级File对象
* 3、listRoots():列出所有的盘符
* @author MacBook
*
*/
public class ListDemo01 {
public static void main(String[] args) {
File dir = new File("D:/e- java/T");
//下级名称
String[] subNames = dir.list();
for(String s:subNames) {
System.out.println(s);
}
//下级对象 listFile()
File[] subFiles = dir.listFiles();
for(File s:subFiles) {
System.out.println(s);
}
//盘符
File[] subRoots = dir.listRoots();
for(File s:subRoots) {
System.out.println(s.getAbsolutePath());
}
}
}
7.递归
（1）打印1-10的数
package cn.jbit.lesson.sep;
/**
* 递归
* @author MacBook
*
*/
public class Dirdemo02 {
public static void main(String[] args) {
printTen(1);
}
//打印1-10的数
public static void printTen(int num) {
//1.出口
if(num>10) { //递归头；结束递归
return;
}
System.out.println(num);
printTen(num+1);//自己调用自己
}
}
（2）使用递归查看文件目录
package cn.jbit.lesson.sep;
import java.io.File;
/**
* 使用递归查看文件目录
* @author MacBook
*
*/
public class DirDemo03 {
public static void main(String[] args) {
File src = new File("D:/e- java/T");
printName(src,1);
}
public static void printName(File src,int deep) {
/**
* 目的是查看这个文件所有层的下级的名字
* 思路：先判断是不是存在
* 存在则判断是不是目录
* 如果是目录就可以进行递归
*
*/
//为了输出的时候显示出层次感 ，加入了这样的代码
for(int i=0;i<deep;i++) {
System.out.print("*");
}
System.out.println(src.getName());
if(null ==src || !src.exists()) {
System.out.println("不存在！");
return;
}else if(src.isDirectory()){ //判断是目录
for(File s:src.listFiles()) {
printName(s,deep+1);
}
}
}
}
8.Byte
电脑：字节
人：字符
从字符->字节 叫做编码（encode）
从字节到字符叫解码(decode)
unicode 有定长和变长，定长是utf-16，统一2个字节，比较浪费空间，utf-16又分为utf-16BE(高字节低地址)和utf-16LE(低字节低地址)；变长是utf-8，英文1个字节，中文3个字节。
ANSI： 是中文的WINDOWS系统中的GBK
package cn.jbit.lesson.sep;
import java.io.UnsupportedEncodingException;
/**
* getBytes
* @author MacBook
*
*/
public class ByteDemo01 {
public static void main(String[] args) throws UnsupportedEncodingException{
//准备一个字符串
String msg = "性命生命使命";
//编码：字节数组
byte[] datas = msg.getBytes();
// System.out.println(datas.length);//18
//
// //编码其他字符集
// datas = msg.getBytes("UTF-16LE");
// System.out.println(datas.length);//12
//
// //编码其他字符集
// datas = msg.getBytes("GBK");
// System.out.println(datas.length);//12
//
//模拟服务远程传一个数组给我，要对其进行还原
//解码 ：从字节->字符
//构造器解码
//String(byte[] bytes, int offset, int length, Charset charset)
msg = new String(datas,0,datas.length,"utf-8");
System.out.println(msg);
/*
* 解码出现乱码，原因如下：
* 1）字节数不够
*/
msg = new String(datas,0,datas.length-2,"utf-8");
System.out.println(msg);
/*
* 2） 字符集不统一
*/
msg = new String(datas,0,datas.length,"gbk");
System.out.println(msg);
//注意：在进行编码的时候可以进行编制任何模式的字节码，但是在解码的时候必须与原有得格式保持一致，否则回出现乱码
}
}
9.字节流和字符流（输入流）
(1)第一个程序， 不标准的写法（便于理解）
package cn.lesson.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* 理解操作步骤：
* 1.创建源
* 2.选择流
* 3.操作（read \write）
* 注意：read读取数据时，如果数据不存在，则返回-1
* 4.释放资源
*
* @author MacBook
*
*/
public class IoTest01 {
public static void main(String[] args) {
//1.创建源
File src = new File("test.txt");
//2.选择流
try {
InputStream is = new FileInputStream(src);
//3.操作流（读取）
int temp1 = is.read();
int temp2 = is.read();
int temp3 = is.read();
int temp4 = is.read();
System.out.println((char)temp1);
System.out.println((char)temp2);
System.out.println((char)temp3);
System.out.println((char)temp4);
//4.释放资源
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
(2)标准的写法
先修改循环，再将释放流的过程放到finally中去，最后将is的作用域提升上去。
package cn.lesson.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* 理解操作步骤，标准：
* 1.创建源
* 2.选择流
* 3.操作（read \write）
* 注意：read读取数据时，如果数据不存在，则返回-1
* 4.释放资源
*
* @author MacBook
*
*/
public class IoTest01 {
public static void main(String[] args) {
//1.创建源
File src = new File("test.txt");
//2.选择流
InputStream is =null;
try {
is = new FileInputStream(src);
//3.操作流（读取）
int temp;
while((temp=is.read())!=-1) {
System.out.println((char)temp);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//4.释放资源
try {
if(is!=null){
is.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
（3）分段读取（以下4个代码重要）
package cn.lesson.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* 分段读取
* @author MacBook
*
*/
public class IoTest11 {
public static void main(String[] args) {
//1.创建源
File src = new File("test.txt");
//2.选择流
InputStream is = null;
try {
is = new FileInputStream(src);
//3.操作（分段读取）
byte[] flush = new byte[1024*10*5];//1024表示1K，*10 就是10k，再*5，就是50K，不要将它们算出来，这样写好维护
int len=-1;
while((len= is.read(flush))!=-1) {
String str = new String(flush,0,len);//解码
System.out.println(str);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//4.释放资源
try {
if(is!=null){
is.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
10.输出流
注意：(1)OutPutStream中创建源的时候文件可以不存在，会帮助我们自动创建一个，但是InPutStream就必须要存在才能进行操作。
（2）可以再后面追加 true:直接再后面追加，false :从第一个开始追加（相当于修改）
package cn.lesson.io;
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;
/**
* 操作步骤
* 1.创建源
* 2.选择流
* 3.操作（write）
* 4.释放资源
* @author MacBook
*
*/
public class IoTest16 {
public static void main(String[] args) {
//1.创建源
File src = new File("out.txt");
//2.选择流
OutputStream os = null;
try {
os = new FileOutputStream(src,false);
/*
* 3.操作（写入）
* 将字符串->字节，要编码
*/
//我们要写入的字符串
String str = "io is so easy";
//将字符串进行编码写入
byte[] b = str.getBytes();//编码
os.write(b,0,b.length );//写入
os.flush();//养成刷新的好习惯
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//4.释放
if(os!=null) {
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
11.复制
注意：先打开的流后关闭
package cn.lesson.io;
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;
public class CopyTest01 {
public static void main(String[] args) {
copy("out.txt","test12.txt");
}
public static void copy(String insrc,String outsrc) {
//1.创建源
File srcIn = new File(insrc);//文件存在的地方
File srcOut = new File(outsrc);//文件要去的地方
//2.选择流
InputStream is =null;//输入流
OutputStream os=null;//输出流
try {
is = new FileInputStream(srcIn);
os = new FileOutputStream(srcOut);
//3.操作（复制）读取 之后再输出
//读取
byte[] flush = new byte[1024];
int temp= -1;
while((temp = is.read(flush))!=-1) {
//写出去
os.write(flush, 0, flush.length);
}
os.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
if(os!=null) {
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(is!=null) {
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
12 .字符输入流
注意：字符输入流只能处理纯文本的文件，可以避免乱码的问题
代码和inputstream差不多，只需要修改选择流就行啦
package cn.lesson.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
/**
* 字符输入流
* 1.创建源
* 2.选择流
* 3.操作（read\write）
* 4.释放资源
* @author MacBook
*
*/
public class IoTestRead01 {
public static void main(String[] args) {
//1.创建源
File src = new File("test.txt");
//2.选择流
Reader is=null;
try {
is = new FileReader(src);
//3.操作
char[] flush = new char[1024];
int len=-1;
while((len= is.read(flush))!=-1) {
String str = new String(flush,0,len);
System.out.println(str);
}
//4.释放资源
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
13.字符输出流
和OutPutStream差不多的
但是有三种写法
package cn.lesson.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Writer;
/**
* 字符输出流
* 操作步骤
* 1.创建源
* 2.选择流
* 3.操作（write）
* 4.释放资源
* @author MacBook
*
*/
public class IoTest16 {
public static void main(String[] args) {
//1.创建源
File src = new File("out13.txt");
//2.选择流
Writer os = null;
try {
os = new FileWriter(src);
/*
* 3.操作（写入）
*
*/
// //写法一：我们要写入的字符串
// String str = "io is so easy哈哈哈";
// //将字符串进行编码写入
// char[] b = str.toCharArray();
// os.write(b,0,b.length );//写入
// os.flush();//养成刷新的好习惯
// //写法二：
// String str = "io is so easy哈哈哈";
// os.write(str);//直接放入Str
//// //如果只想输出一部分
//// os.write(str,0,4);
// os.flush();
//写法三
String str = "io is so easy哈哈哈";
os.append(str);//可以一直点下去
os.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//4.释放
if(os!=null) {
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
14.字节数组
之前文件是保存在硬盘上的，java并不能直接对其进行操作，需要虚拟机来对其进行操作 java -> os ->文件
现在的字节数组是存在内存中的，java可以对其直接进行操作
java-> 字节数组
- 任何东西都可以用字节数组
- 字节数组不用关闭（是java 的垃圾回收机制自从关闭）
- 字节数组可以无限添加，但是不要太大
（1)字节输入流ByteArrayInputStream
package cn.lesson.io;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* 字节数组输入流
* 1.创建源
* 2.选择流
* 3.操作
* 4.释放资源
* @author MacBook
*
*/
public class IoTestByte01 {
public static void main(String[] args) {
//1.创建源
byte[] b = "talk is cheap show me the code".getBytes();
//2.选择流
InputStream is=null;
try {
is = new ByteArrayInputStream(b);
//3.操作
byte[] flush = new byte[1024*10*5];
int len=-1;
while((len= is.read(flush))!=-1) {
String str = new String(flush,0,len);
System.out.println(str);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
//4.释放资源
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
(2)字节数组输出流
package cn.lesson.io;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
* 字节数组输出流
* 1.创建源： 不需要填入内容，因为在内存中是不确定的，所以java内部会维护。
* 2.选择流：不关联源（不适用多态，字节数组输入流是使用的多态）
* 3.操作（写出内容）
* 4.释放资源，可以不用释放。
*
* 获取数据
* toByteArray()
*
* @author MacBook
*
*/
public class IoTestByte05 {
public static void main(String[] args) {
//1.创建源
byte[] dest = null;
//2.选择流
ByteArrayOutputStream baos = null;
baos = new ByteArrayOutputStream();
//3.操作（写出）
String msg = "沙雕！";
byte[] datas = msg.getBytes();//字符串->字节
baos.write(datas,0,datas.length);
try {
baos.flush();
//获取数据
dest = baos.toByteArray();
System.out.println(dest.length+"-->"+new String(dest,0,dest.length));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
15.综合_对接流
思路：
文件->程序->字节数组->程序->文件
package cn.lesson.io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 对接流
* 1.将图片读取到字节数组中
* 2.将字节数组写出到图片中
* @author MacBook
*
*/
public class IoTestInner01 {
public static void main(String[] args) {
byte[] datas = fileToByteArray("p.png");
System.out.println(datas.length);
byteArrayToFile(datas,"pi.png");
}
/**
* 1.将图片读取到字节数组中
* 1）图片到程序 FileInPutStream
* 2）程序到字节数组 ByteArrayOutputStream
* @param filePath：文件的路径
*/
public static byte[] fileToByteArray(String filePath) {
//1.创建源
File src = new File(filePath);
byte[] dest = null;
//2.选择流
InputStream is =null;
ByteArrayOutputStream baos = null;
baos = new ByteArrayOutputStream();
try {
is = new FileInputStream(src);
//3.操作（分段读取）
byte[] flush = new byte[1024*10];//1024表示1K，*10 就是10k，再*5，就是50K，不要将它们算出来，这样写好维护
int len=-1;
while((len= is.read(flush))!=-1) {
baos.write(flush,0,len);//写出到字节数组中
}
baos.flush();
return baos.toByteArray();//返回数据
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//4.释放资源
try {
if(is!=null){
is.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
/**
* 2.将字节数组写出到文件中
* 1)字节数组读取到程序中 ByteArrayInputStream
* 2）程序写出到图片文件中 FileOutputStream
* @param src ：字节数组的数据源
* @param filePath ：文件路径
*/
public static void byteArrayToFile(byte[] src,String filePath) {
//1.创建源
File dest = new File(filePath);
//2.选择流
InputStream is=null;
OutputStream os = null;
try {
is = new ByteArrayInputStream(src);
os = new FileOutputStream(dest);
//3.操作
byte[] flush = new byte[1024*10*5];
int len=-1;
while((len= is.read(flush))!=-1) {
os.write(flush,0,len );//写入
}
os.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
if(os!=null) {
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
16.封装拷贝文件
package cn.lesson.io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
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;
/**
* 1.封装拷贝
* 2.封装释放资源
* @author MacBook
*
*/
public class EncapsulationCopy {
public static void main(String[] args) {
//文件->文件
try {
InputStream is =new FileInputStream("out.txt");
OutputStream os = new FileOutputStream("output.txt");
copy(is,os);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//从文件->字节数组
byte[] datas =null;
try {
InputStream is =new FileInputStream("p.png");
ByteArrayOutputStream os = new ByteArrayOutputStream();
copy(is,os);
datas = os.toByteArray();
System.out.println(datas.length);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//字节数组->文件
try {
ByteArrayInputStream is =new ByteArrayInputStream(datas);
OutputStream os = new FileOutputStream("po.png");
copy(is,os);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 对接输入输出流
* @param is
* @param os
*/
public static void copy(InputStream is,OutputStream os) {
try {
//3.操作（复制）读取 之后再输出
//读取
byte[] flush = new byte[1024];
int temp= -1;
while((temp = is.read(flush))!=-1) {
//写出去
os.write(flush, 0, flush.length);
}
os.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
close(is,os);
}
}
/**
* 不是很正确的close方法，目的是拿来理解下面的close
* @param is
* @param os
*/
public static void close(InputStream is,OutputStream os) {
if(os!=null) {
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(is!=null) {
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 释放资源正确的close代码，但是现在已经不用了，作为参考看看吧
* 新版本的释放资源直接在前面try(is,os){} 就行啦。不要finally了
* @param ios
*/
public static void copy(Closeable...ios) {
for(Closeable io:ios) {
if(io!=null) {
try {
io.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}