package com.zcjl.test.base;

import java.io.File;

public class Test {

    public static void main(String[] args) throws Exception {

        System.out.println(

            Thread.currentThread().getContextClassLoader().getResource(""));

        System.out.println(Test.class.getClassLoader().getResource(""));

        System.out.println(ClassLoader.getSystemResource(""));

        System.out.println(Test.class.getResource(""));

        System.out.println(Test.class.getResource("/"));

        System.out.println(new File("").getAbsolutePath());

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

    }

}

import java.io.*;

import java.net.*;

import java.util.*;

//import javax.swing.filechooser.*;

//import org.jr.swing.filter.*;



/**

* 此类中封装一些常用的文件操作。

* 所有方法都是静态方法，不需要生成此类的实例，

* 为避免生成此类的实例，构造方法被申明为private类型的。

* @since  0.1

*/



public class FileUtil {

  /**

   * 私有构造方法，防止类的实例化，因为工具类不需要实例化。

   */

  private FileUtil() {



  }



  /**

   * 修改文件的最后访问时间。

   * 如果文件不存在则创建该文件。

   * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考



虑中。</b>

   * @param file 需要修改最后访问时间的文件。

   * @since  0.1

   */

  public static void touch(File file) {

    long currentTime = System.currentTimeMillis();

    if (!file.exists()) {

      System.err.println("file not found:" + file.getName());

      System.err.println("Create a new file:" + file.getName());

      try {

        if (file.createNewFile()) {

        //  System.out.println("Succeeded!");

        }

        else {

        //  System.err.println("Create file failed!");

        }

      }

      catch (IOException e) {

      //  System.err.println("Create file failed!");

        e.printStackTrace();

      }

    }

    boolean result = file.setLastModified(currentTime);

    if (!result) {

    //  System.err.println("touch failed: " + file.getName());

    }

  }



  /**

   * 修改文件的最后访问时间。

   * 如果文件不存在则创建该文件。

   * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考



虑中。</b>

   * @param fileName 需要修改最后访问时间的文件的文件名。

   * @since  0.1

   */

  public static void touch(String fileName) {

    File file = new File(fileName);

    touch(file);

  }



  /**

   * 修改文件的最后访问时间。

   * 如果文件不存在则创建该文件。

   * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考



虑中。</b>

   * @param files 需要修改最后访问时间的文件数组。

   * @since  0.1

   */

