zeo112140

JDK源码学习（二）-------------java.io(附录java.io.file源码)

通过数据流、序列化和文件系统提供系统输入和输出。

请参见：
描述

接口摘要
Closeable	Closeable 是可以关闭的数据源或目标。
DataInput	`DataInput` 接口用于从二进制流中读取字节，并根据所有 Java 基本类型数据进行重构。
DataOutput	`DataOutput` 接口用于将数据从任意 Java 基本类型转换为一系列字节，并将这些字节写入二进制流。
Externalizable	Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。
FileFilter	用于抽象路径名的过滤器。
FilenameFilter	实现此接口的类实例可用于过滤器文件名。
Flushable	Flushable 是可刷新数据的目标地。
ObjectInput	ObjectInput 扩展 DataInput 接口以包含对象的读操作。
ObjectInputValidation	允许验证图形中对象的回调接口。
ObjectOutput	ObjectOutput 扩展 DataOutput 接口以包含对象的写入操作。
ObjectStreamConstants	写入 Object Serialization Stream 的常量。
Serializable	类通过实现 java.io.Serializable 接口以启用其序列化功能。

类摘要
BufferedInputStream	`BufferedInputStream` 为另一个输入流添加一些功能，即缓冲输入以及支持`mark` 和`reset` 方法的能力。
BufferedOutputStream	该类实现缓冲的输出流。
BufferedReader	从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedWriter	将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
ByteArrayInputStream	`ByteArrayInputStream` 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。
ByteArrayOutputStream	此类实现了一个输出流，其中的数据被写入一个 byte 数组。
CharArrayReader	此类实现一个可用作字符输入流的字符缓冲区。
CharArrayWriter	此类实现一个可用作 Writer 的字符缓冲区。
Console	此类包含多个方法，可访问与当前 Java 虚拟机关联的基于字符的控制台设备（如果有）。
DataInputStream	数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。
DataOutputStream	数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。
File	文件和目录路径名的抽象表示形式。
FileDescriptor	文件描述符类的实例用作与基础机器有关的某种结构的不透明句柄，该结构表示开放文件、开放套接字或者字节的另一个源或接收者。
FileInputStream	`FileInputStream` 从文件系统中的某个文件中获得输入字节。
FileOutputStream	文件输出流是用于将数据写入 `File` 或 `FileDescriptor` 的输出流。
FilePermission	此类表示对文件和目录的访问。
FileReader	用来读取字符文件的便捷类。
FileWriter	用来写入字符文件的便捷类。
FilterInputStream	`FilterInputStream` 包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
FilterOutputStream	此类是过滤输出流的所有类的超类。
FilterReader	用于读取已过滤的字符流的抽象类。
FilterWriter	用于写入已过滤的字符流的抽象类。
InputStream	此抽象类是表示字节输入流的所有类的超类。
InputStreamReader	InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 `charset` 读取字节并将其解码为字符。
LineNumberInputStream	已过时。此类错误假定字节能充分表示字符。
LineNumberReader	跟踪行号的缓冲字符输入流。
ObjectInputStream	ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
ObjectInputStream.GetField	提供对从输入流读取的持久字段的访问权限。
ObjectOutputStream	ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。
ObjectOutputStream.PutField	提供对要写入 ObjectOutput 的持久字段的编程访问。
ObjectStreamClass	类的序列化描述符。
ObjectStreamField	Serializable 类中 Serializable 字段的描述。
OutputStream	此抽象类是表示输出字节流的所有类的超类。
OutputStreamWriter	OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 `charset` 将要写入流中的字符编码成字节。
PipedInputStream	管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。
PipedOutputStream	可以将管道输出流连接到管道输入流来创建通信管道。
PipedReader	传送的字符输入流。
PipedWriter	传送的字符输出流。
PrintStream	`PrintStream` 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
PrintWriter	向文本输出流打印对象的格式化表示形式。
PushbackInputStream	`PushbackInputStream` 为另一个输入流添加性能，即“推回 (push back)”或“取消读取 (unread)”一个字节的能力。
PushbackReader	允许将字符推回到流的字符流 reader。
RandomAccessFile	此类的实例支持对随机访问文件的读取和写入。
Reader	用于读取字符流的抽象类。
SequenceInputStream	`SequenceInputStream` 表示其他输入流的逻辑串联。
SerializablePermission	此类用于可序列化权限。
StreamTokenizer	`StreamTokenizer` 类获取输入流并将其解析为“标记”，允许一次读取一个标记。
StringBufferInputStream	已过时。此类未能正确地将字符转换为字节。
StringReader	其源为一个字符串的字符流。
StringWriter	一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。
Writer	写入字符流的抽象类。

异常摘要
CharConversionException	用于字符转换异常的基类。
EOFException	当输入过程中意外到达文件或流的末尾时，抛出此异常。
FileNotFoundException	当试图打开指定路径名表示的文件失败时，抛出此异常。
InterruptedIOException	I/O 操作已中断信号，抛出此异常。
InvalidClassException	当 Serialization 运行时检测到某个类具有以下问题之一时，抛出此异常。
InvalidObjectException	指示一个或多个反序列化对象未通过验证测试。
IOException	当发生某种 I/O 异常时，抛出此异常。
NotActiveException	当序列化和反序列化不活动时，抛出此异常。
NotSerializableException	当实例需要具有序列化接口时，抛出此异常。
ObjectStreamException	特定于 Object Stream 类的所有异常的超类。
OptionalDataException	指示对象读取操作失败的异常，原因是无法读取流中的基本数据或已序列化对象的数据末尾。
StreamCorruptedException	当从对象流中读取的控制信息与内部一致性检查相冲突时，抛出此异常。
SyncFailedException	当 sync 操作失败时，抛出此异常。
UnsupportedEncodingException	不支持字符编码。
UTFDataFormatException	在数据输入流中或由实现该数据输入接口的任何类中以 UTF-8 修改版格式读取错误字符串时，抛出此异常。
WriteAbortedException	在写入操作过程中抛出 ObjectStreamException 之一的信号。

错误摘要
IOError	当发生严重的 I/O 错误时，抛出此错误。

软件包 java.io 的描述

通过数据流、序列化和文件系统提供系统输入和输出。除非另有说明，否则向此包的任何类或接口中的构造方法或方法传递 null 参数时，都将抛出NullPointerException。

包规范

Java Object Serialization Specification

相关文档

有关概述、教程、示例、指南和工具文档的信息，请参阅：

Serialization Enhancements

从以下版本开始：: JDK1.0

————————————————java.io.file————————————————————————————————————————————

