JAVA API阅读笔记

Arrays类

public class Arrays extends Object

此类包含用来操作数组（比如排序和搜索）的各种方法。

基本上都是static方法：故调用的时候：Arrays.方法名

 

四个基本方法：

equals()： 比较两个数组是否相等

fill()：用某个值填充整个数组

sort()：对数组排序

binarySearch()：在已经排序的数组中查找元素

 

 

//equals和deepEquals区别：

深层是什么概念？

 

BufferedReader类

public class BufferedReader

   extends Reader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 

 

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 

 

通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如， 

 

 BufferedReader in

   = new BufferedReader(new FileReader("foo.in"));

 将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。 

 

构造方法：

BufferedReader(Reader in) 

          创建一个使用默认大小输入缓冲区的缓冲字符输入流。

 

常用方法：

 String readLine() 

          读取一个文本行。 

 

ClassT

extends Object

类 Class<T>

 

类型参数：

T - 由此 Class 对象建模的类的类型。例如，String.class 的类型是 Class<String>。如果将被建模的类未知，则使用 Class<?>。

 

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。 

 

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。 

 

常用的方法：

public static Class<?> forName(String className)

                        throws ClassNotFoundException

返回与带有给定字符串名的类或接口相关联的 Class 对象。

调用 forName("X") 将导致命名为 X 的类被初始化

 

public String getName()

以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。 

如果此类对象表示的是非数组类型的引用类型，则返回该类的二进制名称

如果此类对象表示一个基本类型或 void，则返回的名字是一个与该基本类型或 void 所对应的 Java 语言关键字相同的 String。 

如果此类对象表示一个数组类，则名字的内部形式为：表示该数组嵌套深度的一个或多个 '[' 字符加元素类型名。元素类型名的编码如下： 

Element Type       Encoding  

boolean                  Z  

byte       B  

char       C  

class or interface       Lclassname;  

double       D  

float       F  

int       I  

long       J  

short       S  

 

public T newInstance()

              throws InstantiationException,

                     IllegalAccessException

//通过类名来产生实例

 

Class<?>[] getInterfaces()  

          确定此对象所表示的类或接口实现的接口。

 

 boolean isInterface() 

          判定指定的 Class 对象是否表示一个接口类型 

 

Class<? super T> getSuperclass() 

          返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。

 

 Method[] getMethods() 

          返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。 

 

 Constructor<?>[] getConstructors() 

          返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。 

 

Connection接口

接口

父接口：Wrapper

提供的主要方法：

 Statement createStatement()

 PreparedStatement prepareStatement(String sql)

 

使用Connection (返回Connection对象)

 Connection Driver.connect(String url, Properties info) 

 

 Connection DatabaseMetaData.getConnection() 

 

 Connection Statement.getConnection() 

 

 static Connection DriverManager.getConnection(String url) 

 static Connection DriverManager.getConnection(String url, Properties info) 

 static Connection DriverManager.getConnection(String url, String user, String password) 

 

 Connection DataSource.getConnection()  

 Connection DataSource.getConnection(String username, String password)  

 

DataSource是DriverManager的替代品

 

 

DataSource接口

extends CommonDataSource, Wrapper

 

该工厂用于提供到此 DataSource 对象所表示的物理数据源的连接。作为 DriverManager 工具的替代项，DataSource 对象是获取连接的首选方法。实现 DataSource 接口的对象通常在基于 JavaTM Naming and Directory Interface (JNDI) API 的命名服务中注册。 

 

DataSource 接口由驱动程序供应商实现。共有三种类型的实现： 

基本实现 - 生成标准的 Connection 对象 

连接池实现 - 生成自动参与连接池的 Connection 对象。此实现与中间层连接池管理器一起使用。 

分布式事务实现 - 生成一个 Connection 对象，该对象可用于分布式事务，大多数情况下总是参与连接池。此实现与中间层事务管理器一起使用，大多数情况下总是与连接池管理器一起使用。 

 

DataSource 对象的属性在必要时可以修改。例如，如果将数据源移动到另一个服务器，则可更改与服务器相关的属性。其优点在于，由于可以更改数据源的属性，所以任何访问该数据源的代码都无需更改。 

 

通过 DataSource 对象访问的驱动程序本身不会向 DriverManager 注册。通过查找操作获取 DataSource 对象，然后使用该对象创建 Connection 对象。使用基本的实现，通过 DataSource 对象获取的连接与通过 DriverManager 设施获取的连接相同。

 

提供的主要方法：

Connection getConnection(String username,

                         String password)

Connection getConnection()

DriverManager类

extends Object

