File类

最新推荐文章于 2022-11-27 16:41:40 发布
最新推荐文章于 2022-11-27 16:41:40 发布
阅读量175 收藏
点赞数
分类专栏： java IO 文章标签： java File IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flybone7/article/details/104048220
版权
java 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
IO
1 篇文章 0 订阅
订阅专栏

File类是java.io包下代表与平台无关的文件和目录，也就是说，如果希望在程序中操作文件和目录，都可以通过File类来完成。

值得指出的是，不管是文件还是目录都是通过File类来操作的，File能够新建、删除、重命名文件和目录。

但是File类本身不能访问文件内容，如果需要访问文件内容需要使用输入输出流。

getPath
public String getPath()将此抽象路径名转换为一个路径名字符串。所得到的字符串使用默认名称分隔符来分隔名称序列中的名称。 
返回：
此抽象路径名的字符串形式
getAbsolutePath
public String getAbsolutePath()返回抽象路径名的绝对路径名字符串。 
如果此抽象路径名已经是绝对路径名，则返回该路径名字符串，这与 getPath() 方法一样。如果此抽象路径名是空的抽象路径名，则返回当前用户目录的路径名字符串，该目录由系统属性 user.dir 指定。否则，使用与系统有关的方式分析此路径名。在 UNIX 系统上，通过根据当前用户目录分析某一相对路径名，可使该路径名成为绝对路径名。在 Microsoft Windows 系统上，通过由路径名指定的当前驱动器目录（如果有）来分析某一相对路径名，可使该路径名成为绝对路径名；否则，可以根据当前用户目录来分析它。 
返回：
绝对路径名字符串，它与此抽象路径名表示相同的文件或目录的 
抛出： 
SecurityException - 如果无法访问所需的系统属性值。
另请参见：
isAbsolute()

 

 

什么叫当前驱动器，还有就是某个驱动器的当前路径?

默认正在操作的硬盘或其他存储设备分区叫当前驱动器。比如你打开了D盘的文件夹，D盘就是当前驱动器。文件在硬盘（U盘、光盘……）等的具体位置，是用一层层名称表示，从驱动器开始，如D盘下有文件夹ABC，ABC里面有A1、B1等文件夹，则D:\ABC\A1和D:\ABC\B1分别表示指向这两个文件夹的路径。就像找人说“山东\青岛\市南区\香港中路\15号\1单元\201\张三”一样，所以又被称为地址。
查看方式是：在打开窗口（资源管理器）的地址栏单击空白位置，可以显示当前路径。
此外，在CMD命令窗口中提示符默认显示当前路径。

package java.io;

import java.security.AccessController;
import java.util.Locale;
import sun.security.action.GetPropertyAction;

