Java IO流(第二讲):File类

File是基于磁盘操作的I/O,Java多数IO都是实行流式操作,但是File不是,它不会读取文件信息或者向文件存储,它是直接处理文件的,它不会读取文件信息或者向文件存储,File对象可以用来获取或处理与磁盘文件相关的信息,例如权限,时间,日期和目录路径。File类的名字比较欺骗性,它其实并不仅仅代表一个特定文件名字,也可以代表文件目录下一系列文件名,用File存储数据存在很大的安全性,但是文件仍是我们存储数据以及共享数据的主要工具。

下面我们来解读File类在Java中的运用方式。

首先,我们来看下File的构造函数:

1. public File(String pathname)// pathname是文件的路径名以及文件名

2. public File(String parent, String child)// parent代表父类文件路径以及文件名,child代表子类文件路径以及文件名

3. public File(File parent, String child)//parent代表父类文件,child代表子类文件名

4 .public File(URI uri) //通过远程地址创建File对象

根据上面的构造函数,我们来用实例说明一下

 File file1=new File("D:\\file1.txt");//绝对路径保证我们能找到文件
 File file2=new File("D:\\","file1.txt");
 File file3=new  File("D:\\");
 File file4=new  File(file3,"file1.txt");

怎么读取文件的信息?我们知道Java是面向对象的,因此我们需要将文件转换为对象(具体怎么讲文件转换为对象不考虑),这样我们就可以通过操作对象来获取文件的信息。上面file1代表我们将D盘下文件file1.txt转化为File对象,file2与file1的构造函数区别在于我们把文件路径分割为两个部分,两个部分存在父子关系。file4 的构造函数代表着父类是一个file对象file3,实际上上面前3个都是将file1.txt这个文件构造为File对象,这样我们就可以通过File对象的方法获取我们需要的信息以及进行一系列操作。

注意:Java 能正确处理UNIX和Windows/DOS约定路径分隔符。如果在Windows版本的Java下用斜线(/),路径处理依然正确。记住,如果你用Windows使用反斜线(\)的约定,你需要在字符串内使用它的转义序列.

有很多人在这里会有疑问,我上面建的File实例都是用绝对路径,那么如果用相对路径,怎么建,文件放在哪?根据File JDK文档说明,java.io包中所有类,这个基地址由user.dir这个属性制定,也叫当前目录。如下代码:

System.out.println(System.getProperty("user.dir"));

所以如果想根据相对路径创建File对象,首先要把你要创建File的文件放到你代码的相对路径下,即上面代码查看的结果,然后创建File对象实例

其次,我们来看看File对象的方法:

1.getName()返回值 String

获取File对象文件名,如果File对象是文件夹,则获取文件夹名称,是文件则获取文件名称。源码也很简单,就是获取最后一个分隔符,然后字符串截取。

public String getName() {
        int index = path.lastIndexOf(separatorChar);
        if (index < prefixLength) return path.substring(prefixLength);
        return path.substring(index + 1);
    }

2.getParent()返回值 String

获取当前File的 父类文件名,当然这里可能不存在父类文件夹,即我们创建File对象用相对路径创建,很多人会疑惑,相对路径至少也是存储在代码根目录下的,为什么不会获取父类文件夹,那我们来看看源码你就清楚了,源码是直接从创建File对象是给定的路径截取父类文件名,如果给定的路径用相对路径,就不会获取父类文件。

public String getParent() {
        int index = path.lastIndexOf(separatorChar);
        if (index < prefixLength) {
            if ((prefixLength > 0) && (path.length() > prefixLength))
                return path.substring(0, prefixLength);
            return null;
        }
        return path.substring(0, index);
    }

3.getParentFile()返回值 File

获取父类File对象实例,从源码可以看出如果调用此方法的File在构造时,传递的参数存在父类文件夹,则是可以获取的。

 public File getParentFile() {
        String p = this.getParent();//直接调用获取父类路径方法
        if (p == null) return null;
        return new File(p, this.prefixLength);
    }

4.getPath() 返回值 String

返回当前File对象实例的路径字符串,创建时File时传递的值是啥,返回的就是啥。

 public String getPath() {
        return path;
    }

5.isAbsolute() 返回值 boolean