管理一组 JDBC 驱动程序的基本服务。

 

作为初始化的一部分，DriverManager 类会尝试加载在 "jdbc.drivers" 系统属性中引用的驱动程序类。这允许用户定制由他们的应用程序使用的 JDBC Driver。例如，在 ~/.hotjava/properties 文件中，用户可以指定： 

 jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.taste.ourDriver

 

应用程序不再需要使用 Class.forName() 显式地加载 JDBC 驱动程序。当前使用 Class.forName() 加载 JDBC 驱动程序的现有程序将在不作修改的情况下继续工作。 

 

在调用 getConnection 方法时，DriverManager 会试着从初始化时加载的那些驱动程序以及使用与当前 applet 或应用程序相同的类加载器显式加载的那些驱动程序中查找合适的驱动程序。 

 

提供的主要方法：

public static Connection getConnection(String url,

                                       Properties info)

public static Connection getConnection(String url,

                                       String user,

                                       String password)

public static Connection getConnection(String url)

 

public static Driver getDriver(String url)

public static Enumeration<Driver> getDrivers()

 

public static void registerDriver(Driver driver)

public static void deregisterDriver(Driver driver)

 

Driver接口

每个驱动程序类必须实现的接口。

 

Java SQL 框架允许多个数据库驱动程序。 

 

每个驱动程序都应该提供一个实现 Driver 接口的类。 

 

DriverManager 会试着加载尽可能多的它可以找到的驱动程序，然后，对于任何给定连接请求，它会让每个驱动程序依次试着连接到目标 URL。 

 

强烈建议每个 Driver 类应该是小型的并且是单独的，这样就可以在不必引入大量支持代码的情况下加载和查询 Driver 类。 

 

在加载某一 Driver 类时，它应该创建自己的实例并向 DriverManager 注册该实例。这意味着用户可以通过调用以下程序加载和注册一个驱动程序 

   Class.forName("foo.bah.Driver")

 

提供的主要方法：

Connection connect(String url,

                   Properties info)

 

在要求 JDBC 驱动程序管理器连接到给定 URL 时，它会将该 URL 依次传递给每个已加载的驱动程序。

java.util.Properties 参数将任意字符串标记/值对作为连接参数传递。通常 Properties 对象中至少应该包括 "user" 和 "password" 属性。 

 

Enumeration接口

public interface Enumeration<E>实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。 

 

例如，要输出 Vector<E> v 的所有元素，可使用以下方法： 

 

   for (Enumeration<E> e = v.elements(); e.hasMoreElements();)

       System.out.println(e.nextElement());这些方法主要通过向量的元素、哈希表的键以及哈希表中的值进行枚举。枚举也用于将输入流指定到 SequenceInputStream 中。 

 

注：此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。 

 

使用在Hashtable的枚举上面

常用方法：

boolean hasMoreElements() 

          测试此枚举是否包含更多的元素。 

 E nextElement() 

          如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。 

 

Executors

public class Executors

extends Object

 

static ExecutorService newFixedThreadPool(int nThreads) 

          创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。 

 

FilenameFilter接口

public interface FilenameFilter

实现此接口的类实例可用于过滤器文件名。Abstract Window Toolkit 的文件对话框组件使用这些实例过滤 File 类的 list 方法中的目录清单。 

 

接口方法：

 boolean accept(File dir, String name) 

          测试指定文件是否应该包含在某一文件列表中。 

 

File类

public class File

   extends Object

   implements Serializable, Comparable<File>

 

构造函数：

File(String pathname) 

          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

 

常用方法：

boolean delete() 

          删除此抽象路径名表示的文件或目录。 

boolean mkdir() 

          创建此抽象路径名指定的目录。 

 String[] list() 

          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。 

 String[] list(FilenameFilter filter) 

          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。 

 boolean isDirectory() 

          测试此抽象路径名表示的文件是否是一个目录。 

 boolean isFile() 

          测试此抽象路径名表示的文件是否是一个标准文件。 

 boolean isHidden() 

          测试此抽象路径名指定的文件是否是一个隐藏文件。 

long lastModified() 

          返回此抽象路径名表示的文件最后一次被修改的时间。 

 long length() 

          返回由此抽象路径名表示的文件的长度。 

String getName() 

          返回由此抽象路径名表示的文件或目录的名称。 

 String getParent() 

          返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 

boolean canRead() 

          测试应用程序是否可以读取此抽象路径名表示的文件。 

 boolean canWrite() 

          测试应用程序是否可以修改此抽象路径名表示的文件。 

 

HashSet类

public class HashSet<E>

   extends AbstractSet<E>

   implements Set<E>, Cloneable, Serializable

 

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。 

 