  public static void touch(File[] files) {

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

      touch(files);

    }

  }



  /**

   * 修改文件的最后访问时间。

   * 如果文件不存在则创建该文件。

   * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考



虑中。</b>

   * @param fileNames 需要修改最后访问时间的文件名数组。

   * @since  0.1

   */

  public static void touch(String[] fileNames) {

    File[] files = new File[fileNames.length];

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

      files = new File(fileNames);

    }

    touch(files);

  }



  /**

   * 判断指定的文件是否存在。

   * @param fileName 要判断的文件的文件名

   * @return 存在时返回true，否则返回false。

   * @since  0.1

   */

  public static boolean isFileExist(String fileName) {

    return new File(fileName).isFile();

  }



  /**

   * 创建指定的目录。

   * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。

   * <b>注意：可能会在返回false的时候创建部分父目录。</b>

   * @param file 要创建的目录

   * @return 完全创建成功时返回true，否则返回false。

   * @since  0.1

   */

  public static boolean makeDirectory(File file) {

    File parent = file.getParentFile();

    if (parent != null) {

      return parent.mkdirs();

    }

    return false;

  }



  /**

   * 创建指定的目录。

   * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。

   * <b>注意：可能会在返回false的时候创建部分父目录。</b>

   * @param fileName 要创建的目录的目录名

   * @return 完全创建成功时返回true，否则返回false。

   * @since  0.1

   */

  public static boolean makeDirectory(String fileName) {

    File file = new File(fileName);

    return makeDirectory(file);

  }



  /**

   * 清空指定目录中的文件。

   * 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。

   * 另外这个方法不会迭代删除，即不会删除子目录及其内容。

   * @param directory 要清空的目录

   * @return 目录下的所有文件都被成功删除时返回true，否则返回false.

   * @since  0.1

   */

  public static boolean emptyDirectory(File directory) {

    boolean result = false;

    File[] entries = directory.listFiles();

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

      if (!entries.delete()) {

        result = false;

      }

    }

    return true;

  }



  /**

   * 清空指定目录中的文件。

   * 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。

   * 另外这个方法不会迭代删除，即不会删除子目录及其内容。

   * @param directoryName 要清空的目录的目录名

   * @return 目录下的所有文件都被成功删除时返回true，否则返回false。

   * @since  0.1

   */

  public static boolean emptyDirectory(String directoryName) {

    File dir = new File(directoryName);

    return emptyDirectory(dir);

  }



  /**

   * 删除指定目录及其中的所有内容。

   * @param dirName 要删除的目录的目录名

   * @return 删除成功时返回true，否则返回false。

   * @since  0.1

   */

  public static boolean deleteDirectory(String dirName) {

    return deleteDirectory(new File(dirName));

  }



  /**

   * 删除指定目录及其中的所有内容。

   * @param dir 要删除的目录

   * @return 删除成功时返回true，否则返回false。

   * @since  0.1

   */

  public static boolean deleteDirectory(File dir) {

    if ( (dir == null) || !dir.isDirectory()) {

      throw new IllegalArgumentException("Argument " + dir +

                                         " is not a directory. ");

    }



    File[] entries = dir.listFiles();

    int sz = entries.length;



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

      if (entries.isDirectory()) {

        if (!deleteDirectory(entries)) {

          return false;

        }

      }

      else {

        if (!entries.delete()) {

          return false;

        }

      }

    }



    if (!dir.delete()) {

      return false;

    }

    return true;

  }









  /**

   * 返回文件的URL地址。

   * @param file 文件

   * @return 文件对应的的URL地址

   * @throws MalformedURLException

   * @since  0.4

   * @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。

   *             请使用File.toURL方法。

   */

  public static URL getURL(File file) throws MalformedURLException {

    String fileURL = "file:/" + file.getAbsolutePath();

    URL url = new URL(fileURL);

    return url;

  }



  /**

   * 从文件路径得到文件名。

   * @param filePath 文件的路径，可以是相对路径也可以是绝对路径

   * @return 对应的文件名

   * @since  0.4

   */

  public static String getFileName(String filePath) {

    File file = new File(filePath);

    return file.getName();

  }



  /**

   * 从文件名得到文件绝对路径。

   * @param fileName 文件名

   * @return 对应的文件路径

   * @since  0.4

   */

  public static String getFilePath(String fileName) {

    File file = new File(fileName);

    return file.getAbsolutePath();

  }



  /**

   * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。

   * 其实就是将路径中的"\"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便，

   * 某中程度上说"/"比"\"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。

   * @param filePath 转换前的路径

   * @return 转换后的路径

   * @since  0.4

   */

  public static String toUNIXpath(String filePath) {

    return filePath.replace('\\', '/');

  }



  /**

   * 从文件名得到UNIX风格的文件绝对路径。

   * @param fileName 文件名

   * @return 对应的UNIX风格的文件路径

   * @since  0.4

   * @see #toUNIXpath(String filePath) toUNIXpath

   */

  public static String getUNIXfilePath(String fileName) {

    File file = new File(fileName);

    return toUNIXpath(file.getAbsolutePath());

  }



  /**

   * 得到文件的类型。

   * 实际上就是得到文件名中最后一个"."后面的部分。

   * @param fileName 文件名

   * @return 文件名中的类型部分

   * @since  0.5

   */

  public static String getTypePart(String fileName) {

    int point = fileName.lastIndexOf('.');

    int length = fileName.length();

    if (point == -1 || point == length - 1) {

      return "";

    }

    else {

      return fileName.substring(point + 1, length);

    }

  }



  /**

   * 得到文件的类型。

   * 实际上就是得到文件名中最后一个"."后面的部分。

   * @param file 文件

   * @return 文件名中的类型部分

   * @since  0.5

   */

  public static String getFileType(File file) {

    return getTypePart(file.getName());

  }



  /**

   * 得到文件的名字部分。

   * 实际上就是路径中的最后一个路径分隔符后的部分。

   * @param fileName 文件名

   * @return 文件名中的名字部分

   * @since  0.5

   */

  public static String getNamePart(String fileName) {

    int point = getPathLsatIndex(fileName);

    int length = fileName.length();

    if (point == -1) {

      return fileName;

    }

    else if (point == length - 1) {

      int secondPoint = getPathLsatIndex(fileName, point - 1);

      if (secondPoint == -1) {

        if (length == 1) {

          return fileName;

        }

        else {

          return fileName.substring(0, point);

        }

      }

      else {

        return fileName.substring(secondPoint + 1, point);

      }

    }

    else {

      return fileName.substring(point + 1);

    }

  }



  /**

   * 得到文件名中的父路径部分。

   * 对两种路径分隔符都有效。

   * 不存在时返回""。

   * 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。

   * @param fileName 文件名

   * @return 父路径，不存在或者已经是父目录时返回""

   * @since  0.5

   */

  public static String getPathPart(String fileName) {

    int point = getPathLsatIndex(fileName);

    int length = fileName.length();

    if (point == -1) {

      return "";

    }

    else if (point == length - 1) {

      int secondPoint = getPathLsatIndex(fileName, point - 1);

      if (secondPoint == -1) {

        return "";

      }

      else {

        return fileName.substring(0, secondPoint);

      }

    }

    else {

      return fileName.substring(0, point);

    }

  }



  /**

   * 得到路径分隔符在文件路径中首次出现的位置。

   * 对于DOS或者UNIX风格的分隔符都可以。

   * @param fileName 文件路径

   * @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。

   * @since  0.5

   */

  public static int getPathIndex(String fileName) {

    int point = fileName.indexOf('/');

    if (point == -1) {

      point = fileName.indexOf('\\');

    }

    return point;

  }



  /**

   * 得到路径分隔符在文件路径中指定位置后首次出现的位置。

   * 对于DOS或者UNIX风格的分隔符都可以。

   * @param fileName 文件路径

   * @param fromIndex 开始查找的位置

   * @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。

   * @since  0.5

   */

  public static int getPathIndex(String fileName, int fromIndex) {

    int point = fileName.indexOf('/', fromIndex);

    if (point == -1) {

      point = fileName.indexOf('\\', fromIndex);

    }

    return point;

  }



  /**

   * 得到路径分隔符在文件路径中最后出现的位置。

   * 对于DOS或者UNIX风格的分隔符都可以。

   * @param fileName 文件路径

   * @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。

   * @since  0.5

   */

  public static int getPathLsatIndex(String fileName) {

    int point = fileName.lastIndexOf('/');

    if (point == -1) {

      point = fileName.lastIndexOf('\\');

    }

    return point;

  }



  /**

   * 得到路径分隔符在文件路径中指定位置前最后出现的位置。

   * 对于DOS或者UNIX风格的分隔符都可以。

   * @param fileName 文件路径

   * @param fromIndex 开始查找的位置

   * @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。

   * @since  0.5

   */

  public static int getPathLsatIndex(String fileName, int fromIndex) {

    int point = fileName.lastIndexOf('/', fromIndex);

    if (point == -1) {

      point = fileName.lastIndexOf('\\', fromIndex);

    }

    return point;

  }



  /**

   * 将文件名中的类型部分去掉。

   * @param filename 文件名

   * @return 去掉类型部分的结果

   * @since  0.5

   */

  public static String trimType(String filename) {

    int index = filename.lastIndexOf(".");

    if (index != -1) {

      return filename.substring(0, index);

    }

    else {

      return filename;

    }

  }

  /**

   * 得到相对路径。

   * 文件名不是目录名的子节点时返回文件名。

   * @param pathName 目录名

   * @param fileName 文件名

   * @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名

   * @since  0.5

   */

  public static String getSubpath(String pathName,String fileName) {

    int index = fileName.indexOf(pathName);

    if (index != -1) {

      return fileName.substring(index + pathName.length() + 1);

    }

    else {

      return fileName;

    }

  }



}