判断此File实例是不是绝对路径创建实例。

 public boolean isAbsolute() {
        return fs.isAbsolute(this);
    }

6.getAbsolutePath() 返回值 String

获取此File实例的绝对路径字符串,不管File实例是已绝对路径或者相对路径创建。

public String getAbsolutePath() {
        return fs.resolve(this);
    }

7.getAbsoluteFile() 返回值 File

将File实例转化为绝对路径创建的File实例,对相对路径创建的File起作用,绝对路径创建的没变化。

public File getAbsoluteFile() {
        String absPath = getAbsolutePath();
        return new File(absPath, fs.prefixLength(absPath));
    }

8.getCanonicalPath() 返回值 String

返回此抽象路径名的规范路径名字符串。

规范路径名是绝对路径名,并且是惟一的。规范路径名的准确定义与系统有关。如有必要,此方法首先将路径名转换为绝对路径名,这与调用 getAbsolutePath() 方法的效果一样,然后用与系统相关的方式将它映射到其惟一路径名。这通常涉及到从路径名中移除多余的名称(比如 "." 和 "..")、解析符号连接(对于 UNIX 平台),以及将驱动器号转换为标准大小写形式(对于 Microsoft Windows 平台)。

每个表示现存文件或目录的路径名都有一个惟一的规范形式。每个表示不存在文件或目录的路径名也有一个惟一的规范形式。不存在文件或目录路径名的规范形式可能不同于创建文件或目录之后同一路径名的规范形式。同样,现存文件或目录路径名的规范形式可能不同于删除文件或目录之后同一路径名的规范形式。

返回:

规范路径名字符串,它与此抽象路径名表示相同的文件或目录

 public String getCanonicalPath() throws IOException {
        if (isInvalid()) {
            throw new IOException("Invalid file path");
        }
        return fs.canonicalize(fs.resolve(this));
    }

这个不是很好理解但是我们可以用例子对比一下,有经验的程序员用过相对路径,应该都清楚../test2.txt中的..在相对路径代表上一级目录

File file4=new File("test2.txt");
File file5=new File("../test2.txt");
System.out.println(file4.getAbsolutePath()+"------"+file5.getAbsolutePath());
System.out.println(file4.getCanonicalPath()+"------"+file5.getCanonicalPath());
-------打印结果------
F:\guoxiangworkspace\Socket\test2.txt------F:\guoxiangworkspace\Socket\..\test2.txt
F:\guoxiangworkspace\Socket\test2.txt------F:\guoxiangworkspace\test2.txt

可以看出getAbsolutePath将..也打印出来了,实际我的标准的路径是F:\guoxiangworkspace\test2.txt,而getCanonicalPath()就是标准化路径,并不是根据创建的抽象路径直接打印,是经过处理的。

9.getCanonicalFile() 返回值 File

同上,只是返回File实例。

public File getCanonicalFile() throws IOException {
        String canonPath = getCanonicalPath();
        return new File(canonPath, fs.prefixLength(canonPath));
    }

10.toURI() 返回值 URI

返回创建File实例抽象路径的URI实例,什么是URI有兴趣的可以百度

http://www.cnblogs.com/gaojing/archive/2012/02/04/2413626.html

http://www.cnblogs.com/hust-ghtao/p/4724885.html 附上两篇文章

 public URI toURI() {
        try {
            File f = getAbsoluteFile();
            String sp = slashify(f.getPath(), f.isDirectory());
            if (sp.startsWith("//"))
                sp = "//" + sp;
            return new URI("file", null, sp, null);
        } catch (URISyntaxException x) {
            throw new Error(x);         // Can‘t happen
        }
    }

11.canRead() 返回值 boolean

判断该File实例是否可以读取,简单的说就是你的程序如果想读取File 文件的内容,能不能读。如果读取权限被限制,则返回false。

 public boolean canRead() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return false;
        }
        return fs.checkAccess(this, FileSystem.ACCESS_READ);
    }

12.canWrite() 返回值 boolean

同上,判断该文件是否可以往内写数据。

  public boolean canWrite() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkWrite(path);
        }
        if (isInvalid()) {
            return false;
        }
        return fs.checkAccess(this, FileSystem.ACCESS_WRITE);
    }

