/** 输入流冲常用方法说明：
* read() 从输入流中读取数据的下一个字节。返回 0 ~ 255 范围内的 int 字节值。
* 如果因为已经到达流末尾而没有可用的字节，则返回值为 -1
*
* read(byte[] b) 从输入流中读入一定长度的字节，并以证书的形式返回字节数
*
* mark(int readlimit) 在输入流的当前位置放置一个标记。readlimit 参数告知此输入流在标记位置
* 失效之前允许读取的字节数
*
* reset() 将输入指针返回到当前所做的标记处
*
* skip(long n) 跳过输入流上的 n 个字节并返回实际跳过的字节数
*
* markSupported() 如果当前流支持 mark() / reset() 操作就返回 true
*
* close() 关闭此输入流并释放与该流关联的所有系统资源
*/
/** 输出流常用方法
* write(int b) 将制定的字节写入此输出流
*
* write(byte[] b) 将 b 个字节从制定的 byte 数组写入此输出流
*
* write(byte[] b, int off, int len) 将制定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
*
* flush() 彻底完成输出并清空缓存区
*
* close() 关闭输出流
*/
面向字符的输入输出流
/**
* FileReader 类读取文件
*/
public static void useFileReaderReadFile() throws IOException {
FileReader b=new FileReader("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/ReadMe.txt");
char a[]=new char[1000]; //创建可容纳 1000 个字符的数组
int num=b.read(a); //将数据读入到数组 a 中，并返回字符数
String str=new String(a,0,num); //将字符串数组转换成字符串
System.out.println("读取的字符个数为："+num+"\n内容为：\n" + str);
}
/**
* 使用 FileWrite写入文件
* @throws IOException
*/
public static void useFileWriterWriteFile() throws IOException{
FileWriter fileWriter =new FileWriter("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/WriteMe.txt");
for(int i=0;i<10;i++){
fileWriter.write("用 FileWriter 写入文字内容\n");
}
System.out.println("FileWriter 写入文件成功");
fileWriter.close();
}
/**
* 使用 BufferedReader 类读取文件
*/
public static void useBufferedReaderReadFile() throws IOException{
String OneLine;
int count = 0;
try{
FileReader fileReader =new FileReader("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/ReadMe.txt");
BufferedReader bufferedReader =new BufferedReader(fileReader);
while((OneLine = bufferedReader.readLine())!=null){ //每次读取 1 行
count++; //计算读取的行数
System.out.println(OneLine + "\n");
}
System.out.println("\n 共读取了 "+count+" 行");
bufferedReader.close();
}
catch(IOException io){
System.out.println("出错了!"+io);
}
}
/**
* 使用 BufferedWriter 写入文件
* @throws IOException
*/
public static void useBufferedWriterWriteFile() throws IOException{
String str;
BufferedReader in = new
BufferedReader(new FileReader("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/ReadMe.txt"));
BufferedWriter out = new
BufferedWriter(new FileWriter("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/WriteMe.txt"));
while((str=in.readLine())!=null){
out.write(str); //将读取到的 1 行数据写入输出流
System.out.println(str);
}
out.flush();
in.close();
out.close();
}
面向字节的输入输出流
/**
* 使用 InputStream 读取数据
* 好处：节省空间
* @throws IOException
*/
public static void useInputStream() throws IOException{
File readFile = new File("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/ReadMe.txt");
InputStream inputStream = new FileInputStream(readFile);
byte[] b = new byte[(int)readFile.length()];
System.err.println("文档内容长度为："+readFile.length());
// 1.1 全字节读取
inputStream.read(b);
inputStream.close();
System.err.println(new String(b));
// 1.2 逐字节读取
// int count = 0;
// int temp = 0;
// // 注意：当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。
// while((temp = inputStream.read()) != -1){
// b[count++] = (byte)temp;
// }
// inputStream.close();
// System.err.println(new String(b));
}
/**
* 使用 OutputStream 写入数据
* @throws IOException
*/
public static void useOutputStream() throws IOException{
File writeFile = new File("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/WriteMe.txt");
OutputStream outputStream = new FileOutputStream(writeFile);
// 开启添加模式
// OutputStream outputStream = new FileOutputStream(writeFile, true);
byte[] b2 = "DAXIE,xiaoxie大哥，恭喜你，终于把我给打印出来啦，我是神屌丝，继续努力哦\n".getBytes();
outputStream.write(b2);
int temp = 0;
// 下面是逐字节写入
for (int i = 0; i < b2.length; i++) {
outputStream.write(b2[i]);
// 大写转换为小写
// outputStream.write(Character.toLowerCase(b2[i]));
}
outputStream.close();
}
小测试
/**
* 通过程序创建一个文件，从键盘输入字符，
* 当遇到字符“#”时结束，在屏幕上显示该文件的所有内容
*/
public static void test1(){
char ch;
int dataIndex;
try{
/**
* FileDescriptor 是 java.io 中的一个类，该类不能实例化，
* 其中包含三个静态成员：in、out 和err，分别对应于标准输入流、标准输出流和标准错误流，
* 利用它们可以在标准输入输出流上建立文件输入输出流，实现键盘输入或屏幕输出操作。
*/
// 读取数据在控制台
FileInputStream in = new FileInputStream(FileDescriptor.in);
// 写入数据到具体文件
FileOutputStream outPath = new FileOutputStream("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/WriteMe.txt"); //创建文件输出流对象
System.out.println("请输入字符，以#号结束：");
while((ch = (char)in.read()) != '#'){
outPath.write(ch);
}
System.out.println("输入结束，文件已写入到 WriteMe.txt 中\n");
in.close();
outPath.close();
// 读取数据从具体文件
FileInputStream inPath = new FileInputStream("/Users/panzhangbao/Desktop/Java/JavaIO/src/pan/WriteMe.txt");
// 写入数据到控制台
FileOutputStream out = new FileOutputStream(FileDescriptor.out);
System.out.println("读取具体文件数据开始");
// inPath.available() 为文件的大小
while(inPath.available() > 0){
dataIndex = inPath.read();
out.write(dataIndex);
}
System.out.println("\n读取具体文件数据结束");
inPath.close();
out.close();
}
catch(FileNotFoundException e){
System.out.println("找不到该文件！");
}
catch(IOException e){}
}
/**
* 输入一串字符显示出来，并显示 System.in 和 System.out 所属的类
* @throws IOException - 此处输入中文暂时未解决
*/
public static void test2() throws IOException{
byte a[] = new byte[128]; //设置输入缓冲区
System.out.print("请输入字符串：");
// 最后是输入字符的个数
int count = System.in.read(a); //读取标准输入输出流
System.out.println("输入的 ASCII 值是：");
for(int i = 0;i < count;i++)
System.out.print(a[i]+""); //输出数组元素的 ASCII 值
System.out.println();
System.out.println("输入的字符（暂时无法处理中文字符）是：");
for(int i = 0;i < count-2;i++) { //不显示回车和换行符
System.out.print((char) a[i] + ""); //按字符方式输出元素
}
Class inClass = System.in.getClass();
Class outClass = System.out.getClass();
System.out.print("\nin 所在的类为：" + inClass.toString());
System.out.print("\nout 所在的类为：" + outClass.toString());
}
压缩
//使用java.util.zip原生ZipOutputStream与ZipEntry会中文乱码
//import java.util.zip.ZipOutputStream;
//import java.util.zip.ZipEntry;
//使用org.apache.tools.zip这个就不会中文乱码
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;
import java.io.*;
import java.util.Enumeration;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.CheckedOutputStream;
//需要压缩的文件夹完整路径
static String filePath = "/Users/panzhangbao/Desktop/待压缩文件夹名/";
//需要压缩的文件夹名
static String fileName = "待压缩文件夹名";
//压缩完成后保存为小笨蛋.zip文件，名字随意
static String outPath = "/Users/panzhangbao/Desktop/压缩文件名.zip";
// 需要解压的文件（夹）完整路径
static String zipPath = "/Users/panzhangbao/Desktop/压缩文件名.zip";
// 解压后的文件（夹）完整路径
static String unzipedFilePath = "/Users/panzhangbao/Desktop/解压后文件夹名/";
public static void main(String[] args) throws Exception {
// zipFileMethod();
unzipFileMethod();
}
/**
* 压缩文件或者文件夹
* @throws Exception
*/
public static void zipFileMethod() throws Exception {
OutputStream outputStream = new FileOutputStream(outPath);//创建 压缩文件名.zip文件
CheckedOutputStream checkedOutputStream = new CheckedOutputStream(outputStream, new CRC32());//检查输出流,采用CRC32算法，保证文件的一致性
ZipOutputStream zipOutputStream = new ZipOutputStream(checkedOutputStream);//创建zip文件的输出流
zipOutputStream.setEncoding("GBK");//设置编码，防止中文乱码
File file = new File(filePath);//需要压缩的文件或文件夹对象
ZipFile(zipOutputStream,file);//压缩文件的具体实现函数
zipOutputStream.close();
checkedOutputStream.close();
outputStream.close();
System.out.println("压缩完成");
}
//递归，获取需要压缩的文件夹下面的所有子文件,然后创建对应目录与文件,对文件进行压缩
public static void ZipFile(ZipOutputStream zipOutputStream, File file) throws Exception
{
if(file.isDirectory()) {
//创建压缩文件的目录结构
zipOutputStream.putNextEntry(new ZipEntry(file.getPath().substring(file.getPath().indexOf(fileName))+File.separator));
for(File f : file.listFiles()) {
ZipFile(zipOutputStream,f);
}
}
else {
//打印输出正在压缩的文件
System.out.println("正在压缩文件:"+file.getName());
//创建压缩文件
zipOutputStream.putNextEntry(new ZipEntry(file.getPath().substring(file.getPath().indexOf(fileName))));
//用字节方式读取源文件
InputStream inputStream = new FileInputStream(file.getPath());
//创建一个缓存区
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
//字节数组,每次读取1024个字节
byte [] bytes = new byte[1024];
//循环读取，边读边写
while(bufferedInputStream.read(bytes)!=-1)
{
zipOutputStream.write(bytes); //写入压缩文件
}
//关闭流
bufferedInputStream.close();
inputStream.close();
}
}
/**
* 解压缩文件或者文件夹
* @throws Exception
*/
public static void unzipFileMethod() throws IOException {
ZipFile zipFile = new ZipFile(zipPath,"GBK");//压缩文件的实列,并设置编码
//获取压缩文中的所有项
for(Enumeration<ZipEntry> enumeration = zipFile.getEntries(); enumeration.hasMoreElements();)
{
ZipEntry zipEntry = enumeration.nextElement();//获取元素
//排除空文件夹
if(!zipEntry.getName().endsWith(File.separator))
{
System.out.println("正在解压文件:"+zipEntry.getName());//打印输出信息
//创建解压目录
File file = new File(unzipedFilePath+zipEntry.getName().substring(0, zipEntry.getName().lastIndexOf(File.separator)));
//判断是否存在解压目录
if(!file.exists())
{
file.mkdirs();//创建解压目录
}
OutputStream outputStream = new FileOutputStream(unzipedFilePath+zipEntry.getName());//创建解压后的文件
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);//带缓的写出流
InputStream inputStream = zipFile.getInputStream(zipEntry);//读取元素
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);//读取流的缓存流
CheckedInputStream checkedInputStream = new CheckedInputStream(bufferedInputStream, new CRC32());//检查读取流，采用CRC32算法，保证文件的一致性
byte [] bytes = new byte[1024];//字节数组，每次读取1024个字节
//循环读取压缩文件的值
while(checkedInputStream.read(bytes)!=-1)
{
bufferedOutputStream.write(bytes);//写入到新文件
}
checkedInputStream.close();
bufferedInputStream.close();
inputStream.close();
bufferedOutputStream.close();
outputStream.close();
}
else
{
//如果为空文件夹，则创建该文件夹
new File(unzipedFilePath+zipEntry.getName()).mkdirs();
}
}
System.out.println("解压完成");
zipFile.close();
}
}
网友评论