InputStream input = Thread.currentThread().getContextClassLoader().

getResourceAsStream("abc.properties");

Properties prop = new Properties();

prop.load(input);

input.close();

OutputStream out = new FileOutputStream(path);

prop.setProperty("abc", "test");

prop.store(out, "–test–");

out.close();

// jsp页面

String path = pageContext.getServletContext().getRealPath("/");

String realPath = path+"/WEB-INF/classes/abc.properties";



//java 程序

InputStream in = getClass().getClassLoader().getResourceAsStream("abc.properties"); // abc.properties放在webroot/WEB-INF/classes/目录下

prop.load(in);

in.close();



OutputStream out = new FileOutputStream(path); // path为通过页面传入的路径

prop.setProperty("abc", "abcccccc");

prop.store(out, "–test–");

out.close();

InputStream in = new FileInputStream("abc.properties"); // 放在classes同级



OutputStream out = new FileOutputStream("abc.properties");

这个时候我们就需要进行deep Clone了，对那些非基本型别的域进行特殊的处理，例如本例中的hireDay。我们可以重新定义Clone方法，对hireDay做特殊处理，如下代码所示：

   class Employee implements Cloneable

{

        public Object clone() throws CloneNotSupportedException

        {

         Employee cloned = (Employee) super.clone();

      cloned.hireDay = (Date) hireDay.clone()

      return cloned;

        }

}



3． Clone()方法的保护机制

在Object中Clone()是被申明为protected的，这样做是有一定的道理的，以Employee

类为例，通过申明为protected，就可以保证只有Employee类里面才能“克隆”Employee对象，原理可以参考我前面关于public、protected、private的学习笔记。

4． Clone()方法的使用