/*
* @(#)File.java 1.143 09/12/06
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/

package java.io;

import java.net.URI;
import java.net.URL;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Map;
import java.util.Hashtable;
import java.security.AccessController;
import java.security.AccessControlException;
import java.security.SecureRandom;
import sun.security.action.GetPropertyAction;

/**
* An abstract representation of file and directory pathnames.
*
* User interfaces and operating systems use system-dependent pathname
* strings to name files and directories. This class presents an
* abstract, system-independent view of hierarchical pathnames. An
* abstract pathname has two components:
*
* <ol>
* <li> An optional system-dependent prefix string,
* such as a disk-drive specifier, <code>"/"</code> for the UNIX root
* directory, or <code>"\\\\"</code> for a Microsoft Windows UNC pathname, and
* <li> A sequence of zero or more string names.
* </ol>
*
* The first name in an abstract pathname may be a directory name or, in the
* case of Microsoft Windows UNC pathnames, a hostname. Each subsequent name
* in an abstract pathname denotes a directory; the last name may denote
* either a directory or a file. The empty abstract pathname has no
* prefix and an empty name sequence.
*
* The conversion of a pathname string to or from an abstract pathname is
* inherently system-dependent. When an abstract pathname is converted into a
* pathname string, each name is separated from the next by a single copy of
* the default separator character. The default name-separator
* character is defined by the system property <code>file.separator</code>, and
* is made available in the public static fields <code>{@link
* #separator}</code> and <code>{@link #separatorChar}</code> of this class.
* When a pathname string is converted into an abstract pathname, the names
* within it may be separated by the default name-separator character or by any
* other name-separator character that is supported by the underlying system.
*
* A pathname, whether abstract or in string form, may be either
* absolute or relative. An absolute pathname is complete in
* that no other information is required in order to locate the file that it
* denotes. A relative pathname, in contrast, must be interpreted in terms of
* information taken from some other pathname. By default the classes in the
* <code>java.io</code> package always resolve relative pathnames against the
* current user directory. This directory is named by the system property
* <code>user.dir</code>, and is typically the directory in which the Java
* virtual machine was invoked.
*
* The parent of an abstract pathname may be obtained by invoking
* the {@link #getParent} method of this class and consists of the pathname's
* prefix and each name in the pathname's name sequence except for the last.
* Each directory's absolute pathname is an ancestor of any <tt>File</tt>
* object with an absolute abstract pathname which begins with the directory's
* absolute pathname. For example, the directory denoted by the abstract
* pathname <tt>"/usr"</tt> is an ancestor of the directory denoted by the
* pathname <tt>"/usr/local/bin"</tt>.
*
* The prefix concept is used to handle root directories on UNIX platforms,
* and drive specifiers, root directories and UNC pathnames on Microsoft Windows platforms,
* as follows:
*
* <ul>
*
* <li> For UNIX platforms, the prefix of an absolute pathname is always
* <code>"/"</code>. Relative pathnames have no prefix. The abstract pathname
* denoting the root directory has the prefix <code>"/"</code> and an empty
* name sequence.
*
* <li> For Microsoft Windows platforms, the prefix of a pathname that contains a drive
* specifier consists of the drive letter followed by <code>":"</code> and
* possibly followed by <code>"\\"</code> if the pathname is absolute. The
* prefix of a UNC pathname is <code>"\\\\"</code>; the hostname and the share
* name are the first two names in the name sequence. A relative pathname that
* does not specify a drive has no prefix.
*
* </ul>
*
* Instances of this class may or may not denote an actual file-system
* object such as a file or a directory. If it does denote such an object
* then that object resides in a partition. A partition is an
* operating system-specific portion of storage for a file system. A single
* storage device (e.g. a physical disk-drive, flash memory, CD-ROM) may
* contain multiple partitions. The object, if any, will reside on the
* partition <a name="partName">named</a> by some ancestor of the absolute
* form of this pathname.
*
* A file system may implement restrictions to certain operations on the
* actual file-system object, such as reading, writing, and executing. These
* restrictions are collectively known as access permissions. The file
* system may have multiple sets of access permissions on a single object.
* For example, one set may apply to the object's owner, and another
* may apply to all other users. The access permissions on an object may
* cause some methods in this class to fail.
*
* Instances of the <code>File</code> class are immutable; that is, once
* created, the abstract pathname represented by a <code>File</code> object
* will never change.
*
* @version 1.143, 12/06/09
* @author unascribed
* @since JDK1.0
*/

public class File
implements Serializable, Comparable<File>
{

    /**
     * The FileSystem object representing the platform's local file system.
     */
    static private FileSystem fs = FileSystem.getFileSystem();

    /**
     * This abstract pathname's normalized pathname string. A normalized
     * pathname string uses the default name-separator character and does not
     * contain any duplicate or redundant separators.
     *
     * @serial
     */
    private String path;

    /**
     * The length of this abstract pathname's prefix, or zero if it has no
     * prefix.
     */
    private transient int prefixLength;

    /**
     * Returns the length of this abstract pathname's prefix.
     * For use by FileSystem classes.
     */
    int getPrefixLength() {
return prefixLength;
    }

/**
 * The system-dependent default name-separator character. This field is
 * initialized to contain the first character of the value of the system
 * property <code>file.separator</code>. On UNIX systems the value of this
 * field is <code>'/'</code>; on Microsoft Windows systems it is <code>'\\'</code>.
 *
 * @see java.lang.System#getProperty(java.lang.String)
 */
 public static final char separatorChar = fs.getSeparator();

/**
 * The system-dependent default name-separator character, represented as a
 * string for convenience. This string contains a single character, namely
 * <code>{@link #separatorChar}</code>.
 */
 public static final String separator = "" + separatorChar;

/**
 * The system-dependent path-separator character. This field is
 * initialized to contain the first character of the value of the system
 * property <code>path.separator</code>. This character is used to
 * separate filenames in a sequence of files given as a path list.
 * On UNIX systems, this character is <code>':'</code>; on Microsoft Windows systems it
 * is <code>';'</code>.
 *
 * @see java.lang.System#getProperty(java.lang.String)
 */
 public static final char pathSeparatorChar = fs.getPathSeparator();

/**
 * The system-dependent path-separator character, represented as a string
 * for convenience. This string contains a single character, namely
 * <code>{@link #pathSeparatorChar}</code>.
 */
 public static final String pathSeparator = "" + pathSeparatorChar;

/* -- Constructors -- */

    /**
     * Internal constructor for already-normalized pathname strings.
     */
    private File(String pathname, int prefixLength) {
this.path = pathname;
this.prefixLength = prefixLength;
    }

    /**
     * Internal constructor for already-normalized pathname strings.
     * The parameter order is used to disambiguate this method from the
     * public(File, String) constructor.
     */
    private File(String child, File parent) {
        assert parent.path != null;
        assert (!parent.path.equals(""));
        this.path = fs.resolve(parent.path, child);
this.prefixLength = parent.prefixLength;
    }

/**
 * Creates a new <code>File</code> instance by converting the given
 * pathname string into an abstract pathname. If the given string is
 * the empty string, then the result is the empty abstract pathname.
 *
 * @param pathname A pathname string
 * @throws NullPointerException
 * If the <code>pathname</code> argument is <code>null</code>
 */
 public File(String pathname) {
if (pathname == null) {
 throw new NullPointerException();
}
this.path = fs.normalize(pathname);
this.prefixLength = fs.prefixLength(this.path);
 }

    /* Note: The two-argument File constructors do not interpret an empty
       parent abstract pathname as the current user directory. An empty parent
       instead causes the child to be resolved against the system-dependent
       directory defined by the FileSystem.getDefaultParent method. On Unix
       this default is "/", while on Microsoft Windows it is "\\". This is required for
       compatibility with the original behavior of this class. */

/**
 * Creates a new <code>File</code> instance from a parent pathname string
 * and a child pathname string.
 *
 * If <code>parent</code> is <code>null</code> then the new
 * <code>File</code> instance is created as if by invoking the
 * single-argument <code>File</code> constructor on the given
 * <code>child</code> pathname string.
 *
 * Otherwise the <code>parent</code> pathname string is taken to denote
 * a directory, and the <code>child</code> pathname string is taken to
 * denote either a directory or a file. If the <code>child</code> pathname
 * string is absolute then it is converted into a relative pathname in a
 * system-dependent way. If <code>parent</code> is the empty string then
 * the new <code>File</code> instance is created by converting
 * <code>child</code> into an abstract pathname and resolving the result
 * against a system-dependent default directory. Otherwise each pathname
 * string is converted into an abstract pathname and the child abstract
 * pathname is resolved against the parent.
 *
 * @param parent The parent pathname string
 * @param child The child pathname string
 * @throws NullPointerException
 * If <code>child</code> is <code>null</code>
 */
 public File(String parent, String child) {
if (child == null) {
 throw new NullPointerException();
}
if (parent != null) {
 if (parent.equals("")) {
 this.path = fs.resolve(fs.getDefaultParent(),
 fs.normalize(child));
 } else {
 this.path = fs.resolve(fs.normalize(parent),
 fs.normalize(child));
 }
} else {
 this.path = fs.normalize(child);
}
this.prefixLength = fs.prefixLength(this.path);
 }

/**
 * Creates a new <code>File</code> instance from a parent abstract
 * pathname and a child pathname string.
 *
 * If <code>parent</code> is <code>null</code> then the new
 * <code>File</code> instance is created as if by invoking the
 * single-argument <code>File</code> constructor on the given
 * <code>child</code> pathname string.
 *
 * Otherwise the <code>parent</code> abstract pathname is taken to
 * denote a directory, and the <code>child</code> pathname string is taken
 * to denote either a directory or a file. If the <code>child</code>
 * pathname string is absolute then it is converted into a relative
 * pathname in a system-dependent way. If <code>parent</code> is the empty
 * abstract pathname then the new <code>File</code> instance is created by
 * converting <code>child</code> into an abstract pathname and resolving
 * the result against a system-dependent default directory. Otherwise each
 * pathname string is converted into an abstract pathname and the child
 * abstract pathname is resolved against the parent.
 *
 * @param parent The parent abstract pathname
 * @param child The child pathname string
 * @throws NullPointerException
 * If <code>child</code> is <code>null</code>
 */
 public File(File parent, String child) {
if (child == null) {
 throw new NullPointerException();
}
if (parent != null) {
 if (parent.path.equals("")) {
 this.path = fs.resolve(fs.getDefaultParent(),
 fs.normalize(child));
 } else {
 this.path = fs.resolve(parent.path,
 fs.normalize(child));
 }
} else {
 this.path = fs.normalize(child);
}
this.prefixLength = fs.prefixLength(this.path);
 }

/**
 * Creates a new <tt>File</tt> instance by converting the given
 * <tt>file:</tt> URI into an abstract pathname.
 *
 * The exact form of a <tt>file:</tt> URI is system-dependent, hence
 * the transformation performed by this constructor is also
 * system-dependent.
 *
 * For a given abstract pathname f it is guaranteed that
 *
 * <blockquote><tt>
 * new File(</tt> f<tt>.{@link #toURI() toURI}()).equals(</tt> f<tt>.{@link #getAbsoluteFile() getAbsoluteFile}())
 * </tt></blockquote>
 *
 * so long as the original abstract pathname, the URI, and the new abstract
 * pathname are all created in (possibly different invocations of) the same
 * Java virtual machine. This relationship typically does not hold,
 * however, when a <tt>file:</tt> URI that is created in a virtual machine
 * on one operating system is converted into an abstract pathname in a
 * virtual machine on a different operating system.
 *
 * @param uri
 * An absolute, hierarchical URI with a scheme equal to
 * <tt>"file"</tt>, a non-empty path component, and undefined
 * authority, query, and fragment components
 *
 * @throws NullPointerException
 * If <tt>uri</tt> is <tt>null</tt>
 *
 * @throws IllegalArgumentException
 * If the preconditions on the parameter do not hold
 *
 * @see #toURI()
 * @see java.net.URI
 * @since 1.4
 */
 public File(URI uri) {

// Check our many preconditions
if (!uri.isAbsolute())
     throw new IllegalArgumentException("URI is not absolute");
if (uri.isOpaque())
     throw new IllegalArgumentException("URI is not hierarchical");
String scheme = uri.getScheme();
if ((scheme == null) || !scheme.equalsIgnoreCase("file"))
     throw new IllegalArgumentException("URI scheme is not \"file\"");
if (uri.getAuthority() != null)
     throw new IllegalArgumentException("URI has an authority component");
if (uri.getFragment() != null)
     throw new IllegalArgumentException("URI has a fragment component");
if (uri.getQuery() != null)
     throw new IllegalArgumentException("URI has a query component");
String p = uri.getPath();
if (p.equals(""))
     throw new IllegalArgumentException("URI path component is empty");

// Okay, now initialize
p = fs.fromURIPath(p);
if (File.separatorChar != '/')
p = p.replace('/', File.separatorChar);
this.path = fs.normalize(p);
this.prefixLength = fs.prefixLength(this.path);
}

/* -- Path-component accessors -- */

/**
 * Returns the name of the file or directory denoted by this abstract
 * pathname. This is just the last name in the pathname's name
 * sequence. If the pathname's name sequence is empty, then the empty
 * string is returned.
 *
 * @return The name of the file or directory denoted by this abstract
 * pathname, or the empty string if this pathname's name sequence
 * is empty
 */
 public String getName() {
int index = path.lastIndexOf(separatorChar);
if (index < prefixLength) return path.substring(prefixLength);
return path.substring(index + 1);
 }

/**
 * Returns the pathname string of this abstract pathname's parent, or
 * <code>null</code> if this pathname does not name a parent directory.
 *
 * The parent of an abstract pathname consists of the
 * pathname's prefix, if any, and each name in the pathname's name
 * sequence except for the last. If the name sequence is empty then
 * the pathname does not name a parent directory.
 *
 * @return The pathname string of the parent directory named by this
 * abstract pathname, or <code>null</code> if this pathname
 * does not name a parent
 */
 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);
 }

