IO流学习

IO流:存储和读取数据的解决方案

 

 

import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//1.创建对象//写出 输入流 OutputStream//本地文件fileFileOutputStream fos =new FileOutputStream("basic-code\\1.txt");//写出数据fos.write(97);//释放资源fos.close();}
}

 

 

import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("basic-code\\1.txt");//fos.write(97);//fos.write(98);byte[] bytes={97,98,99,100,101};//fos.write(bytes);fos.write(bytes,1,3);fos.close();}
}

 

import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("basic-code\\1.txt");String str ="yjybainchangsigema";byte[] bytes = str.getBytes();// System.out.println(Arrays.toString(bytes));fos.write(bytes);String str2 = "\r\n";byte[] bytes1 = str2.getBytes();fos.write(bytes1);String str3 = "come on";byte[] bytes2 = str3.getBytes();fos.write(bytes2);fos.close();}
}

 

import java.io.FileInputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {FileInputStream fio =new FileInputStream("basic-code\\1.txt");int read = fio.read();System.out.println(read);fio.close();}
}

import java.io.FileInputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//字节输入流循环读取FileInputStream fis =new FileInputStream("baisc-code\\1.txt");int b;/** read:表示读取数据,而且是读取一个数据就移动一次指针* 如果没有变量b* 假设文件数据abcde* while((fis.read())!=-1){System.out.println(fis.read);* 相当于a!=-1      输出b*       c!=-1      输出d*       e!=-1      输出-1* 因此第三方变量必须写* */while((b=fis.read())!=-1){System.out.println((char)b);}fis.close();}
}

文件拷贝的基本代码(小文件)

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//文件拷贝//1.创建对象FileInputStream fis =new FileInputStream("D:\\iii\\movie.mp4");FileOutputStream fos = new FileOutputStream("basic-code\\copy.mp4");//2.拷贝//核心思想:边读边想int b;while((b =fis.read())!=-1){fos.write(b);}//3.释放资源//规则:先开的最后关闭fos.close();fis.close();}
}

 

 

import java.io.FileInputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//1.创建对象FileInputStream fis = new FileInputStream("basic-code\\1.txt");//2.读取数据byte[] bytes = new byte[2];//一次读取多个字节数据 具体多少 跟数组的长度有关//返回值 本子读取到多少个字节数据int len1 = fis.read(bytes);System.out.println(len1);//2String str1 = new String(bytes);System.out.println(str1);int len2 = fis.read(bytes);System.out.println(len2);//2String str2 = new String(bytes);System.out.println(str2);int len3 = fis.read(bytes);System.out.println(len3);//2String str3 = new String(bytes);System.out.println(str3);fis.close();}
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//文件拷贝改写long start = System.currentTimeMillis();FileInputStream fis = new FileInputStream("D:\\aaa");FileOutputStream fos = new FileOutputStream("baisc-code\\a");int len;byte[] bytes =new byte[1025*1024*5];while((len=fis.read())!=-1){fos.write(bytes,0,len);}fos.close();fis.close();long end = System.currentTimeMillis();System.out.println(end-start);}
}

 

 字符集详解(ASCII, GBK)

 

 

 

 

 

 

 

 

import java.io.FileInputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//字节流读取中文会出现乱码FileInputStream fis = new FileInputStream("basic-code\\a");int b;while((b= fis.read())!=-1){System.out.println((char)b);}fis.close();}
}

数据流一个个拷贝 肯定就会出现乱码

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//1.创建对象FileInputStream fis = new FileInputStream("basic-code\\a.txt");FileOutputStream fos =new FileOutputStream("basic-code\\1.txt");//2.拷贝int b;while((b=fis.read())!=-1){fos.write(b);}//3.释放资源fos.close();fis.close();}
}

记事本!数据不会丢失目的地和数据源保持一致

 

 

