devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java--流_java流

作者：不正经 | 2024-04-22 17:28:44

赞

踩

java流

流

数据源：

数据源data source，提供数据的原始媒介。常见的数据源有:数据库、文件、其他程 序、内存、网络连接、lo 设备。 数据源分为:源设备、目标设备。

源设备:为程序提供数据，一般对应输入流。

目标设备:程序数据的目的地，一般对应输出流。

流的概念：

流是一个抽象、动态的概念，是一连串连续动态的数据集合。 对于输入流而言，数据源就像水箱，流(stream)就像水管中流动着的水流，程序就是我们最终的用户。我们通过流(AStream)将数据源(Source)中的数据(information)输送到程序(Program)中。对于输出流而言，目标数据源就是目的地(dest)，我们通过流(A Stream)将程序(Program)中的数据(information)输送到目的数据源(dest)中。

Java中流的概念细分

按流的方向分类:

输入流:数据流向是数据源到程序(以InputStream、Reader结尾的流)。 输出流:数据流向是程序到目的地(以 OutPutStream、Writer结尾的流)。

  1. import java.io.FileInputStream;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.nio.charset.StandardCharsets;
  6. //文件不规范写法
  7. ​
  8. public class Test {
  9.     public static void main(String[] args) throws IOException {
  10.         readfile();
  11.         writeFile();
  12.     }
  13.     public static void readfile() throws IOException {
  14.         try (FileInputStream fis = new FileInputStream("D:/b.txt");){
  15. ​
  16.             int x = fis.read();
  17.             char y = (char) fis.read();
  18.             char z = (char) fis.read();
  19.             char w = (char) fis.read();
  20.             int r  = fis.read();//读取完毕返回-1
  21.             System.out.println((char)x);
  22.             System.out.println(y);
  23.             System.out.println(z);
  24.             System.out.println(w);
  25.             System.out.println(r);
  26. //            fis.close();//不关闭，操作系统打开的系统资源文件一直被打开
  27.             //通过操作系统打开文件，硬盘资源，不做关闭时，资源一直被打开//打出信号让操作系统去关闭文件
  28.         } catch (FileNotFoundException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32.     public static void writeFile() throws IOException {
  33.         FileOutputStream fis = null;
  34.         try {
  35.            fis = new FileOutputStream("d:/b.txt");
  36.             fis.write("wsxz".getBytes(StandardCharsets.UTF_8));//转为字节数组输入
  37.             fis.write('s');
  38.             fis.write("t521".getBytes(StandardCharsets.UTF_8));
  39.             fis.close();
  40.         } catch (FileNotFoundException e) {
  41.             throw new RuntimeException(e);
  42.         }
  43.         finally{
  44.             if (fis != null) {
  45.                 fis.close();
  46.             }
  47.         }
  48.     }
  49. }
  50. ​
  51. import java.io.FileInputStream;
  52. import java.io.FileNotFoundException;
  53. import java.io.IOException;
  54. ​
  55. public class Test2 {
  56.     public static void main(String[] args) throws IOException {
  57.         readFile();
  58.     }
  59.     public static void readFile() throws IOException {
  60.         FileInputStream x = null;
  61.         try {
  62.             x = new FileInputStream("d:/b.txt");
  63.             int y = x.read();
  64.             int z = x.read();
  65.             int w = x.read();
  66.             int a = x.read();
  67.             int b = x.read();
  68.             System.out.println(y);
  69.             System.out.println(z);
  70.             System.out.println(w);
  71.             System.out.println(a);
  72.             System.out.println(b);
  73. ​
  74.         } catch (FileNotFoundException e) {
  75.             throw new RuntimeException(e);
  76.         } catch (IOException e) {
  77.             throw new RuntimeException(e);
  78.         }
  79.         finally {//文件最后不管前面是否报错都会将文件关闭
  80.             if(x != null)
  81.                 x.close();
  82.         }
  83.     }
  84. }
  85. import java.io.FileInputStream;
  86. import java.io.FileNotFoundException;
  87. import java.io.IOException;
  88. ​
  89. public class Test3 {
  90.     public static void main(String[] args) throws IOException {
  91.         readFile();
  92.     }
  93.     public static void readFile() throws IOException {
  94.         try (FileInputStream x = new FileInputStream("d:/b.txt");){//编译器自动生成finally结构关闭文件
  95.             int y = x.read();
  96.             int z = x.read();
  97.             int w = x.read();
  98.             int a = x.read();
  99.             int b = x.read();
  100.             System.out.println(y);
  101.             System.out.println(z);
  102.             System.out.println(w);
  103.             System.out.println(a);
  104.             System.out.println(b);
  105.         } catch (FileNotFoundException e) {
  106.             throw new RuntimeException(e);
  107.         } catch (IOException e) {
  108.             throw new RuntimeException(e);
  109.         }
  110.     }
  111. }

按处理的数据单元分类:

字节流:以字节为单位获取数据，命名上以Stream结屋的流一般是字节流 。如FilelnputStream、FileOutputStream。

字符流:以字符为单位获取数据，命名上以Reader/Writer结屋的流一般是字符流，如 FileReaderFileWriter

  1. import java.io.FileInputStream;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.nio.charset.StandardCharsets;
  6. ​
  7. public class Test4 {
  8.     public static void main(String[] args) {
  9.         readFile();
  10.         writeFile();
  11.         CopyFile();
  12.     }
  13.     public static  void readFile()
  14.     {
  15.         try (FileInputStream x = new FileInputStream("d:/b.txt");){
  16.             StringBuilder y = new StringBuilder();
  17.             int temp = 0;
  18.             while((temp = x.read()) != -1)
  19.             {
  20.                 y.append((char) temp);
  21.             }
  22.             System.out.println(y);
  23.         } catch (IOException e) {
  24.             throw new RuntimeException(e);
  25.         }
  26.     }
  27.     public static void writeFile()
  28.     {
  29.         FileOutputStream z = null;
  30.         try {
  31.             z = new FileOutputStream("d:/b.txt");
  32.             z.write("wsxzst5626454664".getBytes(StandardCharsets.UTF_8));
  33.         } catch (FileNotFoundException e) {
  34.             throw new RuntimeException(e);
  35.         } catch (IOException e) {
  36.             throw new RuntimeException(e);
  37.         } finally {
  38.             try {
  39.                 z.close();
  40.             } catch (IOException e) {
  41.                 throw new RuntimeException(e);
  42.             }
  43.         }
  44.     }
  45.   public static void CopyFile(){
  46.         try(FileInputStream c = new FileInputStream("d:/微信图片.jpG");
  47.         FileOutputStream v = new FileOutputStream("d:/微信图片复制.jpG");){
  48.             int temp = 0;
  49.             while((temp = c.read()) != -1)
  50.             {
  51.                 v.write(temp);
  52.             }
  53.         } catch (FileNotFoundException e) {
  54.             throw new RuntimeException(e);
  55.         } catch (IOException e) {
  56.             throw new RuntimeException(e);
  57.         }
  58.     }
  59.     public static void CopyFile(){
  60.         try(FileInputStream c = new FileInputStream("d:/微信图片.jpG");
  61.             FileOutputStream v = new FileOutputStream("d:/微信图片复制2.jpG");){
  62.             byte[] buff = new byte[1024];
  63.             while((c.read(buff)) != -1)
  64.             {
  65.                 v.write(buff);
  66.             }
  67.         } catch (FileNotFoundException e) {
  68.             throw new RuntimeException(e);
  69.         } catch (IOException e) {
  70.             throw new RuntimeException(e);
  71.         }
  72.     }
  73. }
  74. ​
  75. import java.io.FileNotFoundException;
  76. import java.io.FileReader;
  77. import java.io.FileWriter;
  78. import java.io.IOException;
  79. ​
  80. public class Test5 {
  81.     public static void main(String[] args) {
  82.         try(FileReader x = new FileReader("d:/c.txt");
  83.             FileWriter y = new FileWriter("d:/c_copy.txt");){
  84.             int temp = 0;
  85.             while((temp = x.read()) != -1) {
  86.                 y.write(temp);
  87.             }
  88.         } catch (FileNotFoundException e) {
  89.             throw new RuntimeException(e);
  90.         } catch (IOException e) {
  91.             throw new RuntimeException(e);
  92.         }
  93.     }
  94. }
  95. ​

按处理对象不同分类:

节点流:可以直接从数据源或目的地读写数据，如 FilelnputStream、FileReaderDatalnputStream等。

处理流:不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如 BufferedInputStream、BufferedReader等。

  1. import java.io.*;
  2. ​
  3. public class Test6 {
  4.     public static void main(String[] args) {
  5.     try(FileInputStream x = new FileInputStream("d:/微信图片.jpG");
  6.         FileOutputStream y = new FileOutputStream("d:/微信图片2.jpG");
  7.         BufferedInputStream z = new BufferedInputStream(x);
  8.         BufferedOutputStream w = new BufferedOutputStream(y);){
  9.         int temp = 0;
  10.         while((temp = x.read()) != -1)
  11.         {
  12.             w.write(temp);
  13.         }
  14.     } catch (FileNotFoundException e) {
  15.         throw new RuntimeException(e);
  16.     } catch (IOException e) {
  17.         throw new RuntimeException(e);
  18.     }
  19.     }
  20. }
  21. ​

文件字符流

前面介绍的文件字节流可以处理所有的文件，但是字节流不能很好的处理Unicode字符，经常会出现“乱码”现象。所以，我们处理文本文件，一般可以使用文件字符流，它以字符为单位进行操作。

  1. import java.io.*;
  2. ​
  3. public class Test9 {
  4.     public static void main(String[] args) {
  5.         writeDate();
  6.         readData();
  7.     }
  8.     public static void writeDate(){
  9.         try(DataOutputStream x = new DataOutputStream(new FileOutputStream("d:/data.txt"))) {
  10.             x.writeChars("wsx");
  11.             x.writeInt(85);
  12.             x.writeChar('x');
  13.             x.writeInt(12);
  14.             x.writeBoolean(true);
  15.             x.writeUTF("吴时兴");
  16.             x.flush();//刷新缓存区，将流中数据写入文件
  17.         } catch (FileNotFoundException e) {
  18.             throw new RuntimeException(e);
  19.         } catch (IOException e) {
  20.             throw new RuntimeException(e);
  21.         }
  22.     }
  23.     public static void readData()
  24.     {
  25.         try(DataInputStream y = new DataInputStream(new FileInputStream("d:/data.txt"))){
  26.             System.out.println(y.readChar());
  27.             System.out.println(y.readChar());
  28.             System.out.println(y.readChar());
  29.             System.out.println(y.readInt());
  30.             System.out.println(y.readChar());
  31.             System.out.println(y.readInt());
  32.             System.out.println(y.readBoolean());
  33.             System.out.println(y.readUTF());
  34. ​
  35.         } catch (FileNotFoundException e) {
  36.             throw new RuntimeException(e);
  37.         } catch (IOException e) {
  38.             throw new RuntimeException(e);
  39.         }
  40.     }
  41. }

缓冲字节流

Java缓冲流本身并不具有10流的读取与写入功能，只是在别的 流(节点流或其他处理流)上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流(包装流)。 当对文件或者其他数据源进行频繁的读写操作时，效率比较低， 这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。 因此，缓冲流还是很重要的，我们在10操作时记得加上缓冲流来提升性能。BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。下面我们通过两种方式(普通文件字节流与缓冲文件字节流)实现一个视频文件的复制，来体会一下缓冲流的好处。

  1. import java.io.*;
  2. ​
  3. public class Test7 {
  4.     public static void main(String[] args) {
  5.         try(BufferedReader x = new BufferedReader(new FileReader("d:/c.txt"));
  6.             BufferedWriter y = new BufferedWriter(new FileWriter("d:/c4.txt"));){
  7.             String temp = "";
  8.             while((temp = x.readLine()) != null)
  9.             {
  10.                 y.write(temp);
  11.                 y.newLine();
  12.             }
  13.         } catch (FileNotFoundException e) {
  14.             throw new RuntimeException(e);
  15.         } catch (IOException e) {
  16.             throw new RuntimeException(e);
  17.         }
  18.     }
  19. }
  20. import java.io.*;
  21. ​
  22. public class Test6 {
  23.     public static void main(String[] args) {
  24.     try(FileInputStream x = new FileInputStream("d:/微信图片.jpG");
  25.         FileOutputStream y = new FileOutputStream("d:/微信图片2.jpG");
  26.         BufferedInputStream z = new BufferedInputStream(x);
  27.         BufferedOutputStream w = new BufferedOutputStream(y);){
  28.         int temp = 0;
  29.         while((temp = x.read()) != -1)
  30.         {
  31.             w.write(temp);
  32.         }
  33.     } catch (FileNotFoundException e) {
  34.         throw new RuntimeException(e);
  35.     } catch (IOException e) {
  36.         throw new RuntimeException(e);
  37.     }
  38.     }
  39. }

缓冲字符流

BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率，同时，提供了更方便的按行读取的方法:readLine();处理文本时，我们一般可以使用缓冲字符流。

  1. import java.io.*;
  2. ​
  3. public class Test7 {
  4.     public static void main(String[] args) {
  5.         try(BufferedReader x = new BufferedReader(new FileReader("d:/c.txt"));
  6.             BufferedWriter y = new BufferedWriter(new FileWriter("d:/c4.txt"));){
  7.             String temp = "";
  8.             while((temp = x.readLine()) != null)
  9.             {
  10.                 y.write(temp);
  11.                 y.newLine();
  12.             }
  13.         } catch (FileNotFoundException e) {
  14.             throw new RuntimeException(e);
  15.         } catch (IOException e) {
  16.             throw new RuntimeException(e);
  17.         }
  18.     }
  19. }
  20. ​

字节数组流

ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况!说白了，FilelnputStream是把文件当做数据源。ByteArrayInputStream则是把内存中的”某个字节数组对象”当做数据源。

  1. import java.io.ByteArrayInputStream;
  2. import java.io.IOException;
  3. import java.nio.charset.StandardCharsets;
  4. ​
  5. public class Test8 {
  6.     public static void main(String[] args) {
  7.         test("dsafsgagd".getBytes(StandardCharsets.UTF_8));
  8.     }
  9.     public static void test(byte[] bytes){
  10.         int temp = 0;
  11.         int num = 0;
  12.         try(ByteArrayInputStream x = new ByteArrayInputStream(bytes)){
  13.             while((temp = x.read()) != -1){
  14.                 System.out.println((char) temp);
  15.                 num++;
  16.             }
  17.             System.out.println("读取字节数组为" + num);
  18.         } catch (IOException e) {
  19.             throw new RuntimeException(e);
  20.         }
  21.     }
  22. }
  23. ​

数据流

数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。 DatalnputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据(如:int、double、String等)的方法。 DatalnputStream和DataOutputStream是处理流，可以对其他节点流或处理流进行包装，增加一些更灵活、更高效的功能。

  1. import java.io.*;
  2. ​
  3. public class Test9 {
  4.     public static void main(String[] args) {
  5.         writeDate();
  6.         readData();
  7.     }
  8.     public static void writeDate(){
  9.         try(DataOutputStream x = new DataOutputStream(new FileOutputStream("d:/data.txt"))) {
  10.             x.writeChars("wsx");
  11.             x.writeInt(85);
  12.             x.writeChar('x');
  13.             x.writeInt(12);
  14.             x.writeBoolean(true);
  15.             x.writeUTF("撒旦今年");
  16.             x.flush();//刷新缓存区，将流中数据写入文件
  17.         } catch (FileNotFoundException e) {
  18.             throw new RuntimeException(e);
  19.         } catch (IOException e) {
  20.             throw new RuntimeException(e);
  21.         }
  22.     }
  23.     public static void readData()
  24.     {
  25.         try(DataInputStream y = new DataInputStream(new FileInputStream("d:/data.txt"))){
  26.             System.out.println(y.readChar());
  27.             System.out.println(y.readChar());
  28.             System.out.println(y.readChar());
  29.             System.out.println(y.readInt());
  30.             System.out.println(y.readChar());
  31.             System.out.println(y.readInt());
  32.             System.out.println(y.readBoolean());
  33.             System.out.println(y.readUTF());
  34. ​
  35.         } catch (FileNotFoundException e) {
  36.             throw new RuntimeException(e);
  37.         } catch (IOException e) {
  38.             throw new RuntimeException(e);
  39.         }
  40.     }
  41. }

对象流

ObjectInputStream/ObjectOutputStream是以“对象”为数据源，但是必须将传输的对象进行序列化与反序列化操作。 需要序列化的对象，需要实现接口:iava.io.Serializable对象序列化的作用有如下两种: 持久化:把对象的字节序列永久地保存到硬盘上 通常存放在一 个文件中，比如:休眠的实现。以后服务器session管理,hibernate将对象持久化实现。 网络通信:在网络上传送对象的字节序列。比如:服务器之间的数据通信、对象传递。

不参与序列化

static属性不参与序列化。 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰。

  1. public class User implements java.io.Serializable{
  2.     private int id;
  3.     private String name;
  4.     transient private String pwd;
  5. ​
  6.     public User(int id, String name, String pwd) {
  7.         this.id = id;
  8.         this.name = name;
  9.         this.pwd = pwd;
  10.     }
  11. ​
  12.     public int getId() {
  13.         return id;
  14.     }
  15. ​
  16.     public void setId(int id) {
  17.         this.id = id;
  18.     }
  19. ​
  20.     public String getName() {
  21.         return name;
  22.     }
  23. ​
  24.     public void setName(String name) {
  25.         this.name = name;
  26.     }
  27. ​
  28.     public String getPwd() {
  29.         return pwd;
  30.     }
  31. ​
  32.     public void setPwd(String pwd) {
  33.         this.pwd = pwd;
  34.     }
  35. }
  36. import java.io.*;
  37. import java.util.ArrayList;
  38. ​
  39. public class Test10 {
  40.     public static void main(String[] args) {
  41.         writeObject();
  42.         ReadObject();//密码没有参与序列化
  43.     }
  44.     public static void  writeObject(){
  45.         try(ObjectOutputStream x = new ObjectOutputStream(new FileOutputStream("d:/Obj.txt"))){
  46.             ArrayList<User> list = new ArrayList<>();
  47.             list.add(new User(1001,"吴时兴","123456"));
  48.             list.add(new User(1002,"吴时兴2","123458526"));
  49.             list.add(new User(1003,"吴时兴3","123996"));
  50.             list.add(new User(1004,"吴时兴4","1235656"));
  51.             x.writeObject(list);
  52.             x.flush();
  53.         } catch (FileNotFoundException e) {
  54.             throw new RuntimeException(e);
  55.         } catch (IOException e) {
  56.             throw new RuntimeException(e);
  57.         }
  58.     }
  59.     public static void ReadObject(){
  60.         try(ObjectInputStream y = new ObjectInputStream(new FileInputStream("d:/Obj.txt"))){
  61.             ArrayList<User> list  = (ArrayList)y.readObject();
  62.             for(User u : list){
  63.                 System.out.println(u.getId()+ "," + u.getName() + "," + u.getPwd());
  64.             }
  65.         } catch (FileNotFoundException e) {
  66.             throw new RuntimeException(e);
  67.         } catch (IOException e) {
  68.             throw new RuntimeException(e);
  69.         } catch (ClassNotFoundException e) {
  70.             throw new RuntimeException(e);
  71.         }
  72.     }
  73. }
  74. import java.io.*;
  75. import java.util.ArrayList;
  76. ​
  77. public class Test10 {
  78.     public static void main(String[] args) {
  79.         writeObject();
  80.         ReadObject();//密码没有参与序列化
  81.     }
  82.     public static void  writeObject(){
  83.         try(ObjectOutputStream x = new ObjectOutputStream(new FileOutputStream("d:/Obj.txt"))){
  84.             ArrayList<User> list = new ArrayList<>();
  85.             list.add(new User(1001,"吴时兴","123456"));
  86.             list.add(new User(1002,"吴时兴2","123458526"));
  87.             list.add(new User(1003,"吴时兴3","123996"));
  88.             list.add(new User(1004,"吴时兴4","1235656"));
  89.             x.writeObject(list);
  90.             x.flush();
  91.         } catch (FileNotFoundException e) {
  92.             throw new RuntimeException(e);
  93.         } catch (IOException e) {
  94.             throw new RuntimeException(e);
  95.         }
  96.     }
  97.     public static void ReadObject(){
  98.         try(ObjectInputStream y = new ObjectInputStream(new FileInputStream("d:/Obj.txt"))){
  99.             ArrayList<User> list  = (ArrayList)y.readObject();
  100.             for(User u : list){
  101.                 System.out.println(u.getId()+ "," + u.getName() + "," + u.getPwd());
  102.             }
  103.         } catch (FileNotFoundException e) {
  104.             throw new RuntimeException(e);
  105.         } catch (IOException e) {
  106.             throw new RuntimeException(e);
  107.         } catch (ClassNotFoundException e) {
  108.             throw new RuntimeException(e);
  109.         }
  110.     }
  111. }

转换流

InputStreamReader/OutputStreamWriter用来实现将字节流转化成字符流。

  1. import java.io.*;
  2. ​
  3. public class Test11 {
  4.     public static void main(String[] args) {
  5.         try(BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
  6.             BufferedWriter y = new BufferedWriter(new OutputStreamWriter(System.out));){
  7.             String str = x.readLine();
  8.             while(!"exit".equals(str)){
  9.                 y.write("键盘输入：" + str);
  10.                 y.newLine();
  11.                 y.flush();
  12.                 str = x.readLine();
  13.             }
  14.         } catch (IOException e) {
  15.             throw new RuntimeException(e);
  16.         }
  17.     }
  18. }
  19. ​

随意访问文件流

RandomAccessFile可以实现两个作用: 1.实现对一个文件做读和写的操作。 2.可以访问文件的任意位置。不像其他流只能按照先后顺序读取。

  1. import java.io.FileNotFoundException;
  2. import java.io.IOException;
  3. import java.io.RandomAccessFile;
  4. ​
  5. public class Test12 {
  6.     public static void main(String[] args) {
  7.         try(RandomAccessFile x = new RandomAccessFile("d:/data.txt","rw")){
  8.             int [] data = {10,20,3,63,52,85,96,85,74,20};
  9.             for (int i = 0; i < data.length; i++) {
  10.                 x.writeInt(data[i]);
  11.             }
  12.             x.seek(4);
  13.             System.out.println(x.readInt());
  14.             x.seek(8);
  15.             x.writeInt(45);
  16.             for (int i = 0; i < 10; i++) {
  17.                 x.seek(i * 4);
  18.                 System.out.print(x.readInt() + "\t");
  19.             }
  20.         } catch (FileNotFoundException e) {
  21.             throw new RuntimeException(e);
  22.         } catch (IOException e) {
  23.             throw new RuntimeException(e);
  24.         }
  25.     }
  26. }

装饰器模式构建IO流体系

装饰器模式简介 装饰器模式是GOF23种设计模式中较为常用的一种模式。它 可以实现对原有类的包装和装饰，使新的类具有更强的功能。

  1. import org.apache.commons.io.FileUtils;
  2. import org.apache.commons.io.IOUtils;
  3. import java.io.File;
  4. import java.io.FileFilter;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.net.URL;
  8. import java.util.List;
  9. public class Test14 {
  10.     public static void main(String[] args) {
  11. //        writeFile();
  12. //        Read();
  13.         ReadUrl();
  14. //        FileCopy();
  15. //        directoryCopy();
  16.     }
  17.     public static void writeFile(){
  18.         StringBuilder x = new StringBuilder();
  19.         for(int i = 0;i < 1000;i++)
  20.         {
  21.             x.append(Math.random() + "\n");
  22. ​
  23.         }
  24.         try {
  25.             FileUtils.write(new File("d:/4.txt"),x.toString(),"gbk");
  26.         } catch (IOException e) {
  27.             throw new RuntimeException(e);
  28.         }
  29.     }
  30.     public static void Read(){
  31.         try {
  32.             List<String> y = FileUtils.readLines(new File("d:/4.txt"),"gbk");
  33.             for(String temp : y)
  34.             {
  35.                 System.out.println(temp);
  36.             }
  37.         } catch (IOException e) {
  38.             throw new RuntimeException(e);
  39.         }
  40.     }
  41.     public static void ReadUrl(){
  42.         try {
  43.             URL v = new URL("https://vidhub.cc//");
  44.             InputStream b = v.openStream();
  45.             String xo = IOUtils.toString(b,"UTF-8");
  46.             System.out.println(xo);
  47.         } catch (IOException e) {
  48.             throw new RuntimeException(e);
  49.         }
  50.     }
  51.     public static void FileCopy(){
  52.         File x = new File("d:/data.txt");
  53.         File y = new File("d:/aa.txt");
  54.         try {
  55.             FileUtils.copyFile(x,y);
  56.         } catch (IOException e) {
  57.             throw new RuntimeException(e);
  58.         }
  59.     }
  60.     public static void directoryCopy(){
  61.         File x1 = new File("d:/1");
  62.         File x2 = new File("d:/3");
  63.         try {
  64.             FileUtils.copyDirectory(x1, x2, new FileFilter() {
  65.                 @Override
  66.                 public boolean accept(File pathname) {
  67.                     if(pathname.isDirectory() || pathname.getName().endsWith("jpG"))
  68.                     {
  69.                         return true;
  70.                     }
  71.                     else{
  72.                         return false;
  73.                     }
  74.                 }
  75.             });
  76.         } catch (IOException e) {
  77.             throw new RuntimeException(e);
  78.         }
  79.     }
  80. }
  81. //及就是新类包含原类并对与有原类的功能进行了添加

外导jar包的使用：

  1. //阿帕奇开源代码导入commons下的IO流包
  2. import org.apache.commons.io.FileUtils;
  3. import org.apache.commons.io.IOUtils;
  4. import java.io.File;
  5. import java.io.FileFilter;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.net.URL;
  9. import java.util.List;
  10. public class Test14 {
  11.     public static void main(String[] args) {
  12. //        writeFile();
  13. //        Read();
  14.         ReadUrl();
  15. //        FileCopy();
  16. //        directoryCopy();
  17.     }
  18.     public static void writeFile(){
  19.         StringBuilder x = new StringBuilder();
  20.         for(int i = 0;i < 1000;i++)
  21.         {
  22.             x.append(Math.random() + "\n");
  23. ​
  24.         }
  25.         try {
  26.             FileUtils.write(new File("d:/4.txt"),x.toString(),"gbk");
  27.         } catch (IOException e) {
  28.             throw new RuntimeException(e);
  29.         }
  30.     }
  31.     public static void Read(){
  32.         try {
  33.             List<String> y = FileUtils.readLines(new File("d:/4.txt"),"gbk");
  34.             for(String temp : y)
  35.             {
  36.                 System.out.println(temp);
  37.             }
  38.         } catch (IOException e) {
  39.             throw new RuntimeException(e);
  40.         }
  41.     }
  42.     public static void ReadUrl(){
  43.         try {
  44.             URL v = new URL("https://vidhub.cc//");
  45.             InputStream b = v.openStream();
  46.             String xo = IOUtils.toString(b,"UTF-8");
  47.             System.out.println(xo);
  48.         } catch (IOException e) {
  49.             throw new RuntimeException(e);
  50.         }
  51.     }
  52.     public static void FileCopy(){
  53.         File x = new File("d:/data.txt");
  54.         File y = new File("d:/aa.txt");
  55.         try {
  56.             FileUtils.copyFile(x,y);
  57.         } catch (IOException e) {
  58.             throw new RuntimeException(e);
  59.         }
  60.     }
  61.     public static void directoryCopy(){
  62.         File x1 = new File("d:/1");
  63.         File x2 = new File("d:/3");
  64.         try {
  65.             FileUtils.copyDirectory(x1, x2, new FileFilter() {
  66.                 @Override
  67.                 public boolean accept(File pathname) {
  68.                     if(pathname.isDirectory() || pathname.getName().endsWith("jpG"))
  69.                     {
  70.                         return true;
  71.                     }
  72.                     else{
  73.                         return false;
  74.                     }
  75.                 }
  76.             });
  77.         } catch (IOException e) {
  78.             throw new RuntimeException(e);
  79.         }
  80.     }
  81. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/469668
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号