13.exists() 返回值 boolean

判断该File实例创建时,传递的抽象路径所代表的文件或者文件夹是否真的存在。

public boolean exists() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return false;
        }
        return ((fs.getBooleanAttributes(this) & FileSystem.BA_EXISTS) != 0);
    }

14. isDirectory()返回值 boolean

判断该File实例代表的是否是文件夹。

public boolean isDirectory() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return false;
        }
        return ((fs.getBooleanAttributes(this) & FileSystem.BA_DIRECTORY)
                != 0);
    }

15.isFile()返回值 boolean

判断该File实例代表的是否是文件。

public boolean isFile() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return false;
        }
        return ((fs.getBooleanAttributes(this) & FileSystem.BA_REGULAR) != 0);
    }

16.isHidden() 返回值 boolean

判断是否是隐藏文件。

  public boolean isHidden() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return false;
        }
        return ((fs.getBooleanAttributes(this) & FileSystem.BA_HIDDEN) != 0);
    }

17.lastModified() 返回值 long

返回最后一次该File实例代表的文件或者文件夹修改时间。返回的long类型,转换为Data,Date date = new Date(long类型时间);

 public long lastModified() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return 0L;
        }
        return fs.getLastModifiedTime(this);
    }

18.length() 返回值 long

返回文件内容的长度,以字节为单位。

public long length() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return 0L;
        }
        return fs.getLength(this);
    }

19.createNewFile()返回值 boolean

根据File实例的逻辑路径创建新文件,并返回创建结果,如果文件已经存在,则返回false。

使用: File file = new File("D:/test/1.txt"); boolean res = file.createNewFile(); if(!res)System.out.println("创建失败!");
如果D:/test 目录下没有 1.txt文件,则创建该文件;如果没有test目录,直接抛出异常,如果1.txt已经存在,那么文件创建失败。 可以得知,createNewFile() 方法,根据抽象路径创建一个新的空文件,当抽象路径制定的文件存在时,创建失败。

public boolean createNewFile() throws IOException {
        SecurityManager security = System.getSecurityManager();
        if (security != null) security.checkWrite(path);
        if (isInvalid()) {
            throw new IOException("Invalid file path");
        }
        return fs.createFileExclusively(path);
    }

与之相似的方法createTempFile() 方法

该方法有两种调用方式: createTempFile(String prefix, String suffix); 在默认临时文件目录中创建一个空文件,使用给定前缀和后缀生成其名称。 createTempFile(String prefix, String suffix, File directory); 在指定目录中创建一个新的空文件,使用给定的前缀和后缀字符串生成其名称。

实例:

public class TestFile2 {
public static void main(String[] args) {
File f1 = new File("D:\");
File f2 = null;
try {
f2 = File.createTempFile("abc", ".txt", f1);
System.out.println(f2.getName());
} catch (IOException e) {
e.printStackTrace();
}
}
}

打印结果abc807062783757555654.txt

看源码:TempDirectory.generateFile(prefix, suffix, tmpdir)这个函数会生成19位数字追加在前缀。

 public static File createTempFile(String prefix, String suffix,
                                      File directory)
        throws IOException
    {
        if (prefix.length() < 3)
            throw new IllegalArgumentException("Prefix string too short");
        if (suffix == null)
            suffix = ".tmp";

        File tmpdir = (directory != null) ? directory
                                          : TempDirectory.location();
        SecurityManager sm = System.getSecurityManager();
        File f;
        do {
        //
            f = TempDirectory.generateFile(prefix, suffix, tmpdir);

            if (sm != null) {
                try {
                    sm.checkWrite(f.getPath());
                } catch (SecurityException se) {
                    // don‘t reveal temporary directory location
                    if (directory == null)
                        throw new SecurityException("Unable to create temporary file");
                    throw se;
                }
            }
        } while ((fs.getBooleanAttributes(f) & FileSystem.BA_EXISTS) != 0);

        if (!fs.createFileExclusively(f.getPath()))
            throw new IOException("Unable to create temporary file");

        return f;
    }

20.delete()返回值 boolean

根据File实例创建时传递的抽象路劲进行删除,如果文件存在,则删除并返回true,如果不存在或者限制删除,则返回false。