/**
 * Returns the abstract pathname of this abstract pathname's parent,
 * or <code>null</code> if this pathname does not name a parent
 * directory.
 *
 * The parent of an abstract pathname consists of the
 * pathname's prefix, if any, and each name in the pathname's name
 * sequence except for the last. If the name sequence is empty then
 * the pathname does not name a parent directory.
 *
 * @return The abstract pathname of the parent directory named by this
 * abstract pathname, or <code>null</code> if this pathname
 * does not name a parent
 *
 * @since 1.2
 */
 public File getParentFile() {
String p = this.getParent();
if (p == null) return null;
return new File(p, this.prefixLength);
 }

    /**
     * Converts this abstract pathname into a pathname string. The resulting
     * string uses the {@link #separator default name-separator character} to
     * separate the names in the name sequence.
     *
     * @return The string form of this abstract pathname
     */
    public String getPath() {
return path;
    }

/* -- Path operations -- */

/**
 * Tests whether this abstract pathname is absolute. The definition of
 * absolute pathname is system dependent. On UNIX systems, a pathname is
 * absolute if its prefix is <code>"/"</code>. On Microsoft Windows systems, a
 * pathname is absolute if its prefix is a drive specifier followed by
 * <code>"\\"</code>, or if its prefix is <code>"\\\\"</code>.
 *
 * @return <code>true</code> if this abstract pathname is absolute,
 * <code>false</code> otherwise
 */
 public boolean isAbsolute() {
return fs.isAbsolute(this);
 }

/**
 * Returns the absolute pathname string of this abstract pathname.
 *
 * If this abstract pathname is already absolute, then the pathname
 * string is simply returned as if by the <code>{@link #getPath}</code>
 * method. If this abstract pathname is the empty abstract pathname then
 * the pathname string of the current user directory, which is named by the
 * system property <code>user.dir</code>, is returned. Otherwise this
 * pathname is resolved in a system-dependent way. On UNIX systems, a
 * relative pathname is made absolute by resolving it against the current
 * user directory. On Microsoft Windows systems, a relative pathname is made absolute
 * by resolving it against the current directory of the drive named by the
 * pathname, if any; if not, it is resolved against the current user
 * directory.
 *
 * @return The absolute pathname string denoting the same file or
 * directory as this abstract pathname
 *
 * @throws SecurityException
 * If a required system property value cannot be accessed.
 *
 * @see java.io.File#isAbsolute()
 */
 public String getAbsolutePath() {
return fs.resolve(this);
 }

/**
 * Returns the absolute form of this abstract pathname. Equivalent to
 * <code>new File(this.{@link #getAbsolutePath})</code>.
 *
 * @return The absolute abstract pathname denoting the same file or
 * directory as this abstract pathname
 *
 * @throws SecurityException
 * If a required system property value cannot be accessed.
 *
 * @since 1.2
 */
 public File getAbsoluteFile() {
 String absPath = getAbsolutePath();
return new File(absPath, fs.prefixLength(absPath));
 }

/**
 * Returns the canonical pathname string of this abstract pathname.
 *
 * A canonical pathname is both absolute and unique. The precise
 * definition of canonical form is system-dependent. This method first
 * converts this pathname to absolute form if necessary, as if by invoking the
 * {@link #getAbsolutePath} method, and then maps it to its unique form in a
 * system-dependent way. This typically involves removing redundant names
 * such as <tt>"."</tt> and <tt>".."</tt> from the pathname, resolving
 * symbolic links (on UNIX platforms), and converting drive letters to a
 * standard case (on Microsoft Windows platforms).
 *
 * Every pathname that denotes an existing file or directory has a
 * unique canonical form. Every pathname that denotes a nonexistent file
 * or directory also has a unique canonical form. The canonical form of
 * the pathname of a nonexistent file or directory may be different from
 * the canonical form of the same pathname after the file or directory is
 * created. Similarly, the canonical form of the pathname of an existing
 * file or directory may be different from the canonical form of the same
 * pathname after the file or directory is deleted.
 *
 * @return The canonical pathname string denoting the same file or
 * directory as this abstract pathname
 *
 * @throws IOException
 * If an I/O error occurs, which is possible because the
 * construction of the canonical pathname may require
 * filesystem queries
 *
 * @throws SecurityException
 * If a required system property value cannot be accessed, or
 * if a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead}</code> method denies
 * read access to the file
 *
 * @since JDK1.1
 */
 public String getCanonicalPath() throws IOException {
return fs.canonicalize(fs.resolve(this));
 }

/**
 * Returns the canonical form of this abstract pathname. Equivalent to
 * <code>new File(this.{@link #getCanonicalPath})</code>.
 *
 * @return The canonical pathname string denoting the same file or
 * directory as this abstract pathname
 *
 * @throws IOException
 * If an I/O error occurs, which is possible because the
 * construction of the canonical pathname may require
 * filesystem queries
 *
 * @throws SecurityException
 * If a required system property value cannot be accessed, or
 * if a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead}</code> method denies
 * read access to the file
 *
 * @since 1.2
 */
 public File getCanonicalFile() throws IOException {
 String canonPath = getCanonicalPath();
return new File(canonPath, fs.prefixLength(canonPath));
 }

    private static String slashify(String path, boolean isDirectory) {
String p = path;
if (File.separatorChar != '/')
     p = p.replace(File.separatorChar, '/');
if (!p.startsWith("/"))
     p = "/" + p;
if (!p.endsWith("/") && isDirectory)
     p = p + "/";
return p;
    }