此类为基本操作提供了稳定性能，这些基本操作包括 add、remove、contains 和 size，假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小（元素的数量）和底层 HashMap 实例（桶的数量）的“容量”的和成比例。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。 

 

注意，此实现不是同步的。如果多个线程同时访问一个哈希 set，而其中至少一个线程修改了该 set，那么它必须 保持外部同步。这通常是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSet 方法来“包装” set。最好在创建时完成这一操作，以防止对该 set 进行意外的不同步访问：

 

   Set s = Collections.synchronizedSet(new HashSet(...));此类的 iterator 方法返回的迭代器是快速失败 的：在创建迭代器之后，如果对 set 进行修改，除非通过迭代器自身的 remove 方法，否则在任何时间以任何方式对其进行修改，Iterator 都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来在某个不确定时间发生任意不确定行为的风险。 

 

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器在尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误做法：迭代器的快速失败行为应该仅用于检测 bug。 

 

此类是 Java Collections Framework 的成员。 

 

 

构造方法：可以指定其底层HashMap实例的默认初始容量和加载因子

 

常用方法：

 boolean add(E e) 

          如果此 set 中尚未包含指定元素，则添加指定元素。 

 void clear() 

          从此 set 中移除所有元素。 

 Object clone() 

          返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。 

 boolean contains(Object o) 

          如果此 set 包含指定元素，则返回 true。 

 boolean isEmpty() 

          如果此 set 不包含任何元素，则返回 true。 

 Iterator<E> iterator() 

          返回对此 set 中元素进行迭代的迭代器。 

 boolean remove(Object o) 

          如果指定元素存在于此 set 中，则将其移除。 

 int size() 

          返回此 set 中的元素的数量（set 的容量）。 

 

Hashtable类

public class Hashtable<K,V>

   extends Dictionary<K,V>

   implements Map<K,V>, Cloneable, Serializable

 

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。

 

为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

 

Hashtable 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。

 

下面这个示例创建了一个数字的哈希表。它将数字的名称用作键： 

 

   Hashtable<String, Integer> numbers

     = new Hashtable<String, Integer>();

   numbers.put("one", 1);

   numbers.put("two", 2);

   numbers.put("three", 3);要获取一个数字，可以使用以下代码： 

 

   Integer n = numbers.get("two");

     if (n != null) {

         System.out.println("two = " + n);

     }

   }

 

Hashtable存储的是对象引用而不是对象本身。

 

常用方法：

Enumeration<V> elements() 

          返回此哈希表中的值的枚举。 

 V get(Object key) 

          返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。 

 V put(K key, V value) 

          将指定 key 映射到此哈希表中的指定 value。 

 

InputStream抽象类

 

 

Iterator接口

public interface Iterator<E>

对 collection 进行迭代的迭代器

 

产生Iterator对象的方法：(ArrayList)

 Iterator<T> iterator() 

          返回一个在一组 T 类型的元素上进行迭代的迭代器。 

 

主要方法：

 boolean hasNext() 

          如果仍有元素可以迭代，则返回 true。 

 E next() 

          返回迭代的下一个元素。 

 void remove() 

          从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。 

 

 

LinkedHashSet类

public class LinkedHashSet<E>

   extends HashSet<E>

   implements Set<E>, Cloneable, Serializable

 

具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。注意，插入顺序不 受在 set 中重新插入的 元素的影响。（如果在 s.contains(e) 返回 true 后立即调用 s.add(e)，则元素 e 会被重新插入到 set s 中。） 

 

此实现可以让客户免遭未指定的、由 HashSet 提供的通常杂乱无章的排序工作，而又不致引起与 TreeSet 关联的成本增加。使用它可以生成一个与原来顺序相同的 set 副本，并且与原 set 的实现无关： 

 

     void foo(Set s) {

         Set copy = new LinkedHashSet(s);

         ...

     }

 如果模块通过输入得到一个 set，复制这个 set，然后返回由此副本决定了顺序的结果，这种情况下这项技术特别有用。（客户通常期望内容返回的顺序与它们出现的顺序相同。） 

 

允许null元素

影响性能的参数

实现不是同步的

迭代器是快速失败的

 

 

构造方法：与HashSet类似

常用方法：继承HashSet的方法

 

 

Matcher类

 

 

Object基类

protected  Object clone() 

          创建并返回此对象的一个副本。 

 boolean equals(Object obj) 

          指示其他某个对象是否与此对象“相等”。 