 public boolean delete() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkDelete(path);
        }
        if (isInvalid()) {
            return false;
        }
        return fs.delete(this);
    }

21.deleteOnExit() 无返回值

此方法要求将表示此抽象路径名的文件或目录在虚拟机终止时被删除。

public void deleteOnExit() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkDelete(path);
        }
        if (isInvalid()) {
            return;
        }
        DeleteOnExitHook.add(path);
    }

22.list() 返回String[]

返回调用该方法File实例抽象路径名的目录中的文件和目录的字符串数组,即该文件夹下包含的所有文件或者文件夹(不包含文件夹下的子文件)名称组成的数组。

public String[] list() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(path);
        }
        if (isInvalid()) {
            return null;
        }
        return fs.list(this);
    }

23.list(FilenameFilter filter) 返回String[]

相比较上面的方法,多出一个FilenameFilter filter参数,从名字就可以分析出,这个参数是具有过滤作用的。我们习惯用匿名内部类来覆盖FilenameFilter 类方法进行过滤。实例如下

import java.io.File;
import java.io.FilenameFilter;
public class FileDemo {
   public static void main(String[] args) {   
      File f = null;
      File[] paths;
      try{      
        f = new File("D:/test");
         FilenameFilter fileNameFilter = new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
               if(name.lastIndexOf(‘.‘)>0)
               {
                  int lastIndex = name.lastIndexOf(‘.‘);
                  String str = name.substring(lastIndex)
                  if(str.equals(".txt"))
                  {
                     return true;
                  }
               }
               return false;
            }
         };
         paths = f.listFiles(fileNameFilter);
         for(File path:paths)
         {
            System.out.println(path);
         }
      }catch(Exception e){
         e.printStackTrace();
      }
   }}
  public String[] list(FilenameFilter filter) {
        String names[] = list();
        if ((names == null) || (filter == null)) {
            return names;
        }
        List<String> v = new ArrayList<>();
        for (int i = 0 ; i < names.length ; i++) {
            if (filter.accept(this, names[i])) {
                v.add(names[i]);
            }
        }
        return v.toArray(new String[v.size()]);
    }

24.listFiles() 返回值File[]

此方法用于返回调用该方法的File实例下包含的文件以及文件夹的File实例数组。

 public File[] listFiles() {
        String[] ss = list();
        if (ss == null) return null;
        int n = ss.length;
        File[] fs = new File[n];
        for (int i = 0; i < n; i++) {
            fs[i] = new File(ss[i], this);
        }
        return fs;
    }

25.listFiles(FilenameFilter filter) 返回值File[]

同list(FilenameFilter filter)用法相同,先获取调用该方法File下所有文件以及文件夹名称,然后根据过滤条件进行过滤,再将过滤后的得到的文件名数组实例化为File[]数组。

public File[] listFiles(FilenameFilter filter) {
        String ss[] = list();
        if (ss == null) return null;
        ArrayList<File> files = new ArrayList<>();
        for (String s : ss)
            if ((filter == null) || filter.accept(this, s))
                files.add(new File(s, this));
        return files.toArray(new File[files.size()]);
    }

26.listFiles(FileFilter filter) 返回值File[]

同上,但是过滤器类型不同,FilenameFilter只能针对文件名为条件,而FileFilter可以通过调用File方法来返回true或者false来过滤。

如下实例:

import java.io.File;
import java.io.FileFilter;
public class FileDemo {
   public static void main(String[] args) {
      
      File f = null;
      File[] paths;
      
      try{ 
         f = new File("D:/test");
         FileFilter filter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
               return pathname.isFile();
            }
         };
         paths = f.listFiles(filter);
         for(File path:paths)
         {
            System.out.println(path);
         }
      }catch(Exception e){
         e.printStackTrace();
      }
   }}

源代码:

 public File[] listFiles(FileFilter filter) {
        String ss[] = list();
        if (ss == null) return null;
        ArrayList<File> files = new ArrayList<>();
        for (String s : ss) {
            File f = new File(s, this);
            if ((filter == null) || filter.accept(f))
                files.add(f);
        }
        return files.toArray(new File[files.size()]);
    }