/**
 * Converts this abstract pathname into a <code>file:</code> URL. The
 * exact form of the URL is system-dependent. If it can be determined that
 * the file denoted by this abstract pathname is a directory, then the
 * resulting URL will end with a slash.
 *
 * @return A URL object representing the equivalent file URL
 *
 * @throws MalformedURLException
 * If the path cannot be parsed as a URL
 *
 * @see #toURI()
 * @see java.net.URI
 * @see java.net.URI#toURL()
 * @see java.net.URL
 * @since 1.2
 *
 * @deprecated This method does not automatically escape characters that
 * are illegal in URLs. It is recommended that new code convert an
 * abstract pathname into a URL by first converting it into a URI, via the
 * {@link #toURI() toURI} method, and then converting the URI into a URL
 * via the {@link java.net.URI#toURL() URI.toURL} method.
 */
 @Deprecated
 public URL toURL() throws MalformedURLException {
return new URL("file", "", slashify(getAbsolutePath(), isDirectory()));
 }

/**
 * Constructs a <tt>file:</tt> URI that represents this abstract pathname.
 *
 * The exact form of the URI is system-dependent. If it can be
 * determined that the file denoted by this abstract pathname is a
 * directory, then the resulting URI will end with a slash.
 *
 * For a given abstract pathname f, it is guaranteed that
 *
 * <blockquote><tt>
 * new {@link #File(java.net.URI) File}(</tt> f<tt>.toURI()).equals(</tt> f<tt>.{@link #getAbsoluteFile() getAbsoluteFile}())
 * </tt></blockquote>
 *
 * so long as the original abstract pathname, the URI, and the new abstract
 * pathname are all created in (possibly different invocations of) the same
 * Java virtual machine. Due to the system-dependent nature of abstract
 * pathnames, however, this relationship typically does not hold when a
 * <tt>file:</tt> URI that is created in a virtual machine on one operating
 * system is converted into an abstract pathname in a virtual machine on a
 * different operating system.
 *
 * @return An absolute, hierarchical URI with a scheme equal to
 * <tt>"file"</tt>, a path representing this abstract pathname,
 * and undefined authority, query, and fragment components
 * @throws SecurityException If a required system property value cannot
 * be accessed.
 *
 * @see #File(java.net.URI)
 * @see java.net.URI
 * @see java.net.URI#toURL()
 * @since 1.4
 */
 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
}
 }

/* -- Attribute accessors -- */

/**
 * Tests whether the application can read the file denoted by this
 * abstract pathname.
 *
 * @return <code>true</code> if and only if the file specified by this
 * abstract pathname exists and can be read by the
 * application; <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file
 */
 public boolean canRead() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return fs.checkAccess(this, FileSystem.ACCESS_READ);
 }

/**
 * Tests whether the application can modify the file denoted by this
 * abstract pathname.
 *
 * @return <code>true</code> if and only if the file system actually
 * contains a file denoted by this abstract pathname and
 * the application is allowed to write to the file;
 * <code>false</code> otherwise.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 */
 public boolean canWrite() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.checkAccess(this, FileSystem.ACCESS_WRITE);
 }

/**
 * Tests whether the file or directory denoted by this abstract pathname
 * exists.
 *
 * @return <code>true</code> if and only if the file or directory denoted
 * by this abstract pathname exists; <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file or directory
 */
 public boolean exists() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return ((fs.getBooleanAttributes(this) & FileSystem.BA_EXISTS) != 0);
 }

/**
 * Tests whether the file denoted by this abstract pathname is a
 * directory.
 *
 * @return <code>true</code> if and only if the file denoted by this
 * abstract pathname exists and is a directory;
 * <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file
 */
 public boolean isDirectory() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return ((fs.getBooleanAttributes(this) & FileSystem.BA_DIRECTORY)
 != 0);
 }

/**
 * Tests whether the file denoted by this abstract pathname is a normal
 * file. A file is normal if it is not a directory and, in
 * addition, satisfies other system-dependent criteria. Any non-directory
 * file created by a Java application is guaranteed to be a normal file.
 *
 * @return <code>true</code> if and only if the file denoted by this
 * abstract pathname exists and is a normal file;
 * <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file
 */
 public boolean isFile() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return ((fs.getBooleanAttributes(this) & FileSystem.BA_REGULAR) != 0);
 }

/**
 * Tests whether the file named by this abstract pathname is a hidden
 * file. The exact definition of hidden is system-dependent. On
 * UNIX systems, a file is considered to be hidden if its name begins with
 * a period character (<code>'.'</code>). On Microsoft Windows systems, a file is
 * considered to be hidden if it has been marked as such in the filesystem.
 *
 * @return <code>true</code> if and only if the file denoted by this
 * abstract pathname is hidden according to the conventions of the
 * underlying platform
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file
 *
 * @since 1.2
 */
 public boolean isHidden() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return ((fs.getBooleanAttributes(this) & FileSystem.BA_HIDDEN) != 0);
 }

/**
 * Returns the time that the file denoted by this abstract pathname was
 * last modified.
 *
 * @return A <code>long</code> value representing the time the file was
 * last modified, measured in milliseconds since the epoch
 * (00:00:00 GMT, January 1, 1970), or <code>0L</code> if the
 * file does not exist or if an I/O error occurs
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file
 */
 public long lastModified() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return fs.getLastModifiedTime(this);
 }

/**
 * Returns the length of the file denoted by this abstract pathname.
 * The return value is unspecified if this pathname denotes a directory.
 *
 * @return The length, in bytes, of the file denoted by this abstract
 * pathname, or <code>0L</code> if the file does not exist. Some
 * operating systems may return <code>0L</code> for pathnames
 * denoting system-dependent entities such as devices or pipes.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the file
 */
 public long length() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return fs.getLength(this);
 }

/* -- File operations -- */

/**
 * Atomically creates a new, empty file named by this abstract pathname if
 * and only if a file with this name does not yet exist. The check for the
 * existence of the file and the creation of the file if it does not exist
 * are a single operation that is atomic with respect to all other
 * filesystem activities that might affect the file.
 * 
 * Note: this method should not be used for file-locking, as
 * the resulting protocol cannot be made to work reliably. The
 * {@link java.nio.channels.FileLock FileLock}
 * facility should be used instead.
 *
 * @return <code>true</code> if the named file does not exist and was
 * successfully created; <code>false</code> if the named file
 * already exists
 *
 * @throws IOException
 * If an I/O error occurred
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 *
 * @since 1.2
 */
 public boolean createNewFile() throws IOException {
SecurityManager security = System.getSecurityManager();
if (security != null) security.checkWrite(path);
return fs.createFileExclusively(path);
 }

/**
 * Deletes the file or directory denoted by this abstract pathname. If
 * this pathname denotes a directory, then the directory must be empty in
 * order to be deleted.
 *
 * @return <code>true</code> if and only if the file or directory is
 * successfully deleted; <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkDelete}</code> method denies
 * delete access to the file
 */
 public boolean delete() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkDelete(path);
}
return fs.delete(this);
 }

/**
 * Requests that the file or directory denoted by this abstract
 * pathname be deleted when the virtual machine terminates.
 * Files (or directories) are deleted in the reverse order that
 * they are registered. Invoking this method to delete a file or
 * directory that is already registered for deletion has no effect.
 * Deletion will be attempted only for normal termination of the
 * virtual machine, as defined by the Java Language Specification.
 *
 * Once deletion has been requested, it is not possible to cancel the
 * request. This method should therefore be used with care.
 *
 * 
 * Note: this method should not be used for file-locking, as
 * the resulting protocol cannot be made to work reliably. The
 * {@link java.nio.channels.FileLock FileLock}
 * facility should be used instead.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkDelete}</code> method denies
 * delete access to the file
 *
 * @see #delete
 *
 * @since 1.2
 */
 public void deleteOnExit() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkDelete(path);
}
DeleteOnExitHook.add(path);
 }