import java.io.IOException;
import java.util.Arrays;public class Test {public static void main(String[] args) throws IOException {//1.编码String str ="ai你哟";byte[] bytes1 = str.getBytes();System.out.println(Arrays.toString(bytes1));//???byte[] bytes2 = str.getBytes("GBK");System.out.println(Arrays.toString(bytes2));//???//2.解码String str2 = new String(bytes1);System.out.println(str2);String str3 = new String(bytes1,"GBK");System.out.println(str3);}
}

 

 

 

 

import java.io.FileReader;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//1.创建对象并关联本地文件FileReader fr = new FileReader("basic-code\\1.txt");//2.读取数据 read()//字符流的底层也是字节流,默认也是一个字节一个字节的读取的.//如果遇到中文就会一次读取多个 GBK依次读两个字节,UTF-8一次读三个字节//在读取之后 方法的底层还会进行解码并转成十进制//最终把这个十进制作为返回值//这个十进制的数据也表示在字符集上的数字// 英文:文件里面二进制数据 0110 0001//read方法进行获取a,解码并转成十进制97//中文:文件里面的二进制数据 11100110  10110001  10001001//read方法进行读取,解码并转成十进制27721//我想看到中文汉字 就是把这些十进制数据 进行强转int ch;while((ch=fr.read())!=-1){System.out.print((char)ch);}//释放资源fr.close();}
}