class Win32FileSystem
  extends FileSystem
{
  private final char slash;
  private final char altSlash;
  private final char semicolon;
  private static String[] driveDirCache;
  
  public Win32FileSystem()
  {
    this.slash = ((String)AccessController.doPrivileged(new GetPropertyAction("file.separator"))).charAt(0);
    
    this.semicolon = ((String)AccessController.doPrivileged(new GetPropertyAction("path.separator"))).charAt(0);
    
    this.altSlash = (this.slash == '\\' ? '/' : '\\');
  }
  
  private boolean isSlash(char paramChar)
  {
    return (paramChar == '\\') || (paramChar == '/');
  }
  
  private boolean isLetter(char paramChar)
  {
    return ((paramChar >= 'a') && (paramChar <= 'z')) || ((paramChar >= 'A') && (paramChar <= 'Z'));
  }
  
  private String slashify(String paramString)
  {
    if ((paramString.length() > 0) && (paramString.charAt(0) != this.slash)) {
      return this.slash + paramString;
    }
    return paramString;
  }
  
  public char getSeparator()
  {
    return this.slash;
  }
  
  public char getPathSeparator()
  {
    return this.semicolon;
  }
  
  private int normalizePrefix(String paramString, int paramInt, StringBuffer paramStringBuffer)
  {
    int i = 0;
    while ((i < paramInt) && (isSlash(paramString.charAt(i)))) {
      i++;
    }
    char c;
    if ((paramInt - i >= 2) && (isLetter(c = paramString.charAt(i))) && (paramString.charAt(i + 1) == ':'))
    {
      paramStringBuffer.append(c);
      paramStringBuffer.append(':');
      i += 2;
    }
    else
    {
      i = 0;
      if ((paramInt >= 2) && (isSlash(paramString.charAt(0))) && (isSlash(paramString.charAt(1))))
      {
        i = 1;
        paramStringBuffer.append(this.slash);
      }
    }
    return i;
  }
  
  private String normalize(String paramString, int paramInt1, int paramInt2)
  {
    if (paramInt1 == 0) {
      return paramString;
    }
    if (paramInt2 < 3) {
      paramInt2 = 0;
    }
    char c1 = this.slash;
    StringBuffer localStringBuffer = new StringBuffer(paramInt1);
    int i;
    if (paramInt2 == 0)
    {
      i = normalizePrefix(paramString, paramInt1, localStringBuffer);
    }
    else
    {
      i = paramInt2;
      localStringBuffer.append(paramString.substring(0, paramInt2));
    }
    while (i < paramInt1)
    {
      char c2 = paramString.charAt(i++);
      if (isSlash(c2))
      {
        while ((i < paramInt1) && (isSlash(paramString.charAt(i)))) {
          i++;
        }
        if (i == paramInt1)
        {
          int j = localStringBuffer.length();
          if ((j == 2) && (localStringBuffer.charAt(1) == ':'))
          {
            localStringBuffer.append(c1);
            break;
          }
          if (j == 0)
          {
            localStringBuffer.append(c1);
            break;
          }
          if ((j != 1) || (!isSlash(localStringBuffer.charAt(0)))) {
            break;
          }
          localStringBuffer.append(c1);
          break;
        }
        localStringBuffer.append(c1);
      }
      else
      {
        localStringBuffer.append(c2);
      }
    }
    String str = localStringBuffer.toString();
    return str;
  }
  
  public String normalize(String paramString)
  {
    int i = paramString.length();
    int j = this.slash;
    int k = this.altSlash;
    int m = 0;
    for (int n = 0; n < i; n++)
    {
      int i1 = paramString.charAt(n);
      if (i1 == k) {
        return normalize(paramString, i, m == j ? n - 1 : n);
      }
      if ((i1 == j) && (m == j) && (n > 1)) {
        return normalize(paramString, i, n - 1);
      }
      if ((i1 == 58) && (n > 1)) {
        return normalize(paramString, i, 0);
      }
      m = i1;
    }
    if (m == j) {
      return normalize(paramString, i, i - 1);
    }
    return paramString;
  }
  
  public int prefixLength(String paramString)
  {
    int i = this.slash;
    int j = paramString.length();
    if (j == 0) {
      return 0;
    }
    char c = paramString.charAt(0);
    int k = j > 1 ? paramString.charAt(1) : 0;
    if (c == i)
    {
      if (k == i) {
        return 2;
      }
      return 1;
    }
    if ((isLetter(c)) && (k == 58))
    {
      if ((j > 2) && (paramString.charAt(2) == i)) {
        return 3;
      }
      return 2;
    }
    return 0;
  }
  
  public String resolve(String paramString1, String paramString2)
  {
    int i = paramString1.length();
    if (i == 0) {
      return paramString2;
    }
    int j = paramString2.length();
    if (j == 0) {
      return paramString1;
    }
    String str = paramString2;
    int k = 0;
    int m = i;
    if ((j > 1) && (str.charAt(0) == this.slash))
    {
      if (str.charAt(1) == this.slash) {
        k = 2;
      } else {
        k = 1;
      }
      if (j == k)
      {
        if (paramString1.charAt(i - 1) == this.slash) {
          return paramString1.substring(0, i - 1);
        }
        return paramString1;
      }
    }
    if (paramString1.charAt(i - 1) == this.slash) {
      m--;
    }
    int n = m + j - k;
    char[] arrayOfChar = null;
    if (paramString2.charAt(k) == this.slash)
    {
      arrayOfChar = new char[n];
      paramString1.getChars(0, m, arrayOfChar, 0);
      paramString2.getChars(k, j, arrayOfChar, m);
    }
    else
    {
      arrayOfChar = new char[n + 1];
      paramString1.getChars(0, m, arrayOfChar, 0);
      arrayOfChar[m] = this.slash;
      paramString2.getChars(k, j, arrayOfChar, m + 1);
    }
    return new String(arrayOfChar);
  }
  
  public String getDefaultParent()
  {
    return "" + this.slash;
  }
  
  public String fromURIPath(String paramString)
  {
    String str = paramString;
    if ((str.length() > 2) && (str.charAt(2) == ':'))
    {
      str = str.substring(1);
      if ((str.length() > 3) && (str.endsWith("/"))) {
        str = str.substring(0, str.length() - 1);
      }
    }
    else if ((str.length() > 1) && (str.endsWith("/")))
    {
      str = str.substring(0, str.length() - 1);
    }
    return str;
  }
  
  public boolean isAbsolute(File paramFile)
  {
    int i = paramFile.getPrefixLength();
    return ((i == 2) && (paramFile.getPath().charAt(0) == this.slash)) || (i == 3);
  }
  
  protected native String getDriveDirectory(int paramInt);
  
  private static int driveIndex(char paramChar)
  {
    if ((paramChar >= 'a') && (paramChar <= 'z')) {
      return paramChar - 'a';
    }
    if ((paramChar >= 'A') && (paramChar <= 'Z')) {
      return paramChar - 'A';
    }
    return -1;
  }
  
  private String getDriveDirectory(char paramChar)
  {
    int i = driveIndex(paramChar);
    if (i < 0) {
      return null;
    }
    String str = driveDirCache[i];
    if (str != null) {
      return str;
    }
    str = getDriveDirectory(i + 1);
    driveDirCache[i] = str;
    return str;
  }
  
  private String getUserPath()
  {
    return normalize(System.getProperty("user.dir"));
  }
  
  private String getDrive(String paramString)
  {
    int i = prefixLength(paramString);
    return i == 3 ? paramString.substring(0, 2) : null;
  }
  
  public String resolve(File paramFile)
  {
    String str1 = paramFile.getPath();
    int i = paramFile.getPrefixLength();
    if ((i == 2) && (str1.charAt(0) == this.slash)) {
      return str1;
    }
    if (i == 3) {
      return str1;
    }
    if (i == 0) {
      return getUserPath() + slashify(str1);
    }
    String str2;
    String str3;
    if (i == 1)
    {
      str2 = getUserPath();
      str3 = getDrive(str2);
      if (str3 != null) {
        return str3 + str1;
      }
      return str2 + str1;
    }
    if (i == 2)
    {
      str2 = getUserPath();
      str3 = getDrive(str2);
      if ((str3 != null) && (str1.startsWith(str3))) {
        return str2 + slashify(str1.substring(2));
      }
      char c = str1.charAt(0);
      String str4 = getDriveDirectory(c);
      if (str4 != null)
      {
        String str5 = c + ':' + str4 + slashify(str1.substring(2));
        SecurityManager localSecurityManager = System.getSecurityManager();
        try
        {
          if (localSecurityManager != null) {
            localSecurityManager.checkRead(str5);
          }
        }
        catch (SecurityException localSecurityException)
        {
          throw new SecurityException("Cannot resolve path " + str1);
        }
        return str5;
      }
      return c + ":" + slashify(str1.substring(2));
    }
    throw new InternalError("Unresolvable path: " + str1);
  }
  
  private ExpiringCache cache = new ExpiringCache();
  private ExpiringCache prefixCache = new ExpiringCache();
  
  public String canonicalize(String paramString)
    throws IOException
  {
    int i = paramString.length();
    int j;
    if ((i == 2) && (isLetter(paramString.charAt(0))) && (paramString.charAt(1) == ':'))
    {
      j = paramString.charAt(0);
      if ((j >= 65) && (j <= 90)) {
        return paramString;
      }
      return "" + (char)(j - 32) + ':';
    }
    if ((i == 3) && (isLetter(paramString.charAt(0))) && (paramString.charAt(1) == ':') && (paramString.charAt(2) == '\\'))
    {
      j = paramString.charAt(0);
      if ((j >= 65) && (j <= 90)) {
        return paramString;
      }
      return "" + (char)(j - 32) + ':' + '\\';
    }
    if (!useCanonCaches) {
      return canonicalize0(paramString);
    }
    String str1 = this.cache.get(paramString);
    if (str1 == null)
    {
      String str2 = null;
      String str3 = null;
      Object localObject;
      if (useCanonPrefixCache)
      {
        str2 = parentOrNull(paramString);
        if (str2 != null)
        {
          str3 = this.prefixCache.get(str2);
          if (str3 != null)
          {
            localObject = paramString.substring(1 + str2.length());
            str1 = canonicalizeWithPrefix(str3, (String)localObject);
            this.cache.put(str2 + File.separatorChar + (String)localObject, str1);
          }
        }
      }
      if (str1 == null)
      {
        str1 = canonicalize0(paramString);
        this.cache.put(paramString, str1);
        if ((useCanonPrefixCache) && (str2 != null))
        {
          str3 = parentOrNull(str1);
          if (str3 != null)
          {
            localObject = new File(str1);
            if ((((File)localObject).exists()) && (!((File)localObject).isDirectory())) {
              this.prefixCache.put(str2, str3);
            }
          }
        }
      }
    }
    assert (canonicalize0(paramString).equalsIgnoreCase(str1));
    return str1;
  }
  
  protected native String canonicalize0(String paramString)
    throws IOException;
  
  protected String canonicalizeWithPrefix(String paramString1, String paramString2)
    throws IOException
  {
    return canonicalizeWithPrefix0(paramString1, paramString1 + File.separatorChar + paramString2);
  }
  
  protected native String canonicalizeWithPrefix0(String paramString1, String paramString2)
    throws IOException;
  
  static String parentOrNull(String paramString)
  {
    if (paramString == null) {
      return null;
    }
    int i = File.separatorChar;
    int j = 47;
    int k = paramString.length() - 1;
    int m = k;
    int n = 0;
    int i1 = 0;
    while (m > 0)
    {
      int i2 = paramString.charAt(m);
      if (i2 == 46)
      {
        n++;
        if (n >= 2) {
          return null;
        }
        if (i1 == 0) {
          return null;
        }
      }
      else
      {
        if (i2 == i)
        {
          if ((n == 1) && (i1 == 0)) {
            return null;
          }
          if ((m == 0) || (m >= k - 1) || (paramString.charAt(m - 1) == i) || (paramString.charAt(m - 1) == j)) {
            return null;
          }
          return paramString.substring(0, m);
        }
        if (i2 == j) {
          return null;
        }
        if ((i2 == 42) || (i2 == 63)) {
          return null;
        }
        i1++;
        n = 0;
      }
      m--;
    }
    return null;
  }
  
  public native int getBooleanAttributes(File paramFile);
  
  public native boolean checkAccess(File paramFile, int paramInt);
  
  public native long getLastModifiedTime(File paramFile);
  
  public native long getLength(File paramFile);
  
  public native boolean setPermission(File paramFile, int paramInt, boolean paramBoolean1, boolean paramBoolean2);
  
  public native boolean createFileExclusively(String paramString)
    throws IOException;
  
  public boolean delete(File paramFile)
  {
    this.cache.clear();
    this.prefixCache.clear();
    return delete0(paramFile);
  }
  
  protected native boolean delete0(File paramFile);
  
  public native String[] list(File paramFile);
  
  public native boolean createDirectory(File paramFile);
  
  public boolean rename(File paramFile1, File paramFile2)
  {
    this.cache.clear();
    this.prefixCache.clear();
    return rename0(paramFile1, paramFile2);
  }
  
  protected native boolean rename0(File paramFile1, File paramFile2);
  
  public native boolean setLastModifiedTime(File paramFile, long paramLong);
  
  public native boolean setReadOnly(File paramFile);
  
  private boolean access(String paramString)
  {
    try
    {
      SecurityManager localSecurityManager = System.getSecurityManager();
      if (localSecurityManager != null) {
        localSecurityManager.checkRead(paramString);
      }
      return true;
    }
    catch (SecurityException localSecurityException) {}
    return false;
  }
  
  private static native int listRoots0();
  
  public File[] listRoots()
  {
    int i = listRoots0();
    int j = 0;
    for (int k = 0; k < 26; k++) {
      if ((i >> k & 0x1) != 0) {
        if (!access((char)(65 + k) + ":" + this.slash)) {
          i &= (1 << k ^ 0xFFFFFFFF);
        } else {
          j++;
        }
      }
    }
    File[] arrayOfFile = new File[j];
    int m = 0;
    char c = this.slash;
    for (int n = 0; n < 26; n++) {
      if ((i >> n & 0x1) != 0) {
        arrayOfFile[(m++)] = new File((char)(65 + n) + ":" + c);
      }
    }
    return arrayOfFile;
  }
  
  public long getSpace(File paramFile, int paramInt)
  {
    if (paramFile.exists())
    {
      File localFile = paramFile.isDirectory() ? paramFile : paramFile.getParentFile();
      return getSpace0(localFile, paramInt);
    }
    return 0L;
  }
  
  private native long getSpace0(File paramFile, int paramInt);
  
  public int compare(File paramFile1, File paramFile2)
  {
    return paramFile1.getPath().compareToIgnoreCase(paramFile2.getPath());
  }
  
  public int hashCode(File paramFile)
  {
    return paramFile.getPath().toLowerCase(Locale.ENGLISH).hashCode() ^ 0x12D591;
  }
  
  private static native void initIDs();
  
  static
  {
    driveDirCache = new String[26];
    
    initIDs();
  }
}

 