/**
 * Returns an array of strings naming the files and directories in the
 * directory denoted by this abstract pathname.
 *
 * If this abstract pathname does not denote a directory, then this
 * method returns <code>null</code>. Otherwise an array of strings is
 * returned, one for each file or directory in the directory. Names
 * denoting the directory itself and the directory's parent directory are
 * not included in the result. Each string is a file name rather than a
 * complete path.
 *
 * There is no guarantee that the name strings in the resulting array
 * will appear in any specific order; they are not, in particular,
 * guaranteed to appear in alphabetical order.
 *
 * @return An array of strings naming the files and directories in the
 * directory denoted by this abstract pathname. The array will be
 * empty if the directory is empty. Returns <code>null</code> if
 * this abstract pathname does not denote a directory, or if an
 * I/O error occurs.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the directory
 */
 public String[] list() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkRead(path);
}
return fs.list(this);
 }

/**
 * Returns an array of strings naming the files and directories in the
 * directory denoted by this abstract pathname that satisfy the specified
 * filter. The behavior of this method is the same as that of the
 * <code>{@link #list()}</code> method, except that the strings in the
 * returned array must satisfy the filter. If the given
 * <code>filter</code> is <code>null</code> then all names are accepted.
 * Otherwise, a name satisfies the filter if and only if the value
 * <code>true</code> results when the <code>{@link
 * FilenameFilter#accept}</code> method of the filter is invoked on this
 * abstract pathname and the name of a file or directory in the directory
 * that it denotes.
 *
 * @param filter A filename filter
 *
 * @return An array of strings naming the files and directories in the
 * directory denoted by this abstract pathname that were accepted
 * by the given <code>filter</code>. The array will be empty if
 * the directory is empty or if no names were accepted by the
 * filter. Returns <code>null</code> if this abstract pathname
 * does not denote a directory, or if an I/O error occurs.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the directory
 */
 public String[] list(FilenameFilter filter) {
String names[] = list();
if ((names == null) || (filter == null)) {
 return names;
}
ArrayList v = new ArrayList();
for (int i = 0 ; i < names.length ; i++) {
 if (filter.accept(this, names[i])) {
 v.add(names[i]);
 }
}
return (String[])(v.toArray(new String[v.size()]));
 }

/**
 * Returns an array of abstract pathnames denoting the files in the
 * directory denoted by this abstract pathname.
 *
 * If this abstract pathname does not denote a directory, then this
 * method returns <code>null</code>. Otherwise an array of
 * <code>File</code> objects is returned, one for each file or directory in
 * the directory. Pathnames denoting the directory itself and the
 * directory's parent directory are not included in the result. Each
 * resulting abstract pathname is constructed from this abstract pathname
 * using the <code>{@link #File(java.io.File, java.lang.String)
 * File(File, String)}</code> constructor. Therefore if this pathname
 * is absolute then each resulting pathname is absolute; if this pathname
 * is relative then each resulting pathname will be relative to the same
 * directory.
 *
 * There is no guarantee that the name strings in the resulting array
 * will appear in any specific order; they are not, in particular,
 * guaranteed to appear in alphabetical order.
 *
 * @return An array of abstract pathnames denoting the files and
 * directories in the directory denoted by this abstract
 * pathname. The array will be empty if the directory is
 * empty. Returns <code>null</code> if this abstract pathname
 * does not denote a directory, or if an I/O error occurs.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the directory
 *
 * @since 1.2
 */
 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;
 }

/**
 * Returns an array of abstract pathnames denoting the files and
 * directories in the directory denoted by this abstract pathname that
 * satisfy the specified filter. The behavior of this method is the
 * same as that of the <code>{@link #listFiles()}</code> method, except
 * that the pathnames in the returned array must satisfy the filter.
 * If the given <code>filter</code> is <code>null</code> then all
 * pathnames are accepted. Otherwise, a pathname satisfies the filter
 * if and only if the value <code>true</code> results when the
 * <code>{@link FilenameFilter#accept}</code> method of the filter is
 * invoked on this abstract pathname and the name of a file or
 * directory in the directory that it denotes.
 *
 * @param filter A filename filter
 *
 * @return An array of abstract pathnames denoting the files and
 * directories in the directory denoted by this abstract
 * pathname. The array will be empty if the directory is
 * empty. Returns <code>null</code> if this abstract pathname
 * does not denote a directory, or if an I/O error occurs.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the directory
 *
 * @since 1.2
 */
 public File[] listFiles(FilenameFilter filter) {
String ss[] = list();
if (ss == null) return null;
ArrayList v = new ArrayList();
for (int i = 0 ; i < ss.length ; i++) {
 if ((filter == null) || filter.accept(this, ss[i])) {
 v.add(new File(ss[i], this));
 }
}
return (File[])(v.toArray(new File[v.size()]));
 }

/**
 * Returns an array of abstract pathnames denoting the files and
 * directories in the directory denoted by this abstract pathname that
 * satisfy the specified filter. The behavior of this method is the
 * same as that of the <code>{@link #listFiles()}</code> method, except
 * that the pathnames in the returned array must satisfy the filter.
 * If the given <code>filter</code> is <code>null</code> then all
 * pathnames are accepted. Otherwise, a pathname satisfies the filter
 * if and only if the value <code>true</code> results when the
 * <code>{@link FileFilter#accept(java.io.File)}</code> method of
 * the filter is invoked on the pathname.
 *
 * @param filter A file filter
 *
 * @return An array of abstract pathnames denoting the files and
 * directories in the directory denoted by this abstract
 * pathname. The array will be empty if the directory is
 * empty. Returns <code>null</code> if this abstract pathname
 * does not denote a directory, or if an I/O error occurs.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method denies read access to the directory
 *
 * @since 1.2
 */
 public File[] listFiles(FileFilter filter) {
String ss[] = list();
if (ss == null) return null;
ArrayList v = new ArrayList();
for (int i = 0 ; i < ss.length ; i++) {
 File f = new File(ss[i], this);
 if ((filter == null) || filter.accept(f)) {
 v.add(f);
 }
}
return (File[])(v.toArray(new File[v.size()]));
 }

/**
 * Creates the directory named by this abstract pathname.
 *
 * @return <code>true</code> if and only if the directory was
 * created; <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method does not permit the named directory to be created
 */
 public boolean mkdir() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.createDirectory(this);
 }

/**
 * Creates the directory named by this abstract pathname, including any
 * necessary but nonexistent parent directories. Note that if this
 * operation fails it may have succeeded in creating some of the necessary
 * parent directories.
 *
 * @return <code>true</code> if and only if the directory was created,
 * along with all necessary parent directories; <code>false</code>
 * otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code>
 * method does not permit verification of the existence of the
 * named directory and all necessary parent directories; or if
 * the <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method does not permit the named directory and all necessary
 * parent directories to be created
 */
 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());
}

/**
 * Renames the file denoted by this abstract pathname.
 *
 * Many aspects of the behavior of this method are inherently
 * platform-dependent: The rename operation might not be able to move a
 * file from one filesystem to another, it might not be atomic, and it
 * might not succeed if a file with the destination abstract pathname
 * already exists. The return value should always be checked to make sure
 * that the rename operation was successful.
 *
 * @param dest The new abstract pathname for the named file
 *
 * @return <code>true</code> if and only if the renaming succeeded;
 * <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to either the old or new pathnames
 *
 * @throws NullPointerException
 * If parameter <code>dest</code> is <code>null</code>
 */
 public boolean renameTo(File dest) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
 security.checkWrite(dest.path);
}
return fs.rename(this, dest);
 }

/**
 * Sets the last-modified time of the file or directory named by this
 * abstract pathname.
 *
 * All platforms support file-modification times to the nearest second,
 * but some provide more precision. The argument will be truncated to fit
 * the supported precision. If the operation succeeds and no intervening
 * operations on the file take place, then the next invocation of the
 * <code>{@link #lastModified}</code> method will return the (possibly
 * truncated) <code>time</code> argument that was passed to this method.
 *
 * @param time The new last-modified time, measured in milliseconds since
 * the epoch (00:00:00 GMT, January 1, 1970)
 *
 * @return <code>true</code> if and only if the operation succeeded;
 * <code>false</code> otherwise
 *
 * @throws IllegalArgumentException If the argument is negative
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the named file
 *
 * @since 1.2
 */
 public boolean setLastModified(long time) {
if (time < 0) throw new IllegalArgumentException("Negative time");
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.setLastModifiedTime(this, time);
 }

/**
 * Marks the file or directory named by this abstract pathname so that
 * only read operations are allowed. After invoking this method the file
 * or directory is guaranteed not to change until it is either deleted or
 * marked to allow write access. Whether or not a read-only file or
 * directory may be deleted depends upon the underlying system.
 *
 * @return <code>true</code> if and only if the operation succeeded;
 * <code>false</code> otherwise
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the named file
 *
 * @since 1.2
 */
 public boolean setReadOnly() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.setReadOnly(this);
 }

