`
liqita
  • 浏览: 291881 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

JAVA的文件操作【转】

阅读更多

11.3 I/O 类使用

由于在 IO 操作中,需要使用的数据源有很多,作为一个 IO 技术的初学者,从读写文件开始学习 IO 技术是一个比较好的选择。因为文件是一种常见的数据源,而且读写文件也是程序员进行 IO 编程的一个基本能力。本章 IO 类的使用就从读写文件开始。

11.3.1 文件操作

         文件 (File) 是 最常见的数据源之一,在程序中经常需要将数据存储到文件中,例如图片文件、声音文件等数据文件,也经常需要根据需要从指定的文件中进行数据的读取。当然, 在实际使用时,文件都包含一个的格式,这个格式需要程序员根据需要进行设计,读取已有的文件时也需要熟悉对应的文件格式,才能把数据从文件中正确的读取出 来。

         文件的存储介质有很多,例如硬盘、光盘和 U 盘等,由于 IO 类设计时,从数据源转换为流对象的操作由 API 实现了,所以存储介质的不同对于程序员来说是透明的,和实际编写代码无关。

11.3.1.1 文件的概念

         文件是计算机中一种基本的数据存储形式,在实际存储数据时,如果对于数据的读写速度要求不是很高,存储的数据量不是很大时,使用文件作为一种持久数据存储的方式是比较好的选择。

         存储在文件内部的数据和内存中的数据不同,存储在文件中的数据是一种“持久存储”,也就是当程序退出或计算机关机以后,数据还是存在的,而内存内部的数据在程序退出或计算机关机以后,数据就丢失了。

         在不同的存储介质中,文件中的数据都是以一定的顺序依次存储起来,在实际读取时由硬件以及操作系统完成对于数据的控制,保证程序读取到的数据和存储的顺序保持一致。

         每个文件以一个文件路径和文件名称进行表示,在需要访问该文件的时,只需要知道该文件的路径以及文件的全名即可。在不同的操作系统环境下,文件路径的表示形式是不一样的,例如在 Windows 操作系统中一般的表示形式为 C:\windows\system ,而 Unix 上的表示形式为 /user/my 。所以如果需要让 Java 程序能够在不同的操作系统下运行,书写文件路径时还需要比较注意。

11.3.1.1.1 绝对路径和相对路径

         绝对路径是指书写文件的完整路径,例如 d:\java\Hello.java ,该路径中包含文件的完整路径 d:\java 以及文件的全名 Hello.java 。使用该路径可以唯一的找到一个文件,不会产生歧义。但是使用绝对路径在表示文件时,受到的限制很大,且不能在不同的操作系统下运行,因为不同操作系统下绝对路径的表达形式存在不同。

         相对路径是指书写文件的部分路径,例如 \test\Hello.java ,该路径中只包含文件的部分路径 \test 和文件的全名 Hello.java ,部分路径是指当前路径下的子路径,例如当前程序在 d:\abc 下运行,则该文件的完整路径就是 d:\abc\test 。使用这种形式,可以更加通用的代表文件的位置,使得文件路径产生一定的灵活性。

         Eclipse 项目中运行程序时,当前路径是项目的根目录,例如工作空间存储在 d:\javaproject ,当前项目名称是 Test ,则当前路径是: d:\javaproject\Test 。在控制台下面运行程序时,当前路径是 class 文件所在的目录,如果 class 文件包含包名,则以该 class 文件最顶层的包名作为当前路径。

         另外在 Java 语言的代码内部书写文件路径时,需要注意大小写,大小写需要保持一致,路径中的文件夹名称区分大小写。由于 ’\’ Java 语言中的特殊字符,所以在代码内部书写文件路径时,例如代表“ c:\test\java\Hello.java ”时,需要书写成“ c:\\test\\java\\Hello.java ”或“ c:/test/java/Hello.java ”,这些都需要在代码中注意。

11.3.1.1.2 文件名称

         文件名称一般采用“文件名 . 后缀名”的形式进行命名,其中“文件名”用来表示文件的作用,而使用后缀名来表示文件的类型,这是当前操作系统中常见的一种形式,例如“ readme.txt ”文件,其中 readme 代表该文件时说明文件,而 txt 后缀名代表文件时文本文件类型,在操作系统中,还会自动将特定格式的后缀名和对应的程序关联,在双击该文件时使用特定的程序打开。

         其实在文件名称只是一个标示,和实际存储的文件内容没有必然的联系,只是使用这种方式方便文件的使用。在程序中需要存储数据时,如果自己设计了特定的文件格式,则可以自定义文件的后缀名,来标示自己的文件类型。

         和文件路径一样,在 Java 代码内部书写文件名称时也区分大小写,文件名称的大小写必须和操作系统中的大小写保持一致。

         另外,在书写文件名称时不要忘记书写文件的后缀名。

11.3.1.2 File

         为了很方便的代表文件的概念,以及存储一些对于文件的基本操作,在 java.io 包中设计了一个专门的类—— File 类。

         File 类中包含了大部分和文件操作的功能方法,该类的对象可以代表一个具体的文件或文件夹,所以以前曾有人建议将该类的类名修改成 FilePath ,因为该类也可以代表一个文件夹,更准确的说是可以代表一个文件路径。

         下面介绍一下 File 类的基本使用。

         1 File 对象代表文件路径

File 类的对象可以代表一个具体的文件路径,在实际代表时,可以使用绝对路径也可以使用相对路径。

下面是创建的文件对象示例。

                   public File(String pathname)

         该示例中使用一个文件路径表示一个 File 类的对象,例如:

                   File f1 = new File(“d:\\test\\1.txt”);

                   File f2 = new File(“1.txt”);

                  File f3 = new File(“e:\\abc”);

这里的 f1 f2 对象分别代表一个文件, f1 是绝对路径,而 f2 是相对路径, f3 则代表一个文件夹,文件夹也是文件路径的一种。

public File(String parent, String child)

                            也可以使用父路径和子路径结合,实现代表文件路径,例如:

                                     File f4 = new File(“d:\\test\\”,”1.txt”);

                            这样代表的文件路径是: d:\test\1.txt

         2 File 类常用方法

File 类中包含了很多获得文件或文件夹属性的方法,使用起来比较方便,下面将常见的方法介绍如下:

                   a createNewFile 方法

                                     public boolean createNewFile() throws IOException

该方法的作用是创建指定的文件。该方法只能用于创建文件,不能用于创建文件夹,且文件路径中包含的文件夹必须存在。

                   b delect 方法

                                     public boolean delete()

该方法的作用是删除当前文件或文件夹。如果删除的是文件夹,则该文件夹必须为空。如果需要删除一个非空的文件夹,则需要首先删除该文件夹内部的每个文件和文件夹,然后在可以删除,这个需要书写一定的逻辑代码实现。

                   c exists 方法

                                     public boolean exists()

                            该方法的作用是判断当前文件或文件夹是否存在。

                   d getAbsolutePath 方法

                                     public String getAbsolutePath()

该方法的作用是获得当前文件或文件夹的绝对路径。例如 c:\test\1.t 则返回 c:\test\1.t

                   e getName 方法

                                     public String getName()

                            该方法的作用是获得当前文件或文件夹的名称。例如 c:\test\1.t ,则返回 1.t

                   f getParent 方法

                                     public String getParent()

                            该方法的作用是获得当前路径中的父路径。例如 c:\test\1.t 则返回 c:\test

                   g isDirectory 方法

                                     public boolean isDirectory()

                            该方法的作用是判断当前 File 对象是否是目录。

                   h isFile 方法

                                     public boolean isFile()

                            该方法的作用是判断当前 File 对象是否是文件。

                   i length 方法

                                     public long length()

该方法的作用是返回文件存储时占用的字节数。该数值获得的是文件的实际大小,而不是文件在存储时占用的空间数。

                   j list 方法

                                     public String[] list()

该方法的作用是返回当前文件夹下所有的文件名和文件夹名称。说明,该名称不是绝对路径。

                   k listFiles 方法

                                     public File[] listFiles()

                            该方法的作用是返回当前文件夹下所有的文件对象。

                   l mkdir 方法

                                     public boolean mkdir()

该方法的作用是创建当前文件文件夹,而不创建该路径中的其它文件夹。假设 d 盘下只有一个 test 文件夹,则创建 d:\test\abc 文件夹则成功,如果创建 d:\a\b 文件夹则创建失败,因为该路径中 d:\a 文件夹不存在。如果创建成功则返回 true ,否则返回 false

                   m mkdirs 方法

                                     public boolean mkdirs()

该方法的作用是创建文件夹,如果当前路径中包含的父目录不存在时,也会自动根据需要创建。

                   n renameTo 方法

                                     public boolean renameTo(File dest)

该方法的作用是修改文件名。在修改文件名时不能改变文件路径,如果该路径下已有该文件,则会修改失败。

                   o setReadOnly 方法

                                     public boolean setReadOnly()

                            该方法的作用是设置当前文件或文件夹为只读。

         3 File 类基本示例

                   以上各方法实现的测试代码如下:

                            import java.io.File;

/**

 * File 类使用示例

 */

public class FileDemo {

         public static void main(String[] args) {

                   // 创建 File 对象

                   File f1 = new File("d:\\test");

                   File f2 = new File("1.txt");

                   File f3 = new File("e:\\file.txt");

                   File f4 = new File("d:\\","1.txt");

                   // 创建文件

                   try{

                            boolean b = f3.createNewFile();

                   }catch(Exception e){

                            e.printStackTrace();

                   }

                   // 判断文件是否存在

                   System.out.println(f4.exists());

                   // 获得文件的绝对路径

                   System.out.println(f3.getAbsolutePath());

                   // 获得文件名

                   System.out.println(f3.getName());

                   // 获得父路径

                   System.out.println(f3.getParent());

                   // 判断是否是目录

                   System.out.println(f1.isDirectory());

                   // 判断是否是文件

                   System.out.println(f3.isFile());

                   // 获得文件长度

                   System.out.println(f3.length());

                   // 获得当前文件夹下所有文件和文件夹名称

                   String[] s = f1.list();

                   for(int i = 0;i < s.length;i++){

                            System.out.println(s[i]);

                   }

                   // 获得文件对象

                   File[] f5 = f1.listFiles();

                   for(int i = 0;i < f5.length;i++){

                            System.out.println(f5[i]);

                   }

                   // 创建文件夹

                   File f6 = new File("e:\\test\\abc");

                   boolean b1 = f6.mkdir();

                   System.out.println(b1);

                   b1 = f6.mkdirs();

                   System.out.println(b1);

                   // 修改文件名

                   File f7 = new File("e:\\a.txt");

                   boolean b2 = f3.renameTo(f7);

                   System.out.println(b2);

                   // 设置文件为只读

                   f7.setReadOnly();             

         }

}

         4 File 类综合示例

下面以两个示例演示 File 类的综合使用。第一个示例是显示某个文件夹下的所有文件和文件夹,原理是输出当前名称,然后判断当前 File 对 象是文件还是文件夹,如果则获得该文件夹下的所有子文件和子文件夹,并递归调用该方法实现。第二个示例是删除某个文件夹下的所有文件和文件夹,原理是判断 是否是文件,如果是文件则直接删除,如果是文件夹,则获得该文件夹下所有的子文件和子文件夹,然后递归调用该方法处理所有子文件和子文件夹,然后将空文件 夹删除。则测试时谨慎使用第二个方法,以免删除自己有用的数据文件。示例代码如下:

                            import java.io.File;

/**

 * 文件综合使用示例

 */

public class AdvanceFileDemo {

         public static void main(String[] args) {

                   File f = new File("e:\\Book");

                   printAllFile(f);

                   File f1 = new File("e:\\test");

                   deleteAll(f1);

         }

        

         /**

          * 打印 f 路径下所有的文件和文件夹

          * @param f 文件对象

          */

         public static void printAllFile(File f){

                   // 打印当前文件名

                   System.out.println(f.getName());

                   // 是否是文件夹

                   if(f.isDirectory()){

                            // 获得该文件夹下所有子文件和子文件夹

                            File[] f1 = f.listFiles();

                            // 循环处理每个对象

                            int len = f1.length;

                            for(int i = 0;i < len;i++){

                                     // 递归调用,处理每个文件对象

                                     printAllFile(f1[i]);

                            }

                   }

         }

        

         /**

          * 删除对象 f 下的所有文件和文件夹

          * @param f 文件路径

          */

         public static void deleteAll(File f){

                   // 文件

                   if(f.isFile()){

                            f.delete();

                   }else{ // 文件夹

                            // 获得当前文件夹下的所有子文件和子文件夹

                            File f1[] = f.listFiles();

                            // 循环处理每个对象

                            int len = f1.length;

                            for(int i = 0;i < len;i++){

                                     // 递归调用,处理每个文件对象

                                     deleteAll(f1[i]);

                            }

                            // 删除当前文件夹

                            f.delete();

                   }

         }

}

         关于 File 类的使用就介绍这么多,其它的方法和使用时需要注意的问题还需要多进行练习和实际使用。

11.3.1.3 读取文件

         虽然前面介绍了流的概念,但是这个概念对于初学者来说,还是比较抽象的,下面以实际的读取文件为例子,介绍流的概念,以及输入流的基本使用。

         按照前面介绍的知识,将文件中的数据读入程序,是将程序外部的数据传入程序中,应该使用输入流—— InputStream Reader 。而由于读取的是特定的数据源——文件,则可以使用输入对应的子类 FileInputStream FileReader 实现。

         在实际书写代码时,需要首先熟悉读取文件在程序中实现的过程。在 Java 语言的 IO 编程中,读取文件是分两个步骤: 1 、将文件中的数据转换为流, 2 、读取流内部的数据。其中第一个步骤由系统完成,只需要创建对应的流对象即可,对象创建完成以后步骤 1 就完成了,第二个步骤使用输入流对象中的 read 方法即可实现了。

         使用输入流进行编程时,代码一般分为 3 个部分: 1 、创建流对象, 2 、读取流对象内部的数据, 3 、关闭流对象。下面以读取文件的代码示例:

                   import java.io.*;

/**

 * 使用 FileInputStream 读取文件

 */

public class ReadFile1 {

         public static void main(String[] args) {

                   // 声明流对象

                   FileInputStream fis = null;                 

                   try{

                            // 创建流对象

                            fis = new FileInputStream("e:\\a.txt");

                            // 读取数据,并将读取到的数据存储到数组中

                            byte[] data = new byte[1024]; // 数据存储的数组

                            int i = 0; // 当前下标

                            // 读取流中的第一个字节数据

                            int n = fis.read();

                            // 依次读取后续的数据

                            while(n != -1){ // 未到达流的末尾

                                     // 将有效数据存储到数组中

                                     data[i] = (byte)n;

                                     // 下标增加

                                     i++;

                                     // 读取下一个字节的数据

                                      n = fis.read();

                            }

                           

                            // 解析数据

                            String s = new String(data,0,i);

                            // 输出字符串

                            System.out.println(s);

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            try{

                                     // 关闭流,释放资源

                                     fis.close();

                            }catch(Exception e){}

                   }

         }

}

         在该示例代码中,首先创建一个 FileInputStream 类型的对象 fis

                   fis = new FileInputStream("e:\\a.txt");

         这样建立了一个连接到数据源 e:\a.txt 的流,并将该数据源中的数据转换为流对象 fis ,以后程序读取数据源中的数据,只需要从流对象 fis 中读取即可。

         读取流 fis 中的数据,需要使用 read 方法,该方法是从 InputStream 类中继承过来的方法,该方法的作用是每次读取流中的一个字节,如果需要读取流中的所有数据,需要使用循环读取,当到达流的末尾时, read 方法的返回值是 -1

         在该示例中,首先读取流中的第一个字节:

                   int n = fis.read();

         并将读取的值赋值给 int n ,如果流 fis 为空,则 n 的值是 -1 ,否则 n 中的最后一个字节包含的时流 fis 中的第一个字节,该字节被读取以后,将被从流 fis 中删除。

         然后循环读取流中的其它数据,如果读取到的数据不是 -1 ,则将已经读取到的数据 n 强制转换为 byte ,即取 n 中的有效数据——最后一个字节,并存储到数组 data 中,然后调用流对象 fis 中的 read 方法继续读取流中的下一个字节的数据。一直这样循环下去,直到读取到的数据是 -1 ,也就是读取到流的末尾则循环结束。

         这里的数组长度是 1024 ,所以要求流中的数据长度不能超过 1024 ,所以该示例代码在这里具有一定的局限性。如果流的数据个数比较多,则可以将 1024 扩大到合适的个数即可。

         经过上面的循环以后,就可以将流中的数据依次存储到 data 数组中,存储到 data 数组中有效数据的个数是 i 个,即循环次数。

         其实截至到这里, IO 操作中的读取数据已经完成,然后再按照数据源中的数据格式,这里是文件的格式,解析读取出的 byte 数组即可。

         该示例代码中的解析,只是将从流对象中读取到的有效的数据,也就是 data 数组中的前 n 个数据,转换为字符串,然后进行输出。

         在该示例代码中,只是在 catch 语句中输出异常的信息,便于代码的调试,在实际的程序中,需要根据情况进行一定的逻辑处理,例如给出提示信息等。

         最后在 finally 语句块中,关闭流对象 fis ,释放流对象占用的资源,关闭数据源,实现流操作的结束工作。

         上面详细介绍了读取文件的过程,其实在实际读取流数据时,还可以使用其它的 read 方法,下面的示例代码是使用另外一个 read 方法实现读取的代码:

                   import java.io.FileInputStream;

/**

 * 使用 FileInputStream 读取文件

 */

public class ReadFile2 {

         public static void main(String[] args) {

                   // 声明流对象

                   FileInputStream fis = null;                 

                   try{

                            // 创建流对象

                            fis = new FileInputStream("e:\\a.txt");

                            // 读取数据,并将读取到的数据存储到数组中

                            byte[] data = new byte[1024]; // 数据存储的数组

                            int i = fis.read(data);

                           

                            // 解析数据

                            String s = new String(data,0,i);

                            // 输出字符串

                            System.out.println(s);

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            try{

                                     // 关闭流,释放资源

                                     fis.close();

                            }catch(Exception e){}

                   }

         }

}

         该示例代码中,只使用一行代码:

                   int i = fis.read(data);

         就实现了将流对象 fis 中的数据读取到字节数组 data 中。该行代码的作用是将 fis 流中的数据读取出来,并依次存储到数组 data 中,返回值为实际读取的有效数据的个数。

         使用该中方式在进行读取时,可以简化读取的代码。

         当然,在读取文件时,也可以使用 Reader 类的子类 FileReader 进行实现,在编写代码时,只需要将上面示例代码中的 byte 数组替换成 char 数组即可。

使用 FileReader 读取文件时,是按照 char 为单位进行读取的,所以更适合于文本文件的读取,而对于二进制文件或自定义格式的文件来说,还是使用 FileInputStream 进行读取,方便对于读取到的数据进行解析和操作。

读取其它数据源的操作和读取文件类似,最大的区别在于建立流对象时选择的类不同,而流对象一旦建立,则基本的读取方法是一样,如果只使用最基本的 read 方法进行读取,则使用基本上是一致的。这也是 IO 类设计的初衷,使得对于流对象的操作保持一致,简化 IO 类使用的难度。

 程。

         基本的输出流包含 OutputStream Writer 两个,区别是 OutputStream 体系中的类 ( 也就是 OutputStream 的子类 ) 是按照字节写入的,而 Writer 体系中的类 ( 也就是 Writer 的子类 ) 是按照字符写入的。

         使用输出流进行编程的步骤是:

                   1 、建立输出流

                            建立对应的输出流对象,也就是完成由流对象到外部数据源之间的转换。

                   2 、向流中写入数据

                            将需要输出的数据,调用对应的 write 方法写入到流对象中。

                   3 、关闭输出流

                            在写入完毕以后,调用流对象的 close 方法关闭输出流,释放资源。

         在使用输出流向外部输出数据时,程序员只需要将数据写入流对象即可,底层的 API 实现将流对象中的内容写入外部数据源,这个写入的过程对于程序员来说是透明的,不需要专门书写代码实现。

         在向文件中输出数据,也就是写文件时,使用对应的文件输出流,包括 FileOutputStream FileWriter 两个类,下面以 FileOutputStream 为例子说明输出流的使用。示例代码如下:

                   import java.io.*;

/**

 * 使用 FileOutputStream 写文件示例

 */

public class WriteFile1 {

         public static void main(String[] args) {

                   String s = "Java 语言 ";

                   int n = 100;

                   // 声明流对象

                   FileOutputStream fos = null;

                   try{

                            // 创建流对象

                            fos = new FileOutputStream("e:\\out.txt");

                            // 转换为 byte 数组

                            byte[] b1 = s.getBytes();

                            // 换行符

                            byte[] b2 = "\r\n".getBytes();

                            byte[] b3 = String.valueOf(n).getBytes();

                            // 依次写入文件

                            fos.write(b1);

                            fos.write(b2);

                            fos.write(b3);

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try{

                                     fos.close();

                            }catch(Exception e){}

                   }

         }

}

         该示例代码写入的文件使用记事本打开以后,内容为:

                   Java 语言

100

         在该示例代码中,演示了将一个字符串和一个 int 类型的值依次写入到同一个文件中。在写入文件时,首先创建了一个文件输出流对象 fos

                   fos = new FileOutputStream("e:\\out.txt");

         该对象创建以后,就实现了从流到外部数据源 e:\out.txt 的连接。说明:当外部文件不存在时,系统会自动创建该文件,但是如果文件路径中包含未创建的目录时将出现异常。这里书写的文件路径可以是绝对路径也可以是相对路径。

         在 实际写入文件时,有两种写入文件的方式:覆盖和追加。其中“覆盖”是指清除原文件的内容,写入新的内容,默认采用该种形式写文件,“追加”是指在已有文件 的末尾写入内容,保留原来的文件内容,例如写日志文件时,一般采用追加。在实际使用时可以根据需要采用适合的形式,可以使用:

                   public FileOutputStream(String name, boolean append) throws FileNotFoundException

         只需要使用该构造方法在构造 FileOutputStream 对象时,将第二个参数 append 的值设置为 true 即可。

         流对象创建完成以后,就可以使用 OutputStream 中提供的 wirte 方法向流中依次写入数据了。最基本的写入方法只支持 byte 数组格式的数据,所以如果需要将内容写入文件,则需要把对应的内容首先转换为 byte 数组。

         这里以如下格式写入数据:首先写入字符串 s ,使用 String 类的 getBytes 方法将该字符串转换为 byte 数组,然后写入字符串“ \r\n ”,转换方式同上,该字符串的作用是实现文本文件的换行显示,最后写入 int 数据 n ,首先将 n 转换为字符串,再转换为 byte 数组。这种写入数据的顺序以及转换为 byte 数组的方式就是流的数据格式,也就是该文件的格式。因为这里写的都是文本文件,所以写入的内容以明文的形式显示出来,也可以根据自己需要存储的数据设定特定的文件格式。

         其实,所有的数据文件,包括图片文件、声音文件等等,都是以一定的数据格式存储数据的,在保存该文件时,将需要保存的数据按照该文件的数据格式依次写入即可,而在打开该文件时,将读取到的数据按照该文件的格式解析成对应的逻辑即可。

         最后,在数据写入到流内部以后,如果需要立即将写入流内部的数据强制输出到外部的数据源,则可以使用流对象的 flush 方法实现。如果不需要强制输出,则只需要在写入结束以后,关闭流对象即可。在关闭流对象时,系统首先将流中未输出到数据源中的数据强制输出,然后再释放该流对象占用的内存空间。

         使用 FileWriter 写入文件时,步骤和创建流对象的操作都和该示例代码一致,只是在转换数据时,需要将写入的数据转换为 char 数组,对于字符串来说,可以使用 String 中的 toCharArray 方法实现转换,然后按照文件格式写入数据即可。

         对于其它类型的字节输出流 / 字符输出流来说,只是在逻辑上连接不同的数据源,在创建对象的代码上会存在一定的不同,但是一旦流对象创建完成以后,基本的写入方法都是 write 方法,也需要首先将需要写入的数据按照一定的格式转换为对应的 byte 数组 /char 数组,然后依次写入即可。

         所以 IO 类的这种设计形式,只需要熟悉该体系中的某一个类的使用以后,就可以触类旁通的学会其它相同类型的类的使用,从而简化程序员的学习,使得使用时保持统一。

分享到:
评论

相关推荐

    java文件操作类

    java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java文件操作类java...

    java 操作文件工具类 java 操作文件工具类

    java 操作文件工具类java 操作文件工具类 java 操作文件工具类java 操作文件工具类java 操作文件工具类 java 操作文件工具类java 操作文件工具类java 操作文件工具类 java 操作文件工具类java 操作文件工具类java ...

    java视频教程—Java文件操作

    java视频教程 Java文件操作 JavaFile

    JAVA 音频文件PCM转WAV Utils类

    总之,"JAVA 音频文件PCM转WAV Utils类"是Java音频处理领域的一个实用工具,它简化了音频格式转换的过程,使得开发人员可以更方便地在不同音频格式之间进行转换,特别是在需要从基本的PCM数据创建WAV文件的场合。

    Java反编译工具把.class文件转换为.java文件

    ### Java反编译工具:将.class文件转换为.java文件 #### 概述 在软件开发领域,有时我们可能需要分析第三方库或者开源项目的内部结构,这时就需要借助于反编译工具来帮助我们阅读和理解其源码。Java作为一种广泛...

    java实现wav文件转成mp3文件

    Java实现将WAV文件转换为MP3文件是一个常见的音频...总的来说,Java实现WAV转MP3涉及到音频编码理论、特定的编码库以及Java编程技巧。通过理解这些知识点,你可以创建自己的音频处理工具,实现各种音频格式之间的转换。

    java调用window操作系统文本转语音并生成播放文件

    在Java编程环境中,调用Windows操作系统来实现文本转语音(Text-to-Speech, TTS)并生成播放文件是一项常见的需求。这项技术可以帮助开发者为应用程序添加语音合成功能,尤其适用于无障碍应用、语音助手或者多媒体...

    Java文件操作封装类

    Java文件操作封装类

    java文件操作工具类

    java文件操作工具类是java中针对文件操作的一个工具类,可以方便的读取,下载,上传文件等操作,希望可以帮到大家。

    java URL转PDF文件

    在Java编程环境中,将...5. 文件I/O操作,如`FileOutputStream`用于写入PDF文件。 以上就是整个过程的详细步骤和涉及的技术点,希望对你有所帮助。在实际开发中,可以根据具体需求选择合适的库和方法,优化转换效果。

    java文件操作大全

    如何在Java中操作文件呢?转载供大家欣赏

    Java实现doc文件转成docx文件

    Apache POI提供了一系列类和方法来读取、写入以及操作这些文件。 首先,确保已经将Apache POI库添加到项目依赖中。在Eclipse这样的开发环境中,可以通过Maven或Gradle来管理依赖。在Maven的`pom.xml`文件中添加以下...

    doc2docx 文件类型转换 java后台

    Java作为一个广泛使用的编程语言,其强大的库支持使得文件操作变得简单。在描述中提到的“java代码编写”,暗示了我们可能会用到Apache POI库,这是一个用于读写Microsoft Office格式文件的开源Java API。Apache POI...

    JAVA代码实现远程操作服务器文件

    Session是一个远程服务器文件操作的会话,可以实现文件的移动、复制、删除等操作。通过使用Session,可以实现远程服务器文件的操作。 6. 使用InputStream和BufferedReader实现命令执行结果的获取 InputStream和...

    java实现对文件的各种操作的工具类.md

    # java实现对文件的各种操作的工具类 ## 可以实现的操作有: 1. 删除单个文件 2. 删除文件夹及文件夹下的文件 3. 使用文件流对单个文件进行复制 4. 复制整个文件夹内容(包含子文件夹中的所有内容) 5. ...

    java ceb转pdf demo

    可能的方法包括通过JNI(Java Native Interface)调用本地库,或者利用像JNA(Java Native Access)这样的库来与操作系统底层交互。 2. **c2p_dll 2.dll**:这是一个动态链接库文件,很可能是用来处理CEB到PDF转换...

    在java程序中实现wav文件转MP3

    此外,如果要在跨平台上运行,可能还需要处理不同操作系统下的路径分隔符和LAME可执行文件的路径。 在Java中调用外部工具有一定的安全风险,因为它们可能会暴露于命令注入攻击。因此,确保在传递给`exec()`的参数中...

    java 移动文件.

    "Java 文件操作" Java 文件操作是 Java 编程语言中的一种基本操作,包括文件的移动、复制、删除、剪切等。下面是关于 Java 文件操作的知识点总结: 一、文件移动 文件移动是指将文件从一个目录下移到另一个目录下...

    JAVA将PDF转OFD 国产化必备

    1. **读取PDF文件**:使用JAVA PDF库读取PDF文件内容,包括文本、图像、表格等元素。 2. **解析PDF结构**:理解PDF文件的页面布局、字体、颜色等信息,以便在OFD中重现相同的效果。 3. **创建OFD文档结构**:根据PDF...

    java 实现 JPG图像文件转换TIFF文件 有源码。有工程

    通过使用这个库,我们可以方便地在Java中读取、写入和操作TIFF文件。 3. **JPG到TIFF转换步骤**: - **读取JPG文件**:使用`ImageIO.read()`方法读取JPG文件到`BufferedImage`对象。 - **创建TIFF输出流**:创建...

Global site tag (gtag.js) - Google Analytics