protected  void finalize() 

          当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 

 Class<?> getClass() 

          返回此 Object 的运行时类。 

 int hashCode() 

          返回该对象的哈希码值。 

 void notify() 

          唤醒在此对象监视器上等待的单个线程。 

 void notifyAll() 

          唤醒在此对象监视器上等待的所有线程。 

 String toString() 

          返回该对象的字符串表示。 

 void wait() 

          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 

 void wait(long timeout) 

          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。 

 void wait(long timeout, int nanos) 

          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。 

OutputStream抽象类

 

Pattern类

public final class Pattern

   extends Object

   implements Serializable

 

正则表达式的编译表示形式。 

 

指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 

 

因此，典型的调用顺序是 

 

 Pattern p = Pattern.compile("a*b");

 Matcher m = p.matcher("aaaaab");

 boolean b = m.matches();在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句 

 

 boolean b = Pattern.matches("a*b", "aaaaab");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。 

此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。 

 

常用方法：

static Pattern compile(String regex) 

          将给定的正则表达式编译到模式中。 

 

Matcher matcher(CharSequence input) 

          创建匹配给定输入与此模式的匹配器。 

 

static boolean matches(String regex, CharSequence input) 

          编译给定正则表达式并尝试将给定输入与其匹配。 

 

Preferences抽象类

 

PreparedStatement接口

extends Statement

 

表示预编译的 SQL 语句的对象。 

 

SQL 语句被预编译并存储在 PreparedStatement 对象中。然后可以使用此对象多次高效地执行该语句。 

 

注：用于设置 IN 参数值的设置方法（setShort、setString 等等）必须指定与输入参数的已定义 SQL 类型兼容的类型。例如，如果 IN 参数具有 SQL 类型 INTEGER，那么应该使用 setInt 方法。 

 

如果需要任意参数类型转换，使用 setObject 方法时应该将目标 SQL 类型作为其参数。 

 

在以下设置参数的示例中，con 表示一个活动连接： 

 

   PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES

                                     SET SALARY = ? WHERE ID = ?");

   pstmt.setBigDecimal(1, 153833.00)

   pstmt.setInt(2, 110592)

 

提供的主要方法：

 ResultSet executeQuery()  

 int executeUpdate()  

 boolean execute()  

 一堆的set方法，设定SQL语句中未知量

QName类

 

 

Reader抽象类

 

ResultSet接口

extends Wrapper

 

表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。 

 

ResultSet 对象具有指向其当前数据行的光标。最初，光标被置于第一行之前。next 方法将光标移动到下一行；因为该方法在 ResultSet 对象没有下一行时返回 false，所以可以在 while 循环中使用它来迭代结果集。 

 

默认的 ResultSet 对象不可更新，仅有一个向前移动的光标。因此，只能迭代它一次，并且只能按从第一行到最后一行的顺序进行。可以生成可滚动和/或可更新的 ResultSet 对象。以下代码片段（其中 con 为有效的 Connection 对象）演示了如何生成可滚动且不受其他更新影响的可更新结果集。有关其他选项，请参见 ResultSet 字段。 

 

 

       Statement stmt = con.createStatement(

                                      ResultSet.TYPE_SCROLL_INSENSITIVE,

                                      ResultSet.CONCUR_UPDATABLE);

       ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");

       // rs will be scrollable, will not show changes made by others,

       // and will be updatable

 

 ResultSet 接口提供用于从当前行获取列值的获取 方法（getBoolean、getLong 等）。可以使用列的索引编号或列的名称获取值。一般情况下，使用列索引较为高效。列从 1 开始编号。为了获得最大的可移植性，应该按从左到右的顺序读取每行中的结果集列，每列只能读取一次。 

对于获取方法，JDBC 驱动程序尝试将底层数据转换为在获取方法中指定的 Java 类型，并返回适当的 Java 值。JDBC 规范有一个表，显示允许的从 SQL 类型到 ResultSet 获取方法所使用的 Java 类型的映射关系。 

 

 

用作获取方法的输入的列名称不区分大小写。用列名称调用获取方法时，如果多个列具有这一名称，则返回第一个匹配列的值。在生成结果集的 SQL 查询中使用列名称时，将使用列名称选项。对于没有在查询中显式指定的列，最好使用列编号。如果使用列名称，则程序员应该注意保证名称唯一引用预期的列，这可以使用 SQL AS 子句确定。 

 

在 JDBC 2.0 API（JavaTM 2 SDK 标准版 1.2 版）中，此接口添加了一组更新方法。关于获取方法参数的注释同样适用于更新方法的参数。 

 

可以用以下两种方式使用更新方法： 

 