/**
 * Sets the owner's or everybody's write permission for this abstract
 * pathname.
 *
 * @param writable
 * If <code>true</code>, sets the access permission to allow write
 * operations; if <code>false</code> to disallow write operations
 *
 * @param ownerOnly
 * If <code>true</code>, the write permission applies only to the
 * owner's write permission; otherwise, it applies to everybody. If
 * the underlying file system can not distinguish the owner's write
 * permission from that of others, then the permission will apply to
 * everybody, regardless of this value.
 *
 * @return <code>true</code> if and only if the operation succeeded. The
 * operation will fail if the user does not have permission to change
 * the access permissions of this abstract pathname.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the named file
 *
 * @since 1.6
 */
 public boolean setWritable(boolean writable, boolean ownerOnly) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.setPermission(this, FileSystem.ACCESS_WRITE, writable, ownerOnly);
 }

/**
 * A convenience method to set the owner's write permission for this abstract
 * pathname.
 *
 * An invocation of this method of the form <tt>file.setWritable(arg)</tt>
 * behaves in exactly the same way as the invocation
 *
 * <pre>
 * file.setWritable(arg, true) </pre>
 *
 * @param writable
 * If <code>true</code>, sets the access permission to allow write
 * operations; if <code>false</code> to disallow write operations
 *
 * @return <code>true</code> if and only if the operation succeeded. The
 * operation will fail if the user does not have permission to
 * change the access permissions of this abstract pathname.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setWritable(boolean writable) {
return setWritable(writable, true);
 }

/**
 * Sets the owner's or everybody's read permission for this abstract
 * pathname.
 *
 * @param readable
 * If <code>true</code>, sets the access permission to allow read
 * operations; if <code>false</code> to disallow read operations
 *
 * @param ownerOnly
 * If <code>true</code>, the read permission applies only to the
 * owner's read permission; otherwise, it applies to everybody. If
 * the underlying file system can not distinguish the owner's read
 * permission from that of others, then the permission will apply to
 * everybody, regardless of this value.
 *
 * @return <code>true</code> if and only if the operation succeeded. The
 * operation will fail if the user does not have permission to
 * change the access permissions of this abstract pathname. If
 * <code>readable</code> is <code>false</code> and the underlying
 * file system does not implement a read permission, then the
 * operation will fail.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setReadable(boolean readable, boolean ownerOnly) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.setPermission(this, FileSystem.ACCESS_READ, readable, ownerOnly);
 }

/**
 * A convenience method to set the owner's read permission for this abstract
 * pathname.
 *
 * An invocation of this method of the form <tt>file.setReadable(arg)</tt>
 * behaves in exactly the same way as the invocation
 *
 * <pre>
 * file.setReadable(arg, true) </pre>
 *
 * @param readable
 * If <code>true</code>, sets the access permission to allow read
 * operations; if <code>false</code> to disallow read operations
 *
 * @return <code>true</code> if and only if the operation succeeded. The
 * operation will fail if the user does not have permission to
 * change the access permissions of this abstract pathname. If
 * <code>readable</code> is <code>false</code> and the underlying
 * file system does not implement a read permission, then the
 * operation will fail.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setReadable(boolean readable) {
 return setReadable(readable, true);
 }

/**
 * Sets the owner's or everybody's execute permission for this abstract
 * pathname.
 *
 * @param executable
 * If <code>true</code>, sets the access permission to allow execute
 * operations; if <code>false</code> to disallow execute operations
 *
 * @param ownerOnly
 * If <code>true</code>, the execute permission applies only to the
 * owner's execute permission; otherwise, it applies to everybody.
 * If the underlying file system can not distinguish the owner's
 * execute permission from that of others, then the permission will
 * apply to everybody, regardless of this value.
 *
 * @return <code>true</code> if and only if the operation succeeded. The
 * operation will fail if the user does not have permission to
 * change the access permissions of this abstract pathname. If
 * <code>executable</code> is <code>false</code> and the underlying
 * file system does not implement an execute permission, then the
 * operation will fail.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setExecutable(boolean executable, boolean ownerOnly) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkWrite(path);
}
return fs.setPermission(this, FileSystem.ACCESS_EXECUTE, executable, ownerOnly);
 }

/**
 * A convenience method to set the owner's execute permission for this abstract
 * pathname.
 *
 * An invocation of this method of the form <tt>file.setExcutable(arg)</tt>
 * behaves in exactly the same way as the invocation
 *
 * <pre>
 * file.setExecutable(arg, true) </pre>
 *
 * @param executable
 * If <code>true</code>, sets the access permission to allow execute
 * operations; if <code>false</code> to disallow execute operations
 *
 * @return <code>true</code> if and only if the operation succeeded. The
 * operation will fail if the user does not have permission to
 * change the access permissions of this abstract pathname. If
 * <code>executable</code> is <code>false</code> and the underlying
 * file system does not implement an excute permission, then the
 * operation will fail.
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setExecutable(boolean executable) {
 return setExecutable(executable, true);
 }

/**
 * Tests whether the application can execute the file denoted by this
 * abstract pathname.
 *
 * @return <code>true</code> if and only if the abstract pathname exists
 * and the application is allowed to execute the file
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkExec(java.lang.String)}</code>
 * method denies execute access to the file
 *
 * @since 1.6
 */
 public boolean canExecute() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
 security.checkExec(path);
}
return fs.checkAccess(this, FileSystem.ACCESS_EXECUTE);
 }

/* -- Filesystem interface -- */

/**
 * List the available filesystem roots.
 *
 * A particular Java platform may support zero or more
 * hierarchically-organized file systems. Each file system has a
 * <code>root</code> directory from which all other files in that file
 * system can be reached. Windows platforms, for example, have a root
 * directory for each active drive; UNIX platforms have a single root
 * directory, namely <code>"/"</code>. The set of available filesystem
 * roots is affected by various system-level operations such as the insertion
 * or ejection of removable media and the disconnecting or unmounting of
 * physical or virtual disk drives.
 *
 * This method returns an array of <code>File</code> objects that
 * denote the root directories of the available filesystem roots. It is
 * guaranteed that the canonical pathname of any file physically present on
 * the local machine will begin with one of the roots returned by this
 * method.
 *
 * The canonical pathname of a file that resides on some other machine
 * and is accessed via a remote-filesystem protocol such as SMB or NFS may
 * or may not begin with one of the roots returned by this method. If the
 * pathname of a remote file is syntactically indistinguishable from the
 * pathname of a local file then it will begin with one of the roots
 * returned by this method. Thus, for example, <code>File</code> objects
 * denoting the root directories of the mapped network drives of a Windows
 * platform will be returned by this method, while <code>File</code>
 * objects containing UNC pathnames will not be returned by this method.
 *
 * Unlike most methods in this class, this method does not throw
 * security exceptions. If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkRead(java.lang.String)}</code> method
 * denies read access to a particular root directory, then that directory
 * will not appear in the result.
 *
 * @return An array of <code>File</code> objects denoting the available
 * filesystem roots, or <code>null</code> if the set of roots
 * could not be determined. The array will be empty if there are
 * no filesystem roots.
 *
 * @since 1.2
 */
 public static File[] listRoots() {
return fs.listRoots();
 }

/* -- Disk usage -- */

 /**
 * Returns the size of the partition <a href="#partName">named</a> by this
 * abstract pathname.
 *
 * @return The size, in bytes, of the partition or <tt>0L</tt> if this
 * abstract pathname does not name a partition
 *
 * @throws SecurityException
 * If a security manager has been installed and it denies
 * {@link RuntimePermission}<tt>("getFileSystemAttributes")</tt>
 * or its {@link SecurityManager#checkRead(String)} method denies
 * read access to the file named by this abstract pathname
 *
 * @since 1.6
 */
 public long getTotalSpace() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
 sm.checkPermission(new RuntimePermission("getFileSystemAttributes"));
 sm.checkRead(path);
}
return fs.getSpace(this, FileSystem.SPACE_TOTAL);
 }