Clone()方法的使用比较简单，注意如下几点即可：

a． 什么时候使用shallow Clone，什么时候使用deep Clone，这个主要看具体对象的域是什么性质的，基本型别还是reference variable

b． 调用Clone()方法的对象所属的类(Class)必须implements Clonable接口，否则在调用Clone方法的时候会抛出CloneNotSupportedException。

1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：

1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
Input stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
Out stream：
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream

1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
Input stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
Out stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应

以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，只是在操作时的导向不同。如CharArrayReader：和

ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是后者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。

1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。

2. stream添加属性

2.1 “为stream添加属性”的作用

运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。

如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。

2.2 FilterInputStream的各种类型

2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发

2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应

2.3 FilterOutStream的各种类型

2.3.1 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出

2.3.2 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应

3. RandomAccessFile

1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置

4. I/O应用的一个例子

import java.io.*;
public class TestIO{
    public static void main(String[] args) throws IOException{
//1.以行为单位从一个文件读取数据
    BufferedReader in =new BufferedReader(new FileReader(\"F:
epalonTestIO.java\"));
    String s, s2 = new String();
    while((s = in.readLine()) != null)
        s2 += s + "\\";
    in.close();

//1b. 接收键盘的输入
    BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
    System.out.println(\"Enter a line:\");
    System.out.println(stdin.readLine());

//2. 从一个String对象中读取数据
    StringReader in2 = new StringReader(s2);
    int c;
    while((c = in2.read()) != -1)
        System.out.println((char)c);
    in2.close();

//3. 从内存取出格式化输入
    try{
        DataInputStream in3 =new DataInputStream(new ByteArrayInputStream(s2.getBytes()));
        while(true)
            System.out.println((char)in3.readByte());
    }
    catch(EOFException e){
        System.out.println(\"End of stream\");
    }

//4. 输出到文件
    try{
        BufferedReader in4 =new BufferedReader(new StringReader(s2)); //把s2当作输入对象
        PrintWriter out1 =new PrintWriter(new BufferedWriter(new FileWriter(\"F:epalon TestIO.out\")));
        int lineCount = 1;
        while((s = in4.readLine()) != null)
            out1.println(lineCount  + \"：\" + s);
        out1.close();
        in4.close();
    }
    catch(EOFException ex){
        System.out.println(\"End of stream\");
    }

//5. 数据的存储和恢复
    try{
        DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(\"F:epalon Data.txt\")));
        out2.writeDouble(3.1415926);
        out2.writeChars(" Thas was pi:writeChars ");
        out2.writeBytes( "Thas was pi:writeByte ");
        out2.close();
        DataInputStream in5 = new DataInputStream(new BufferedInputStream(new FileInputStream(\"F:epalon Data.txt\")));
        BufferedReader in5br = new BufferedReader(new InputStreamReader(in5));
        System.out.println(in5.readDouble());
        System.out.println(in5br.readLine());
        System.out.println(in5br.readLine());
    }
    catch(EOFException e){
        System.out.println(\"End of stream\");
    }

//6. 通过RandomAccessFile操作文件
    RandomAccessFile rf = new RandomAccessFile(\"F:epalon rtest.dat\", \"rw\");
    for(int i=0; i<10; i++)
        rf.writeDouble(i*1.414);
    rf.close();

    rf = new RandomAccessFile(\"F:epalon rtest.dat\", \"r\");
    for(int i=0; i<10; i++)
        System.out.println(\"Value \" + i + \"：\" + rf.readDouble());
    rf.close();

    rf = new RandomAccessFile(\"F:epalon rtest.dat\", \"rw\");
    rf.seek(5*8);
    rf.writeDouble(47.0001);
    rf.close();

    rf = new RandomAccessFile(\"F:epalon rtest.dat\", \"r\");
    for(int i=0; i<10; i++)
        System.out.println(\"Value \" + i + \"：\" + rf.readDouble());
    rf.close();
    }
}

关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。

        1、语法：必须比较熟悉，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正。

　　2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、HtmlConverter、jar、java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。

　　3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。

　　4、API：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括：

　　 1）、java.lang包下的80％以上的类的功能的灵活运用。

　　 2）、java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer。

　　 3）、java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。

　　 4）、java.math包下的100％的内容。

　　 5）、java.net包下的60％以上的内容，对各个类的功能比较熟悉。

　　 6）、java.text包下的60％以上的内容，特别是各种格式化类。

　　 7）、熟练运用JDBC。

　　 8）、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java。

　　 9）、AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。

　　 10）、Swing的基本内容，和AWT的要求类似。

　　 11）、XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。

　　5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。

　　6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。

　　7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。

　　8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。

　　9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。