27.mkdir()与mkdirs() 返回值boolean

两个方法都是用来创建以抽象路径为名的文件夹,区别在于madir()只能对已经存在的文件夹建立单层子文件夹,如果建立多层嵌套的文件夹则用mkdirs(),包含在抽象路径下的文件夹必须都不能存在,否则则不能建立嵌套文件夹,如果建立成功返回true。

  public boolean mkdir() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkWrite(path);
        }
        if (isInvalid()) {
            return false;
        }
        return fs.createDirectory(this);
    }
    
     public boolean mkdirs() {
        if (exists()) {
            return false;
        }
        if (mkdir()) {
            return true;
        }
        File canonFile = null;
        try {
            canonFile = getCanonicalFile();
        } catch (IOException e) {
            return false;
        }

        File parent = canonFile.getParentFile();
        return (parent != null && (parent.mkdirs() || parent.exists()) &&
                canonFile.mkdir());
    }

28.renameTo(File dest) 返回值boolean

对File实例代表的文件或者文件夹进行重新命名,可用来进行移动文件功能。

存在四种情况会移动失败:第一,file实例代表的源文件不存在,第二,dir代表的文件不存在,第三,两者都不存在,还有一种是硬盘格式不同也会导致移动失败,有人测试过。

实例如下:

 public boolean copyFiles(String srcPath,String destPath){
  File file = new File(srcPath);
  File dir = new File(destPath);
  boolean success = file.renameTo(new File(dir,file.getName()));
  return success;
  }

源代码:

public boolean renameTo(File dest) {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkWrite(path);
            security.checkWrite(dest.path);
        }
        if (dest == null) {
            throw new NullPointerException();
        }
        if (this.isInvalid() || dest.isInvalid()) {
            return false;
        }
        return fs.rename(this, dest);
    }

29.剩下的一些方法大多跟设置文件属性值有关,就不详细列举了,只大概写一下

setLastModified(long time) 设置文件最后一次修改时间。

setReadOnly() 设置文件或目录只允许读操作。

setWritable(boolean writable, boolean ownerOnly)

  • writable --如果为true,允许写访问权限;如果为false,写访问权限是不允许的。
  • ownerOnly --如果为true,则写访问权限仅适用于所有者,否则它适用于所有人。

setWritable(boolean writable)

  • writable --如果为true,允许写访问权限;如果为false,写访问权限是不允许的。

setReadable(boolean readable, boolean ownerOnly)

  • readable -- true时是设置访问在未经许可允许读操作。
  • ownerOnly -- 只有读权限适用于业主的读取权限,如果ownerOnly设置为true;否则返回false。

setReadable(boolean readable)

  • readable -- true时是设置访问在未经许可允许读操作。

setExecutable(boolean executable, boolean ownerOnly)

  • executable -- 为true时设置访问权限,允许执行的操作,假否认执行操作。
  • ownerOnly -- 为true时设置执行权限只对主人的执行权限为ture; 否则,它适用于每一个人。

setExecutable(boolean executable)

  • executable -- 设置访问权限为true,允许执行的操作,否则执行操作为false。

canExecute()

此方法返回布尔值-true,如果指定的文件存在的路径名和文件允许应用程序读取。

listRoots()

该方法返回指示可用的文件系统的根文件对象的数组。如果不能确定该组的根该方法返回null。

getTotalSpace()

该方法返回指定的文件夹或者文件内容大小。

getFreeSpace()

返回未分配空间大小。

getUsableSpace()

该方法返回该分区上的可用的字节数

compareTo()
public int compareTo(File pathname)按字母顺序比较两个抽象路径名。此方法定义的顺序取决于底层系统。在 UNIX 系统上,比较路径名时,字母大小写通常很重要,而在 Microsoft Windows 系统上,这通常不重要。

以上基本是File这个类中的大部分函数,也许还存在函数方法我未列举出,如果我发现我会补充,有不足之处或者错误的地方,可以留言给我,我会修改,谢谢。

时间: 2024-10-11 10:25:22

Java IO流(第二讲):File类的相关文章

J2SE知识点归纳笔记(七)---Java IO Part 1:File类与RandomAccessFile类