import java.io.FileReader;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//1.创建对象FileReader fr =new FileReader("basic-code\\1.txt");//2.读取数据char[] chars =new char[2];int len;//fr.read();//读取数据,解码,强转三步合并了,把强转之后的字符放到数组当中//空参的read()+强制类型转换while((len = fr.read(chars))!=-1){//把数组中的数据变成字符串再进行打印System.out.println(new String(chars,0,len));}//3.释放资源fr.close();}
}
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//字节输出流:FileOutputStream fos = new FileOutputStream("basic-code\\1.txt");fos.write(97);//字节流 每次只能操作一个字节 255fos.close();//字符输出流:FileWriter fw =new FileWriter("basic-code\\a.txt");fw.write(7777);//根据字符集的编码方式进行编码 把编码之后的数据写到文件中去fw.close();FileWriter fw1= new FileWriter("basic-code\\1.txt",true);//续写开关//fw1.write("你好");char[] chars ={'a','b','c','我'};fw.write(chars);fw1.close();}
}

 

 

 

 

 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//拷贝文件夹 考虑子文件//1.创建对象表示数据源File src =new File("D:\\aaa\\src");//2.创建对象表示目的地File dest = new File("D:\\aaa\\dest");//调用方法开始拷贝copydir(src,dest);}/** 作用:拷贝文件夹* 参数一:数据源* 参数二:目的地** */private static void copydir(File src, File dest) throws IOException {dest.mkdirs();递归//进入数据源File[] files = src.listFiles();//遍历数组for (File file : files) {if(file.isFile()){//判断文件 拷贝 FileInputStream fis =new FileInputStream(file);FileOutputStream fos =new FileOutputStream(new File(dest,file.getName()));byte[] bytes = new byte[1024];int len;while((len=fis.read(bytes))!=-1){fos.write(bytes,0,len);}fos.close();fis.close();}else{//判断文件夹 递归copydir(file,new File(dest,file.getName()));}}}
}


        //文件加密//原始文件FileInputStream fis =new FileInputStream("C:\\girl.jpg");//加密处理FileOutputStream fos =new FileOutputStream("C:\\ency.jpg");//加密处理int b;while((b=fis.read())!=-1){fos.write(b ^2);//随便异或一个数字}fos.close();fis.close();//这个程序操作完成后就可以将源文件删除了 这样别人也不知道是什么东西等到你想看了//你再进行解密
      //前置知识/**  ^:异或* 两边相同:false* 两边不同:true*  0:false*  1:true** 100:110100* 10:1010**      1100100*     ^0001010* ________________*      1101110    --->110*   ^  0001010* ________________*      1100100    --->100* System.out.println(100^10);//110* System.out.println(100^10^10);//100** *///文件加密//原始文件FileInputStream fis =new FileInputStream("C:\\ency.jpg");//加密处理FileOutputStream fos =new FileOutputStream("C:\\redu.jpg");//加密处理int b;while((b=fis.read())!=-1){fos.write(b ^2);//随便异或一个数字}fos.close();fis.close();//这个程序操作完成后就可以将源文件删除了 这样别人也不知道是什么东西等到你想看了//你再进行解密

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) throws IOException {//修改文件中的数据//1.读取数据FileReader fr =new FileReader("basic-code\\a.txt");StringBuilder sb =new StringBuilder();int ch;while((ch = fr.read())!=-1){sb.append((char)ch);}fr.close();System.out.println(sb);//2.排序String str =sb.toString();String[] arrstr =str.split("-");ArrayList<Integer>list = new ArrayList<>();for (String s : arrstr) {int i = Integer.parseInt(s);list.add(i);}//System.out.println(list);Collections.sort(list);//3.写出FileWriter fw =new FileWriter("basic-code\\a.txt");for (int i = 0; i < list.size(); i++) {if(i==list.size()-1){fw.write(list.get(i)+"");//如果直接写数字 文件会变成ASCII码}else{fw.write(list.get(i)+"-");}}fw.close();}
}

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
//细节:文件中的数据不要换行  如果加了换行会有\r\n 读取也会读到
//bom头---占三个字节   编码改为ANSI
public class Test {public static void main(String[] args) throws IOException {//修改文件中的数据//1.读取数据FileReader fr =new FileReader("basic-code\\a.txt");StringBuilder sb =new StringBuilder();int ch;while((ch = fr.read())!=-1){sb.append((char)ch);}fr.close();System.out.println(sb);//2.排序Integer[] arr = Arrays.stream(sb.toString().split("-")).map(Integer::parseInt).sorted().toArray(Integer[]::new);//System.out.println(arr);//3.写出FileWriter fw = new FileWriter("C:\\yjy");String s = Arrays.toString(arr).replace(", ","-");String result = s.substring(1,s.length()-1);//System.out.println(result);fw.write(result);fw.close();}
}

 

 

public class Test {public static void main(String[] args) throws IOException {//1.创建缓冲流的对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("basic-code\\a.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("basic-code\\1.txt"));//2.循环读取int b;while ((b = bis.read()) != -1) {bos.write(b);}//3.释放资源bos.close();bis.close();}
}
public class Test {public static void main(String[] args) throws IOException {//一次读写一个字节数组BufferedInputStream bis = new BufferedInputStream(new FileInputStream("basic-code\\a.txt"));BufferedOutputStream bos =new BufferedOutputStream(new FileOutputStream("basic-code\\b.txt"));byte[] bytes =new byte[1024];int len;while((len=bis.read(bytes))!=-1){bos.write(bytes,0,len);}bos.close();bis.close();}
}

 

 

 

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {//两个缓冲区之间这不也是一个字节一个字节的进行倒手的吗?? 速度为什么快了?//因为这一段是在内存中运行的速度非常的快/*字符缓冲输入流:* 构造方法:public BufferedReader(Reader r)* 特有方法:public String readLine() 读一整行*///readLine 方法在读取的时候 一次读一整行 遇到空格换行结束//但是他不会把回车读到内存当中 //1.创建字符缓冲输入流的对象BufferedReader br =new BufferedReader(new FileReader("basic-code\\1.txt"));//2.读取数据
//        String line = br.readLine();
//        System.out.println(line);String line;while((line=br.readLine())!=null){System.out.println(line);}//释放资源br.close();}
}
public class Test {public static void main(String[] args) throws IOException {/*字符缓冲输出流* 构造方法:public BufferedWriter(writer r)* 特有方法:public void newLine() 跨平台换行*///1.创建字符缓冲输出流的对象BufferedWriter bw =new BufferedWriter(new FileWriter("b.txt"));//2.写出数据bw.write("你嘴角上扬的样子,百度搜索不到");bw.newLine();bw.write("以后我结婚你一定要来 ,没有新娘我会很尴尬");//3.释放资源bw.close();}
}

import java.io.*;public class Test {public static void main(String[] args) throws IOException {//拷贝文件 //四种方法拷贝文件,并统计各自用时//字节流的基本流:依次读写一个字节//字节流的基本流:一次读写一个字节数组//字节缓冲流:一次读写一个字节//字节缓冲流:一次读写一个字节数组long start = System.currentTimeMillis();method1();method2();//16method3();//95method4();//17long end=System.currentTimeMillis();System.out.println((end-start)/1000.0+"秒");}private static void method3() throws IOException {//字节缓冲流BufferedInputStream bis =new BufferedInputStream(new FileInputStream("1.txt"));BufferedOutputStream bos =new BufferedOutputStream(new FileOutputStream("2.txt"));int b;while((b=bis.read())!=-1){bos.write(b);}bos.close();bis.close();}private static void method4() throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.txt"));byte[] bytes = new byte[8192];int len;while ((len = bis.read(bytes)) != -1) {bos.write(bytes,0,len);}bos.close();bis.close();}private static void method2() throws IOException {FileInputStream fis = new FileInputStream("C:\\1.txt");FileOutputStream fos=new FileOutputStream("1.txt");byte[] bytes= new byte[1024];int len;while((len=fis.read(bytes))!=-1){fos.write(bytes,0,len);}fos.close();fis.close();}private static void method1() throws IOException {FileInputStream fis = new FileInputStream("C:\\1.txt");FileOutputStream fos = new FileOutputStream("1.txt");int b;while ((b = fis.read()) != -1) {fos.write(b);}fos.close();fis.close();}}


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Test {public static void main(String[] args) throws IOException {//需求:把<出师表>的文章顺序进行恢复到一个新文件中//1.读取数据BufferedReader br =new BufferedReader(new FileReader("basic-code"));String line;ArrayList<String>list=new ArrayList<>();while((line=br.readLine())!=null){//  System.out.println(line);list.add(line);}br.close();//2.排序//排序规则:按照每一行前面的序号进行排序Collections.sort(list, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {//获取o1,o2的序号int i = Integer.parseInt(o1.split("\\.")[0]);int i1 = Integer.parseInt(o2.split("\\.")[0]);return i-i1;}});//写出BufferedWriter bw =new BufferedWriter(new FileWriter("1.txt"));for (String s : list) {bw.write(s);bw.newLine();}bw.close();}
}
import java.io.*;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;public class Test {public static void main(String[] args) throws IOException {//需求:把<出师表>的文章顺序进行恢复到一个新文件中BufferedReader br =new BufferedReader(new FileReader("1.txt"));String line;TreeMap<Integer,String> tm = new TreeMap<>();while((line=br.readLine())!=null){String[] arr =line.split("\\.");//0:序号  1:内容tm.put(Integer.parseInt(arr[0]),line);}br.close();//System.out.println(tm);//2.写出数据BufferedWriter bw =new BufferedWriter(new FileWriter("basic-code"));Set<Map.Entry<Integer,String>>entries = tm.entrySet();for(Map.Entry<Integer,String>entry:entries){String value = entry.getValue();bw.write(value);bw.newLine();}bw.close();}
}

 

import java.io.*;public class Test {public static void main(String[] args) throws IOException {//能用计数器的知识来做吗?不能 因为变量创建在内存中 程序重启 又能够再来三次//为了永久化存储所以要保存在文件当中//1.把文件中的数字读取到内存中//一次读一行 而不是读一个BufferedReader br =new BufferedReader(new FileReader("basic-code"));String line =br.readLine();int count = Integer.parseInt(line);//表示当前软件又运行了一次count++;//2.判断if(count<=3){System.out.println("欢迎使用本软件,第"+count+"次免费使用");}else{System.out.println("本软件只能使用三次,请注册会员继续使用");}//<=3:正常运行//>3:不能运行//3.把自增之后的count写出到文件当中BufferedWriter bw = new BufferedWriter(new FileWriter("basic-code"));//缓冲区输出流在关联文件的时候,文件存在就会清空//原则:IO:随用随创建//什么时候不用就关掉bw.write(count+"");//97 abw.close();}
}

 

import java.io.*;
import java.nio.charset.Charset;public class Test {public static void main(String[] args) throws IOException {//利用转换流按照指定字符编码读取(了解)/** 因为JDK11:这种方法被淘汰了  --->替代方案(掌握)*///        //1.创建对象并指定字符编码(了解即可)
//        InputStreamReader isr =new InputStreamReader(new FileInputStream("basic-code"),"GBK");
//        //2.读取数据
//        int ch;
//        while((ch=isr.read())!=-1){
//            System.out.println((char)ch);
//        }
//        //3.释放资源
//        isr.close();//掌握FileReader fr = new FileReader("basic-code", Charset.forName("GBK"));// 2.读取数据int ch;while((ch=fr.read())!=-1){System.out.println((char)ch);}//3.释放资源fr.close();}
}


import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;public class Test {public static void main(String[] args) throws IOException {//利用转换流按照指定字符编码写出(了解)//        //1.创建转换流对象
//        OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream("basic-code"),"GBK");
//        //2.写出数据
//        osw.write("你好你好");
//        //3.释放资源
//        osw.close();//替代方案FileWriter fw = new FileWriter("basic-code", Charset.forName("GBK"));fw.write("你好你好");fw.close();}
}

 

import java.io.*;
import java.nio.charset.Charset;public class Test {public static void main(String[] args) throws IOException {//将本地文件中GBK文件 转成UTF-8//1.JDK以前的方案InputStreamReader isr = new InputStreamReader(new FileInputStream("basic-code"),"GBK");OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream("basic-code1"),"UTF-8");int b;while ((b= isr.read())!=-1){osw.write(b);}osw.close();isr.close();//替代方案FileReader fr =new FileReader("basic-code", Charset.forName("GBK"));FileWriter fw =new FileWriter("basic-code1",Charset.forName("UTF-8"));int b;while((b=fr.read())!=-1){fw.write(b);}fw.close();fr.close();}
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;public class Test {public static void main(String[] args) throws IOException {//利用字节流读取文件中的数据 每次读一整行,而且不能出现乱码//1.字节流在读取中文的时候,是会出现乱码的,但是字符流可以搞定//2.字节流里面没有读一整行的方法的 只有字符缓冲流可以搞定//        FileInputStream fis= new FileInputStream("basic-code");
//        InputStreamReader isr =new InputStreamReader(fis);
//
//        BufferedReader br =new BufferedReader(isr);
//        String s = br.readLine();
//        br.close();BufferedReader br =new BufferedReader(new InputStreamReader(new FileInputStream("yjy.txt")));String line;while((line=br.readLine())!=null){System.out.println(line);}br.close();}
}

 

 

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;public class Test {public static void main(String[] args) throws IOException {/** serializable接口里面没有抽象方法,标记型接口* 一旦实现了这个接口 那么就表示当前的student类可以被序列化* 理解:* 一个物品的合格证* *///序列化流Student stu =new Student("zhangsan",23);ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("basic-code\\a.txt"));oos.writeObject(stu);oos.close();}
}

import java.io.Serializable;public class Student implements Serializable {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return age*/public int getAge() {return age;}/*** 设置* @param age*/public void setAge(int age) {this.age = age;}public String toString() {return "Student{name = " + name + ", age = " + age + "}";}
}

 

 

自己设置一个提示-版本号

在搜索框搜索Serializable

public class Student implements Serializable {@Serialprivate static final long serialVersionUID = 5498121245996411513L;// private static final long serialVersionUID = 1L;private String name;private int age;private String address;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return age*/public int getAge() {return age;}/*** 设置* @param age*/public void setAge(int age) {this.age = age;}public String toString() {return "Student{name = " + name + ", age = " + age + "}";}
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;public class Test {public static void main(String[] args) throws IOException, ClassNotFoundException {///用对象流读写多个对象//需求://将多个自定义对象序列化到文件中,但是由于对象的个数不确定,反序列化流该如何读取呢?Student s1 =new Student("zhangsan",23,"南京");Student s2 =new Student("lisi",24,"重庆");Student s3 =new Student("wangwu",25,"北京");//序列化多个对象ArrayList<Student>list =new ArrayList<>();list.add(s1);list.add(s2);list.add(s3);ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("basic-code"));oos.writeObject(list);oos.close();}
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;public class Demo {public static void main(String[] args) throws IOException, ClassNotFoundException {//反序列化流的对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("basic-code"));
//
//        Student s1 = (Student) ois.readObject();
//        Student s2 = (Student) ois.readObject();
//        Student s3 = (Student) ois.readObject();ArrayList<Student>list = (ArrayList<Student>) ois.readObject();for (Student student : list) {System.out.println(student);}ois.close();}
}

 

 

 

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.charset.Charset;public class Test {public static void main(String[] args) throws IOException, ClassNotFoundException {//打印流//1.创建字节打印流的对象PrintStream ps =new PrintStream(new FileOutputStream("myio\\1.txt"),true, Charset.forName("UTF-8"));//2.写出数据ps.println(97);//写出+自动刷新+自动换行ps.print(true);ps.println();ps.printf("%s 爱上了 %s","阿珍","阿强");//3.释放资源ps.close();}
}
public class Test {public static void main(String[] args) throws IOException, ClassNotFoundException {//打印流//1.创建字符打印流PrintWriter pw =new PrintWriter(new FileWriter("basic-code"),true);pw.println("dhuaidhwahdo");pw.print("你好你好");pw.close();}
}

解压缩流/压缩流

 

 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;public class Test {public static void main(String[] args) throws IOException, ClassNotFoundException {//1.创建一个File表示要解压的压缩包File src =new File("D:\\aaa.zip");//2.创建File对象表示解压的目的地File dest = new File("D:\\");//调用方法unzip(src,dest);}//定义一个方法用来解压public static void unzip(File src,File dest) throws IOException {//解压的本质:把压缩包里面的每一个文件或者文件夹读取出来 按照层级拷贝到目的地当中//创建一个解压缩流用来读取压缩包中的数据ZipInputStream zip =new ZipInputStream(new FileInputStream(src));//先获取到压缩包里面的每一个zipentry对象//        for (int i = 0; i < 100; i++) {
//            ZipEntry entry = zip.getNextEntry();
//            System.out.println(entry);//找不到就是返回null
//        }//表示当前在压缩包中获取到的文件或者文件夹ZipEntry entry;while ((entry = zip.getNextEntry())!=null){System.out.println(entry);//文件夹:需要在目的地dest处创建一个同样的文件夹//文件:需要读取到压缩包中的文件,并把他存放到目的地dest文件夹中(按照层级目录进行存放)if(entry.isDirectory()){//文件夹:需要在目的地dest处创建一个同样的文件夹File file =new File(dest,entry.toString());file.mkdirs();}else{//文件:需要读取到压缩包的文件,并把他存放到目的地dest文件夹中(按照层级目录进行存放)FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));int b;while((b =zip.read())!=-1){//写到目的地fos.write(b);}fos.close();//表示在压缩包中的一个文件处理完毕了zip.closeEntry();}}zip.close();}
}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;public class Test {public static void main(String[] args) throws IOException, ClassNotFoundException {//压缩单个文件 ->压缩包//1.创建File对象表示要压缩的文件File src = new File("D:\\yjy.txt");//2.创建File对象表示压缩包的位置File dest = new File("D:\\");//3.调用方法来压缩toZip(src,dest);}/** 作用:压缩* 参数一:表示要压缩的文件** 参数二:表示压缩包的位置** */public static void toZip(File src,File dest) throws IOException {//1.创建压缩流关联压缩包ZipOutputStream zos =new ZipOutputStream(new FileOutputStream(new File(dest,"yjy.zip")));//2.创建ZipEntry对象,表示压缩包里面的每一个文件和文件夹ZipEntry entry = new ZipEntry("yjy.txt");//3.把ZipEntry对象放到压缩包当中zos.putNextEntry(entry);//4.把src里面的数据写到压缩包中FileInputStream fis = new FileInputStream(src);int b;while((b=fis.read())!=-1){zos.write(b);}zos.closeEntry();zos.close();}
}

 

import java.io.File;
import java.io.IOException;public class DEMO {public static void main(String[] args) throws IOException {
//        File src =new File("basic-code\\1.txt");
//        File dest =new File("basic-code\\copy.txt");
//
//        FileUtils.copyFile(src,dest);//用这个包直接拷贝了//        File src =new File("D:\\aaa");
//        File dest =new File("D:\\bbb");
//        FileUtils.copyDirectory(src,dest);//        File src =new File("D:\\aaa");
//        File dest =new File("D:\\bbb");
//        FileUtils.copyDirectoryToDirectory(src,dest);//作用:bbb:里面有aaa然后有aaa里面的东西File src =new File("D:\\aaa");FileUtils.deleteDirectory(src);File dest =new File("D:\\bbb");FileUtils.cleanDirectory(dest);}
}

 

 

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;public class DEMO {public static void main(String[] args) throws IOException {//Hutool//因为里面的方法都是静态的所以直接用类名就可以调用了File file = FileUtil.file("D:\\aaa", "bbb", "a.txt");System.out.println(file);//D:\aaa\bbb\a.txtFile f =new File("a.txt");f.createNewFile();//如果父级路径不存在那么会报错//Hutool 里面的touch方法如果找不到这个父级路径会帮我们创建File touch = FileUtil.touch(file);System.out.println(touch);ArrayList<String>list =new ArrayList<>();list.add("aaa");list.add("aaa");list.add("aaa");File file1 = FileUtil.writeLines(list, "D:\\a.txt", "UTF-8", false);System.out.println(file1);File file2 = FileUtil.appendLines(list, "D:\\a.txt", "UTF-8");System.out.println(file2);List<String> strings = FileUtil.readLines("D:\\a.txt", "UTF-8");System.out.println(list);}
}

官网：
    https://hutool.cn/
API文档：
    https://apidoc.gitee.com/dromara/hutool/

中文使用文档：
    https://hutool.cn/docs/#/

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/278794.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Python | 高斯分布拟合示例

Python | 高斯分布拟合示例

什么是正态分布或高斯分布&#xff1f; 当我们绘制一个数据集&#xff08;如直方图&#xff09;时&#xff0c;图表的形状就是我们所说的分布。最常见的连续值形状是钟形曲线&#xff0c;也称为高斯分布或正态分布。 它以德国数学家卡尔弗里德里希高斯的名字命名。遵循高斯分布…
阅读更多...
使用subplot_mosaic创建复杂的子图布局

使用subplot_mosaic创建复杂的子图布局

在本文中&#xff0c;我将介绍matplotlib一个非常有价值的用于管理子图的函数——subplot_mosaic()。如果你想处理多个图的&#xff0c;那么subplot_mosaic()将成为最佳解决方案。我们将用四个不同的图实现不同的布局。 首先使用Import matplotlib行导入必要的库。 import matp…
阅读更多...
【node】使用 sdk 完成短信发送

【node】使用 sdk 完成短信发送

实现效果 过程 流程比较复杂&#xff0c;加上需要实名认证&#xff0c;建议开发的时候先提前去认证号账号&#xff0c;然后申请模版也需要等认证。 源码 我看了新版的sdk用的代码有点长&#xff0c;感觉没必要&#xff0c;这边使用最简单的旧版的sdk。 https://github.com/…
阅读更多...
JSP学习笔记（总结）

JSP学习笔记（总结）

简介 jsp生命周期&#xff1a;首次访问jsp&#xff0c;1 转成的servlet源代码&#xff0c; 2 编译&#xff0c;3 加载&#xff0c;4 执行jsp的init方法, 5 执行jsp的service方法, 6 处理完毕执行jsp的distroy方法。 1 基本标签 1.1 基本元素 (1) HTML元素 (2) CSS元素 (3…
阅读更多...
Git中stash的使用

Git中stash的使用

Git中stash的使用 stash命令1. stash保存当前修改2. 重新使用缓存3. 查看stash3. 删除 使用场景 stash命令 1. stash保存当前修改 git stash 会把所有未提交的修改&#xff08;包括暂存的和非暂存的&#xff09;都保存起来. git stashgit stash save 注释2. 重新使用缓存 #…
阅读更多...
SoＣ中跨时钟域的信号同步设计（单比特同步设计）

SoＣ中跨时钟域的信号同步设计（单比特同步设计）

一、 亚稳态 在数字电路中&#xff0c;触发器是一种很常用的器件。对于任意一个触发器&#xff0c;都由其参数库文件规定了能正常使用的“建立时间”&#xff08;Setup time&#xff09;和“保持时间”&#xff08;Hold time &#xff09;两个参数。“建立时间”是指在时钟…
阅读更多...
向华为学习：基于BLM模型的战略规划研讨会实操的详细说明，含研讨表单（一）

向华为学习：基于BLM模型的战略规划研讨会实操的详细说明，含研讨表单（一）

前面&#xff0c;华研荟用了三篇文章介绍华为战略规划的时候使用的其中一个工具&#xff1a;五看三定。一句话来说&#xff0c;五看三定是通过“五看”来知己知彼&#xff0c;然后设计业务&#xff0c;在选定的业务领域&#xff08;方向&#xff09;确定战略控制点&#xff0c;…
阅读更多...
JedisCluster 通过 Pipeline 实现两套数据轮换更新

JedisCluster 通过 Pipeline 实现两套数据轮换更新

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、整体流程 1.1 大致流程 1.2 流程代码解释 二、从数据库里查数据 2.1 SQL语句 三、更新当前前缀 3.1 设置前缀常量 3.2 初…
阅读更多...
设计模式——原型模式(创建型)

设计模式——原型模式(创建型)

引言 原型模式是一种创建型设计模式&#xff0c; 使你能够复制已有对象&#xff0c; 而又无需使代码依赖它们所属的类。 问题 如果你有一个对象&#xff0c; 并希望生成与其完全相同的一个复制品&#xff0c; 你该如何实现呢&#xff1f; 首先&#xff0c; 你必须新建一个属于…
阅读更多...
overleaf 加载pdf格式的矢量图时，visio 图片保存为pdf格式，如何确保pdf页面大小和图片一致

overleaf 加载pdf格式的矢量图时，visio 图片保存为pdf格式，如何确保pdf页面大小和图片一致

Overleaf支持多种矢量图形格式&#xff0c;其中一些常见的包括&#xff1a; PDF&#xff08;Portable Document Format&#xff09;&#xff1a; PDF是一种常见的矢量图形格式&#xff0c;Overleaf可以直接加载和显示PDF文件。许多绘图工具和LaTeX生成的图形都可以导出为PDF格式…
阅读更多...
vue中哪些数组的方法可以做到响应式

vue中哪些数组的方法可以做到响应式

Vue2 中为什么直接通过数组的索引修改元素是不会触发视图更新 vue2 为什么不直接监听数组 Vue2 对于数组提供了一些变异方法 重写数组方法源码分析 定义拦截器将拦截器挂载到数组上面收集依赖 扩展&#xff1a;理解Vue2如何解决数组和对象的响应式问题 对复杂对象的处理 复杂对…
阅读更多...
【ThemeStudio】安装报错A Javascript error occurred in the main process

【ThemeStudio】安装报错A Javascript error occurred in the main process

报错内容: 问题原因&#xff1a;系统环境缺少microsoft visual c插件 解决方法&#xff1a; 下载 微软VC 地址
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023