flybone7
关注
专栏目录
File类（Java）
weixin_73656077的博客
12-09 1681
1）File类主要是JAVA为文件这块的操作(如。
Java File类，绝对路径和相对路径，File类的构造方法，File类获取功能的方法，File类判断功能的方法，File类创建删除功能的方法，File类遍历（文件夹）目录功能。
Gaoju12138的博客
11-08 7056
1、File类 java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建，查找和删除等操作。 Java把电脑中的文件和文件夹（目录）封装为了一个File类，我们可以使用File类对文件和文件夹进行操作：创建一个文件/文件夹，删除文件/文件夹，获取文件/文件夹，判断文件/文件夹是否存在，对文件夹进行遍历，获取文件的大小。 File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法 重点：记住三个单词 file：文件 directory：文件夹/目录 path：路径 impo
java文件系统_Java之IO(五)文件系统
weixin_35651471的博客
02-12 422
1.前言在讲解Java的文件流之前，先来认识一下Java的文件系统的实现。值得一提的是，Java8与Java7相比，对这一块做了一些改动，接下来会进行对比介绍，但主要还是以Java8为主。1.1 Java7与Java8不同之处概览首先，Java8多了一个DefaultFileSystem，但少了一个Win32FileSystem类，其次两者的抽象父类FileSystem有些许区别。Java7的抽象...
Java SecurityManager checkAccess（）方法与示例
cumudi0723的博客
07-03 410
Syntax: 句法： public void checkAccess (Thread th); public void checkAccess (ThreadGroup tg); SecurityManager类的checkAccess()方法 (SecurityManager Class checkAccess() method) checkAccess(Threa...
AccessController的doPrivileged使用
yekong1225的专栏
07-12 1万+
Java默认不打开安全检查，如果不打开，本地程序拥有所有权限。但是如果程序中加了System.setSecurityManager(new SecurityManager());则Java程序会检验权限。假设有这样一种情况：A程序想在 C:\\Users\\taohuan\\Desktop\\test1  这个目录中新建一个文件，但是它没有相应的权限，但是它引用了另外一个Jar包B，刚好B有权限在...
对AccessController.doPrivileged一点了解
Jerry_Ran的专栏
04-14 2804
AccessController.doPrivileged是一个在AccessController类中的静态方法，允许在一个类实例中的代码通知这个AccessController：它的代码主体是享受"privileged(特权的)"，它单独负责对它的可得的资源的访问请求，而不管这个请求是由什么代码所引发的。这就是说，一个调用者在调用doPrivileged方法时，可被标识为 "特权"。在做访问
java 的 AccessController.doPrivileged使用
u010074988的博客
07-13 1674
AccessController.doPrivileged意思是这个是特别的,不用做权限检查. 在什么地方会用到呢:加入1.jar中有类可以读取一个文件,现在我们要使用1.jar去做这个事情.但是我们的类本生是没有权限去读取那个文件的,一般情况下就是眼睁睁的看着了. 但是jiava提供了doPrivileged.在1.jar中如果读取文件的方法是通过doPrivileged来实现的.就不会有后面的检查了,现在我们就可以使用1.jar去读取那个文件了.. package huangyunbin....
C#中File类的文件操作方法详解
01-01
本文实例讲述了C#中File类的文件操作方法。分享给大家供大家参考。具体分析如下： File类，是一个静态类，主要是来提供一些函数库用的。静态实用类，提供了很多静态的方法，支持对文件的基本操作，包括创建，拷贝，...
Java中的File类
12-22
一、什么是File类 File类是SUN公司提供给开发者操作文件和文件夹的一个类。Java中万物皆对象，计算机中万物皆文件。 获取File类有三种方式： File(String pathName); 根据对应的文件路径创建获取对应的File...
File类的构造方法和各种常用的方法
naoguoteng的博客
06-16 2733
1.File类2.构造方法3.File类中的方法4.文件名称过滤器(FilenameFilter)5.相关案例: 判断D盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称.以及递归删除非空文件夹(目录) .File类是文件和目录路径名的抽象表示形式. 并且这个File类可以用来封装文件,也可以用来封装目录.,然后对其进行操作!注意事项：如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下补充: 相对路径是指没有带盘符的路径. 而相应的绝对路径就是带有盘符的路径​ 4.文件名称过滤器(
Firefly简介
duqing72的专栏
10-19 1万+
 配置管理工具是每一个软件开发团队必备的工具之一。正确地使用好配置管理工具可以在很大程度上提高团队的工作效率，促进成员之间的沟通；避免因为版本混乱而为客户和公司造成的损失。汉星天公司（Hansky Ltd.）最新的配置管理工具Firefly是在总结了过去20多年中配置管理工具发展的趋势与技术之后，开发出的一套全新的面向项目的配置管理工具。相对于传统的版本控制工具（CVS、VSS、PVCS、Cl
厂商优劣势解析：Gartner分布式文件及对象存储市场魔力象限
weixin_33882443的博客
08-01 633
Gartner发布了一款分布式文件系统和对象存储魔力象限，前三名提供商分别是Dell EMC、IBM、Scalitu。 这项研究定义了分布式文件系统和对象存储是“提供了对象以及/或者横向扩展文件技术的软件和硬件解决方案，解决非结构化数据增长的需求，是基于‘无共享架构的’”。 除了前三名的厂商之外，领导者象限没有其他入围厂商了。HDS是唯一一个“挑战者”...
Spring源码--关于AccessController.doPrivileged
laiwenqiang的专栏
01-11 6900
AccessController.doPrivileged是一个在AccessController类中的静态方法，允许在一个类实例中的代码通知这个AccessController：它的代码主体是享受”privileged(特权的)”，它单独负责对它的可得的资源的访问请求，而不管这个请求是由什么代码所引发的。 DefaultListableBeanFactory的preInstantiateSingl
firefly架构说明
9527的专栏
08-11 1458
Firefly是免费、开源、稳定、快速扩展、能 “热更新”的分布式游戏服务器端框架，采用Python编写，基于Twisted框架开发。它包括了开发框架和数据库缓存服务等各种游戏服务器基础服务，节省大量游戏开发的工作时间，真正做到让使用者把精力放在游戏玩法逻辑上。用它可以搭建自定义的分布式架构，只需要修改相应的配置文件即可。 优势特性 采用单线程多进程架构，支持自定义的分布式
IDEA查看类由哪个jar包提供
热门推荐
不当初
03-23 2万+
1问题描述 在进行开发时，很有可能需要移至别人的代码到自己的项目中，这部分代码的功能完成的是如此的优美，以至于我们在阅读时爱不释手，迫不及待的想要把这段代码放置在自己开发的程序中。但此时有一个很显然的问题要弄清楚，类是由jar包提供的，因此关注代码片段中所使用的类所在的jar包就必须引入到自己的项目中。 如何查看一个类型所在的包是那些呢？这便是该博客所要阐述的问题点所在。 package com...
如何访问到一个Servlet？
flybone7的博客
01-25 2520
1.浏览器地址栏中输入：http://localhost:8080/myProject/demo1.do 2.通过ip找到网络对应的服务器 3.通过端口找到服务器上运行的程序----Servlet容器--（Tomcat是一个免费的开放源代码的Servlet容器） 4.通过对应的访问地址找到对应的工程，如：myProject 5.对url地址进行匹配,如:".do后缀都可以匹配到spring-mvc的servlet"，改selvlet映射关系，配置在/WEB-INF/web.xml中 <s
Java中的Properties对象
flybone7的博客
04-27 1519
Properties是Java中jdk自带的一个对象 我们可以直接将后缀为properties的文件变为Properties对象，然后通过Porperties对象中的方法对.properties文件对象进行操作。 package propertiesTset; import java.util.Properties; public class PropertiesTest { ...
@Autowired注入的Httprequest如何保证线程安全
flybone7的博客
11-27 665
@Autowired注入的Httprequest如何保证线程安全
java file类
最新发布
09-17
Java中的File类是用于封装电脑中的文件和文件夹（目录）的类。通过File类，我们可以对文件和文件夹进行各种操作。File类提供了一些常用的方法，如exists()方法用于判断文件是否存在，isDirectory()方法用于判断是否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值