J2SE知识点归纳笔记(七)---Java IO Part 1:File类与RandomAccessFile类                                                                 --转载请注明出处:coder-pig 本节引言: 兜兜转转,又回来写Java了,上一篇J2SE知识点归纳笔记(六)---Java常用类是上2014.4.14写的,时隔一年 又来重拾之前还没写完的系列了,前些天群里一个妹子反映她Java基础薄弱,然后抱怨在cs

Java 基础(三)| IO流之使用 File 类的正确姿势

为跳槽面试做准备,今天开始进入 Java 基础的复习.希望基础不好的同学看完这篇文章,能掌握泛型,而基础好的同学权当复习,希望看完这篇文章能够起一点你的青涩记忆. 一.什么是 File 类? java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建.查找和删除等操作. 二.File 类的使用 2.1 构造方法 File 类的构造有三种: public File(String pathname) : 直接通过文件路径字符串创建 public File(String par

java IO流技术 之 File

IO流技术 概念:input - output 输入输出流: 输入:将文件读到内存中: 输出:将文件从内存中写出到其他地方 作用:主要就是解决设备和设备之间的数据传输问题. File :文件类的使用十分重要 (一)file的构造方法 1 public static void test1(){ 2 3 //三种拼接路径方式 4 //1.直接拼接 5 File filePath = new File("C:\\123\\aaa"); 6 System.out.println("是

Java IO学习笔记:File类

File类 在整个IO包了,唯一表示与文件本身有关的类就是File类.使用File类可以进行1创建或删除文件等常用操作.要想使用File类.则首先要观察File类的构造方法,此类的      常用构造方法如下所示:public File(String pathname) 实例化File类的时候,必须设置好路径 No. 方法或常量 类型 描述 1 public static final String pathSeparator 常量 表示路径的分隔符(windows是“;”) 2 public s

用IO流中的File类来创建文件及目录

题目如下: 设计一个命令窗口程序,要求按照如下的格式显示 例如:===利用命令窗口完成文件的操作===(1)创建目录 (2)创建文件 (3)删除目录 (4)删除文件 ===现在正在做创建目录的操作===目录名字:liu目录路径:F:\\Jinglin\\ZY\\创建成功,选1回到命令窗口界面,选2退出程序 ===现在正在做创建文件的操作===文件名字:liu文件路径:F:\\Jinglin\\ZY\\创建成功,选1回到命令窗口界面,选2退出程序 ===现在正在做删除目录的操作===目录名字:li

Java IO流详解(二)——File类

在上一章博客中简单的介绍了Java IO流的一些特征.也就是对文件的输入输出,既然至始至终都离不开文件,所以Java IO流的使用得从File这个类讲起. File类的描述:File类是文件和目录路径名的抽象表示形式,主要用于文件和目录的创建.查找和删除等操作.即Java中把文件或者目录(文件夹)都封装成File对象.也就是说如果我们要去操作硬盘上的文件或者目录只要创建File这个类即可. 不过要注意的是File类只是对文件的操作类,只能对文件本身进行操作,不能对文件内容进行操作. 1.File

Java IO流中 File文件对象与Properties类

File类 用来将文件或目录封装成对象 方便对文件或目录信息进行处理 File对象可以作为参数传递给流进行操作 File类常用方法 创建 booleancreateNewFile():创建新文件,如果文件存在,返回false booleanmkdir():创建目录,只能创建一级目录 booleanmkdirs():创建目录,可创建多级目录 删除 booleandelete():删除文件,如果文件不存在,返回false,如果删除的是目录,需要确保目录是空的 voiddeleteOnExit():程

Java IO流详尽解析(转自 http://www.2cto.com/kf/201312/262036.html)

流的概念和作用 学习Java IO,不得不提到的就是JavaIO流. 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作. IO流的分类 根据处理数据类型的不同分为:字符流和字节流 根据数据流向不同分为:输入流和输出流 字符流和字节流 字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象.本质其实就是基于字节流读取时,去查了指定的码表.字节流和字符流的区别

文件传输基础——Java IO流

第一章 文件的编码 package com.imooc.io; public class EncodeDemo { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String s="欢迎你ABC"; byte[] byte1=s.getBytes(); for (byte b : byte1) { //把字节转换成16进制的方式显示 Sys