/**
 * Returns the number of unallocated bytes in the partition <a
 * href="#partName">named</a> by this abstract path name.
 *
 * The returned number of unallocated bytes is a hint, but not
 * a guarantee, that it is possible to use most or any of these
 * bytes. The number of unallocated bytes is most likely to be
 * accurate immediately after this call. It is likely to be made
 * inaccurate by any external I/O operations including those made
 * on the system outside of this virtual machine. This method
 * makes no guarantee that write operations to this file system
 * will succeed.
 *
 * @return The number of unallocated bytes on the partition <tt>0L</tt>
 * if the abstract pathname does not name a partition. This
 * value will be less than or equal to the total file system size
 * returned by {@link #getTotalSpace}.
 *
 * @throws SecurityException
 * If a security manager has been installed and it denies
 * {@link RuntimePermission}<tt>("getFileSystemAttributes")</tt>
 * or its {@link SecurityManager#checkRead(String)} method denies
 * read access to the file named by this abstract pathname
 *
 * @since 1.6
 */
 public long getFreeSpace() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
 sm.checkPermission(new RuntimePermission("getFileSystemAttributes"));
 sm.checkRead(path);
}
return fs.getSpace(this, FileSystem.SPACE_FREE);
 }

 /**
 * Returns the number of bytes available to this virtual machine on the
 * partition <a href="#partName">named</a> by this abstract pathname. When
 * possible, this method checks for write permissions and other operating
 * system restrictions and will therefore usually provide a more accurate
 * estimate of how much new data can actually be written than {@link
 * #getFreeSpace}.
 *
 * The returned number of available bytes is a hint, but not a
 * guarantee, that it is possible to use most or any of these bytes. The
 * number of unallocated bytes is most likely to be accurate immediately
 * after this call. It is likely to be made inaccurate by any external
 * I/O operations including those made on the system outside of this
 * virtual machine. This method makes no guarantee that write operations
 * to this file system will succeed.
 *
 * @return The number of available bytes on the partition or <tt>0L</tt>
 * if the abstract pathname does not name a partition. On
 * systems where this information is not available, this method
 * will be equivalent to a call to {@link #getFreeSpace}.
 *
 * @throws SecurityException
 * If a security manager has been installed and it denies
 * {@link RuntimePermission}<tt>("getFileSystemAttributes")</tt>
 * or its {@link SecurityManager#checkRead(String)} method denies
 * read access to the file named by this abstract pathname
 *
 * @since 1.6
 */
 public long getUsableSpace() {
 SecurityManager sm = System.getSecurityManager();
if (sm != null) {
 sm.checkPermission(new RuntimePermission("getFileSystemAttributes"));
 sm.checkRead(path);
}
return fs.getSpace(this, FileSystem.SPACE_USABLE);
 }


 /* -- Temporary files -- */

    // lazy initialization of SecureRandom and temporary file directory
    private static class LazyInitialization {
        static final SecureRandom random = new SecureRandom();

        static final String temporaryDirectory = temporaryDirectory();
        static String temporaryDirectory() {
            return fs.normalize(
                AccessController.doPrivileged(
                    new GetPropertyAction("java.io.tmpdir")));
        }
    }

    private static File generateFile(String prefix, String suffix, File dir)
        throws IOException
    {
        long n = LazyInitialization.random.nextLong();
        if (n == Long.MIN_VALUE) {
            n = 0;      // corner case
        } else {
            n = Math.abs(n);
        }
        return new File(dir, prefix + Long.toString(n) + suffix);
    }

    private static boolean checkAndCreate(String filename, SecurityManager sm)
throws IOException
    {
if (sm != null) {
     try {
  sm.checkWrite(filename);
     } catch (AccessControlException x) {
  /* Throwing the original AccessControlException could disclose
     the location of the default temporary directory, so we
     re-throw a more innocuous SecurityException */
  throw new SecurityException("Unable to create temporary file");
     }
}
return fs.createFileExclusively(filename);
    }

/**
 * Creates a new empty file in the specified directory, using the
 * given prefix and suffix strings to generate its name. If this method
 * returns successfully then it is guaranteed that:
 *
 * <ol>
 * <li> The file denoted by the returned abstract pathname did not exist
 * before this method was invoked, and
 * <li> Neither this method nor any of its variants will return the same
 * abstract pathname again in the current invocation of the virtual
 * machine.
 * </ol>
 *
 * This method provides only part of a temporary-file facility. To arrange
 * for a file created by this method to be deleted automatically, use the
 * <code>{@link #deleteOnExit}</code> method.
 *
 * The <code>prefix</code> argument must be at least three characters
 * long. It is recommended that the prefix be a short, meaningful string
 * such as <code>"hjb"</code> or <code>"mail"</code>. The
 * <code>suffix</code> argument may be <code>null</code>, in which case the
 * suffix <code>".tmp"</code> will be used.
 *
 * To create the new file, the prefix and the suffix may first be
 * adjusted to fit the limitations of the underlying platform. If the
 * prefix is too long then it will be truncated, but its first three
 * characters will always be preserved. If the suffix is too long then it
 * too will be truncated, but if it begins with a period character
 * (<code>'.'</code>) then the period and the first three characters
 * following it will always be preserved. Once these adjustments have been
 * made the name of the new file will be generated by concatenating the
 * prefix, five or more internally-generated characters, and the suffix.
 *
 * If the <code>directory</code> argument is <code>null</code> then the
 * system-dependent default temporary-file directory will be used. The
 * default temporary-file directory is specified by the system property
 * <code>java.io.tmpdir</code>. On UNIX systems the default value of this
 * property is typically <code>"/tmp"</code> or <code>"/var/tmp"</code>; on
 * Microsoft Windows systems it is typically <code>"C:\\WINNT\\TEMP"</code>. A different
 * value may be given to this system property when the Java virtual machine
 * is invoked, but programmatic changes to this property are not guaranteed
 * to have any effect upon the temporary directory used by this method.
 *
 * @param prefix The prefix string to be used in generating the file's
 * name; must be at least three characters long
 *
 * @param suffix The suffix string to be used in generating the file's
 * name; may be <code>null</code>, in which case the
 * suffix <code>".tmp"</code> will be used
 *
 * @param directory The directory in which the file is to be created, or
 * <code>null</code> if the default temporary-file
 * directory is to be used
 *
 * @return An abstract pathname denoting a newly-created empty file
 *
 * @throws IllegalArgumentException
 * If the <code>prefix</code> argument contains fewer than three
 * characters
 *
 * @throws IOException If a file could not be created
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method does not allow a file to be created
 *
 * @since 1.2
 */
 public static File createTempFile(String prefix, String suffix,
 File directory)
 throws IOException
 {
if (prefix == null) throw new NullPointerException();
if (prefix.length() < 3)
 throw new IllegalArgumentException("Prefix string too short");
String s = (suffix == null) ? ".tmp" : suffix;
if (directory == null) {
 String tmpDir = LazyInitialization.temporaryDirectory();
 directory = new File(tmpDir, fs.prefixLength(tmpDir));
}
SecurityManager sm = System.getSecurityManager();
File f;
do {
 f = generateFile(prefix, s, directory);
} while (!checkAndCreate(f.getPath(), sm));
return f;
 }

/**
 * Creates an empty file in the default temporary-file directory, using
 * the given prefix and suffix to generate its name. Invoking this method
 * is equivalent to invoking <code>{@link #createTempFile(java.lang.String,
 * java.lang.String, java.io.File)
 * createTempFile(prefix, suffix, null)}</code>.
 *
 * @param prefix The prefix string to be used in generating the file's
 * name; must be at least three characters long
 *
 * @param suffix The suffix string to be used in generating the file's
 * name; may be <code>null</code>, in which case the
 * suffix <code>".tmp"</code> will be used
 *
 * @return An abstract pathname denoting a newly-created empty file
 *
 * @throws IllegalArgumentException
 * If the <code>prefix</code> argument contains fewer than three
 * characters
 *
 * @throws IOException If a file could not be created
 *
 * @throws SecurityException
 * If a security manager exists and its <code>{@link
 * java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
 * method does not allow a file to be created
 *
 * @since 1.2
 */
 public static File createTempFile(String prefix, String suffix)
throws IOException
 {
return createTempFile(prefix, suffix, null);
 }

/* -- Basic infrastructure -- */

    /**
     * Compares two abstract pathnames lexicographically. The ordering
     * defined by this method depends upon the underlying system. On UNIX
     * systems, alphabetic case is significant in comparing pathnames; on Microsoft Windows
     * systems it is not.
     *
     * @param   pathname The abstract pathname to be compared to this abstract
     *                    pathname
     *
     * @return Zero if the argument is equal to this abstract pathname, a
     *  value less than zero if this abstract pathname is
     *  lexicographically less than the argument, or a value greater
     *  than zero if this abstract pathname is lexicographically
     *  greater than the argument
     *
     * @since   1.2
     */
    public int compareTo(File pathname) {
return fs.compare(this, pathname);
    }