更新当前行中的列值。在可滚动的 ResultSet 对象中，可以向前和向后移动光标，将其置于绝对位置或相对于当前行的位置。以下代码片段更新 ResultSet 对象 rs 第五行中的 NAME 列，然后使用方法 updateRow 更新导出 rs 的数据源表。 

 

       rs.absolute(5); // moves the cursor to the fifth row of rs

       rs.updateString("NAME", "AINSWORTH"); // updates the 

          // NAME column of row 5 to be AINSWORTH

       rs.updateRow(); // updates the row in the data source

 

 将列值插入到插入行中。可更新的 ResultSet 对象具有一个与其关联的特殊行，该行用作构建要插入的行的暂存区域 (staging area)。以下代码片段将光标移动到插入行，构建一个三列的行，并使用方法 insertRow 将其插入到 rs 和数据源表中。 

 

       rs.moveToInsertRow(); // moves cursor to the insert row

       rs.updateString(1, "AINSWORTH"); // updates the 

          // first column of the insert row to be AINSWORTH

       rs.updateInt(2,35); // updates the second column to be 35

       rs.updateBoolean(3, true); // updates the third column to true

       rs.insertRow();

       rs.moveToCurrentRow();

 

 当生成 ResultSet 对象的 Statement 对象关闭、重新执行或用来从多个结果的序列获取下一个结果时，ResultSet 对象将自动关闭。 

 

ResultSet 对象的列的编号、类型和属性由 ResultSet.getMetaData 方法返回的 ResulSetMetaData 对象提供。 

 

提供的主要方法：

  一系列的get方法来取列值

  boolean next()  

  void close()

  一系列update方法

 

 

Runnable接口

public interface RunnableRunnable 

接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。 

 

设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如，Thread 类实现了 Runnable。激活的意思是说某个线程已启动并且尚未停止。 

 

此外，Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread 的子类。大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类创建子类。 

 

方法：

void run() 

          使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。 

 

SecurityManager类

 

Statement接口

extends Wrapper

 

用于执行静态 SQL 语句并返回它所生成结果的对象。 

 

在默认情况下，同一时间每个 Statement 对象在只能打开一个 ResultSet 对象。因此，如果读取一个 ResultSet 对象与读取另一个交叉，则这两个对象必须是由不同的 Statement 对象生成的。如果存在某个语句的打开的当前 ResultSet 对象，则 Statement 接口中的所有执行方法都会隐式关闭它。

 

提供的常用方法：

ResultSet executeQuery(String sql)  

int executeUpdate(String sql)    //不返回任何内容

 

boolean execute(String sql) 

ResultSet getResultSet()

boolean getMoreResults() 

int getUpdateCount()

StringReader类

public class StringReader

   extends Reader

其源为一个字符串的字符流。

 

构造函数：

StringReader(String s) 

          创建一个新字符串 reader。

 

常用方法：

 int read() 

          读取单个字符。 

 

System类

public final class System

   extends Object

System 类包含一些有用的类字段和方法。它不能被实例化。 

 

在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。 

 

常用字段：

static PrintStream err 

          “标准”错误输出流。 

static InputStream in 

          “标准”输入流。 

static PrintStream out 

          “标准”输出流。 

 

常用方法：

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 

          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 //这里只是浅复制。 只复制了引用。 ？？、 

 

Thread类

public class Thread

extends Object

implements Runnable

 

有优先级MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY

线程都有一个标识名：Thread(String name)，可通过 String getName()取回来

boolean isDaemon()

void setDaemon(boolean on) 将该线程标记为守护线程或用户线程，必须在线程启动之前调用。

创建线程：继承Thread，实现Runnable。重写run()方法。

启动线程：创建线程实例，调用start()方法

常用方法：

 void join() 

          等待该线程终止。 

 void join(long millis) 

          等待该线程终止的时间最长为 millis 毫秒。 

 void join(long millis, int nanos) 

          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 

 static void sleep(long millis) 

          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 

 static void sleep(long millis, int nanos) 

          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 

 static void yield() 

          暂停当前正在执行的线程对象，并执行其他线程。 

 

Thread.getState()  //返回线程的状态

线程状态：在给定时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所有操作系统线程状态。

public static enum Thread.State

extends Enum<Thread.State>

 

NEW

至今尚未启动的线程处于这种状态。 

RUNNABLE

正在 Java 虚拟机中执行的线程处于这种状态。 

BLOCKED

受阻塞并等待某个监视器锁的线程处于这种状态。 

WAITING

无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。 

TIMED_WAITING

等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。 

TERMINATED

已退出的线程处于这种状态。 

 

TreeSet类

 

 

Writer抽象类

 

 

Java容器类关系