/**
 * Tests this abstract pathname for equality with the given object.
 * Returns <code>true</code> if and only if the argument is not
 * <code>null</code> and is an abstract pathname that denotes the same file
 * or directory as this abstract pathname. Whether or not two abstract
 * pathnames are equal depends upon the underlying system. On UNIX
 * systems, alphabetic case is significant in comparing pathnames; on Microsoft Windows
 * systems it is not.
 *
 * @param obj The object to be compared with this abstract pathname
 *
 * @return <code>true</code> if and only if the objects are the same;
 * <code>false</code> otherwise
 */
 public boolean equals(Object obj) {
if ((obj != null) && (obj instanceof File)) {
 return compareTo((File)obj) == 0;
}
return false;
 }

/**
 * Computes a hash code for this abstract pathname. Because equality of
 * abstract pathnames is inherently system-dependent, so is the computation
 * of their hash codes. On UNIX systems, the hash code of an abstract
 * pathname is equal to the exclusive or of the hash code
 * of its pathname string and the decimal value
 * <code>1234321</code>. On Microsoft Windows systems, the hash
 * code is equal to the exclusive or of the hash code of
 * its pathname string converted to lower case and the decimal
 * value <code>1234321</code>. Locale is not taken into account on
 * lowercasing the pathname string.
 *
 * @return A hash code for this abstract pathname
 */
 public int hashCode() {
return fs.hashCode(this);
 }

/**
 * Returns the pathname string of this abstract pathname. This is just the
 * string returned by the <code>{@link #getPath}</code> method.
 *
 * @return The string form of this abstract pathname
 */
 public String toString() {
return getPath();
 }

/**
 * WriteObject is called to save this filename.
 * The separator character is saved also so it can be replaced
 * in case the path is reconstituted on a different host type.
 * 
 * @serialData Default fields followed by separator character.
 */
 private synchronized void writeObject(java.io.ObjectOutputStream s)
 throws IOException
 {
s.defaultWriteObject();
s.writeChar(this.separatorChar); // Add the separator character
 }

    /**
     * readObject is called to restore this filename.
     * The original separator character is read. If it is different
     * than the separator character on this system, then the old separator
     * is replaced by the local separator.
     */
    private synchronized void readObject(java.io.ObjectInputStream s)
         throws IOException, ClassNotFoundException
    {
        ObjectInputStream.GetField fields = s.readFields();
        String pathField = (String)fields.get("path", null);
char sep = s.readChar(); // read the previous separator char
if (sep != separatorChar)
            pathField = pathField.replace(sep, separatorChar);
this.path = fs.normalize(pathField);
this.prefixLength = fs.prefixLength(this.path);
    }

/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = 301077366599181567L;
}

你可能感兴趣的:(JDK源码学习（二）-------------java.io(附录java.io.file源码))

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
爬山后遗症璃绛
爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
《策划经理回忆录之二》路基雅虎
话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
本周第二次约练 2cfbdfe28a51
中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
2022-07-08 保利学府里李楚怡1307022
——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
直抒《紫罗兰永恒花园外传》雷姆的黑色童话
没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
如果做到轻松在股市赚钱？只要坚持这三个原则。履霜之人
大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
特殊的拜年飘雪的天堂
文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
398顺境，逆境戴骁勇
2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
想明白这个问题，你才能写下去文自拾
春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
其二十八尾喵
你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
libyuv之linux编译 jaronho Linux linux 运维服务器
文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
webpack图片等资源的处理 dmengmeng
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
ARM中断处理过程落汤老狗嵌入式linux
一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
如何成为段子手欣雅阅读
我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
主题升华随机抽总结木棉咕噜
昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
Java实现的简单双向Map，支持重复Value superlxw1234 java 双向map
关键字：Java双向Map、DualHashBidiMap 有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。即：既要根据Key找Value，又要根据Value
PL/SQL触发器基础及例子百合不是茶 oracle数据库触发器 PL/SQL编程
触发器的简介; 触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似过程函数必须要调用, 一个表中最多只能有12个触发器类型的,触发器和过程函数相似触发器不需要调用直接执行, 触发时间：指明触发器何时执行，该值可取： before：表示在数据库动作之前触发
[时空与探索]穿越时空的一些问题 comsci 问题
我们还没有进行过任何数学形式上的证明,仅仅是一个猜想..... 这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
easy ui datagrid上移下移一行商人shang js 上移下移 easyui datagrid
/** * 向上移动一行 * * @param dg * @param row */ function moveupRow(dg, row) { var datagrid = $(dg); var index = datagrid.datagrid("getRowIndex", row); if (isFirstRow(dg, row)) {
Java反射 oloz 反射
本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教首先看看java中的Class package demo; public class ClassTest { /*先了解java中的Class*/ public static void main(String[] args) { //任何一个类都
springMVC 使用JSR-303 Validation验证杨白白 spring mvc
JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。登录需要验证类 public class Login { @NotEmpty
log4j 香水浓 log4j
log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE #log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML #console log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender log4
使用ajax和history.pushState无刷新改变页面URL agevs jquery 框架 Ajax html5 chrome
表现如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。是什么有这么强大的功能呢？ HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
centos中文乱码 AILIKES centos OS ssh
一、CentOS系统访问 g.cn ，发现中文乱码。于是用以前的方式：yum -y install fonts-chinese CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。后来，终于找到以下方法可以解决，需要两个中文支持的包： fonts-chinese-3.02-12.
触发器 baalwolf 触发器
触发器(trigger)：监视某种情况，并触发某种操作。触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 语法： create trigger triggerName after/before
JS正则表达式的i m g bijian1013 JavaScript 正则表达式
g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。 i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。 m:表示
HTML5模式和Hashbang模式 bijian1013 JavaScript AngularJS Hashbang模式 HTML5模式
我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 html5Mode 一个布尔值，标识$location服务是否运行在HTML5模式下。 ha
[Maven学习笔记六]Maven生命周期 bit1129 maven
从mvn test的输出开始说起当我们在user-core中执行mvn test时，执行的输出如下： /software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
【Hadoop七】基于Yarn的Hadoop Map Reduce容错 bit1129 hadoop
运行于Yarn的Map Reduce作业，可能发生失败的点包括 Task Failure Application Master Failure Node Manager Failure Resource Manager Failure 1. Task Failure 任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
记一次数据推送的异常解决端口解决 ronin47 记一次数据推送的异常解决
　　需求：从db获取数据然后推送到B 程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。　　自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。　　　service iptables stop
巧用视错觉-UI更有趣 brotherlamp UI ui视频 ui教程 ui自学 ui资料
我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
线段树-poj1177-N个矩形求边长（离散化+扫描线） bylijinnan 数据结构算法线段树
package com.ljn.base; import java.util.Arrays; import java.util.Comparator; import java.util.Set; import java.util.TreeSet; /** * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177
HTTP协议详解 chicony http协议
引言
Scala设计模式 chenchao051 设计模式 scala
Scala设计模式我的话：在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
安装mysql daizj mysql 安装
安装mysql (1)删除linux上已经安装的mysql相关库信息。rpm -e xxxxxxx --nodeps (强制删除) 执行命令rpm -qa |grep mysql 检查是否删除干净 (2)执行命令 rpm -i MySQL-server-5.5.31-2.el
HTTP状态码大全 dcj3sjt126com http状态码
完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
asihttprequest上传图片 dcj3sjt126com ASIHTTPRequest
NSURL *url =@"yourURL"; ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url]; [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
C语言中，关键字static的作用 e200702084 C++c C#
在C语言中，关键字static有三个明显的作用： 1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
win7/8使用curl geeksun win7
1. WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。下载地址： http://curl.haxx.se/download.html 请选择不带SSL的版本，否则还需要安装SSL的支持包 2. 可以给Windows增加c
Creating a Shared Repository; Users Sharing The Repository hongtoushizi git
转载自： http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/ Commands discussed in this section: git init –bare git clone git remote git pull git p
Java实现字符串反转的8种或9种方法 Josh_Persistence 异或反转递归反转二分交换反转 java字符串反转栈反转
注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： http://josh-persistence.iteye.com/blog/2205768 /** * */ package com.wsheng.aggregator.algorithm.string; import java.util.Stack; /**
代码实现任意容量倒水问题 home198979 PHP 算法倒水
形象化设计模式实战 HELLO!架构 redis命令源码解析倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
Druid datasource zhb8015 druid
推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。它最重要的特点是：监控、扩展和性能。下载和Maven配置看这里： http
两种启动监听器ApplicationListener和ServletContextListener spjich java spring 框架
引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器 ServletContextListener 特点: 依赖于sevlet容器，需要配置web.xml 使用方法: public class StartListener implements
JavaScript Rounding Methods of the Math object 何不笑 JavaScript Math
The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(), Math.floor(), and Math.round() — handle rounding in differen