读书笔记--Java核心技术--高级特征

abstract int read()        //从数据中读入一个字节，并返回该字节，在碰到流的结尾时返回-1
int read(byte[] b)          //读入一个字节数组，并返回实际读入的字节数，或者在碰到流的结尾时返回-1
int read(byte[] b, int off, int len)        //读入一个字节数组。这个read方法返回实际读入的字节数，或者在碰到流的结尾时返回-1
long skip(long n)      //在输入流中跳过n个字节，返回实际跳过的字节数（如果碰到流的结尾，则可能小于n）
int available()   //返回在不阻塞的情况下可用的字节数
void close()        //关闭这个输入流
void mark(int readLimit)   //在输入流的当前位置打一个标记，如果输入流中已经读入的字节多于readLimit个，则这个流允许忽略这个标记
void reset()     //返回到最后的标记，随后对read的调用将重新读入这些字节
boolean markSupported()    //如果这个流支持打标记，则返回true

abstract void write(int n)  //写出一个字节的数据
void write(byte[] b)
void write(byte[] b, int off, int len)  //写出所有字节或者某个范围的字节到数组b中
void close()  //清空并关闭输出流
void flush()  //清空输出流，也就是将所有缓冲的数据发送到目的地

void close()  //关闭这个Closeable，可能会抛出IOException

void flush()  //清空这个Flushable

int read(CharBuffer cb)  //尝试读入cb可以持有的数量的char值。返回读入的char值的数量

char charAt(int index)  //返回给定索引处的码元
int length()  //返回这个序列中的码元的数量
CharSequence subSequence(int startIndex, int endIndex)  //返回由存储在startIndex到endIndex - 1处的所有码元构成的CharSequence
String toString()  //返回这个序列中所有码元构成的字符串

FileInputStream fin = new FileInputStream("employee.dat");
DataInputStream din = new DataInputStream(fin);
double s = din.readDouble();

DataInputStream din = new DataInputStream(
    new BufferedInputStream(
        new FileInputStream("employee.dat")));

ZipInputStream zin = new ZipInputStream(new FileInputStream("employee.zip"));
DataInputStream din = new DataInputStream(zin);

FileInputStream(String name)
FileInputStream(File file)  //使用由name字符串或file对象指定路径名的文件创建一个新的文件输入流

FileOutputStream(String name)
FileOutputStream(String name, boolean append)
FileOutputStream(File file)
FileOutputStream(File file, boolean append) //使用由name字符串或file对象指定路径名的文件创建一个新的文件输出流

BufferedInputStream(InputStream in)  //创建一个带缓冲区的流

BufferedOutputStream(OutputStream out)  //创建一个带缓冲区的流

PushbackInputStream(InputStream in)
PushbackInputStream(InputStream in, int size)  //构建一个可以预览一个字节或者具有指定尺寸的回推缓冲区的流
void unread(int b)  //回推一个字节，它可以在下次调用read时被再次获取，b:要再次读入的字节

InputStreamReader in = new InputStreamReader(new FileInputStream("input.txt"), "ISO8859_5");
等价于
FileReader in = new FileReader("input.txt"):

PrintWriter out = new PrintWriter("employee.txt"):
等同于
PrintWriter out = new PrintWriter(new FileWriter("employee.txt"));

PrintWriter(Writer out)
PrintWriter(Writer out, boolean autoFlush)  //创建一个新的PrintWriter
PrintWriter(OutputStream out)
PrintWriter(OutputStream out, boolean autoflush) //通过创建必需的中介OutputStreamWriter，从已有的OutputStream中创建一个新的PrintWriter
PrintWriter(String filename)
PrintWriter(File file)  //通过创建必需的中介FileWriter，创建一个想给定的文件写出的新的PrintWriter
void print(Object obj)  //通过打印从toString产生的字符串来打印一个对象
void print(String s)  //打印一个Unicode字符串
void println(String s)  //打印一个字符串，后面紧跟一个行终止符
void print(char[] s)  //打印给定的字符串中的所有Unicode字符
void print(char c)  //打印一个Unicode字符
void print(int i)
void print(long l)
void print(float f)
void print(double d)
void print(boolean b)  //以文本格式打印给定的值
void printf(String format, Object... args)  //按照格式化字符串指定的方式打印给定的值
boolean checkError()  //如果产生格式化或输出错误，返回true

BufferedReader in = new BufferedReader(new FileReader("employee.txt"));

//编码Unicode字符串
Charset cset = Charset.forName("ISO-8859-1"):
String str = ...;
ByteBuffer buffer = cset.encode(str);
byte[] bytes = buffer.array();
//解码字节序列
byte[] bytes = ...;
ByteBuffer bbuf = ByteBuffer.wrap(bytes, offset, length);
CharBuffer cbuf = cset.decode(bbuf);
String str = cbuf.toString();

static SortedMap availableCharsets()  //获取这个虚拟机可用的所有字符集。返回一个映射表，它的键是字符集的名字，值是字符集
static Charset forName(String name)  //获取给定名字的字符集
Set aliases()  //返回这个字符集的别名集
ByteBuffer encode(String str)  //将给定的字符串编码为字节序列
CharBuffer decode(ByteBuffer buffer)  //解码给定的字节序列，无法识别的输入将被转换成Unicode的“替代字符”（’\uFFFD‘)

byte[] array()  //返回这个缓冲区所管理的字节数组
static ByteBuffer wrap(byte[] bytes)
static ByteBuffer wrap(byte[] bytes, int offset, int length)  //返回管理给定的字节数组或给定字节数组的某个范围的字节缓冲区

char[] array()  //返回这个缓冲区所管理的码元数组
char charAt(int index)  //返回给定索引处的码元
String toString()  //返回由这个缓冲区所管理的码元构成的字符串

boolean readBoolean()
byte readByte()
char readChar()
double readDouble()
float readFloat()
int readInt()
long readLong()
short readShort()  //读入一个给定类型的值
void readFully(byte[] b)  //将字节读入到数组b中，其间阻塞直至所有字节都读入
void readFully(byte[] b, int off, int len)  //将字节读入到数组b中，其间阻塞直至所有字节都读入
String readUTF() //读入由“修订过的UTF-8”格式的字符构成的字符串
int skipBytes(int n)  //跳过n个字节，其间阻塞直至所有字节都被跳过

void writeBoolean(boolean b)
void writeByte(int b)
void writeChar(int c)
void writeDouble(double d)
void writeFloat(float f)
void writeInt(int i)
void writeLong(long l)
void writeShort(int s)  //写出一个给定类型的值
void writeChars(String s)  //写出字符串中的所有字符
void writeUTF(String s)  //写出由“修订过的UTF-8”格式的字符构成的字符串

RandomAccessFile(String file, String mode)
RandomAccessFile(File file, String mode)  //file:要打开的文件，mode:"r"表示只读模式，"rw"表示读/写模式
long getFilePointer()  //返回文件指针的当前位置
void seek(long pos)  //将文件指针从文件的开始设置到pos个字节处
long length()  //返回文件按照字节来度量的长度

ZipInputStream zin = new ZipInputStream(new FileInputStream(zipname));
ZipEntry entry;
while ((entry = zin.getNextEntry()) != null)
{
    analyze entry;
    read the contents of zin;
    zin.closeEntry();
}
zin.close();

FileOutputStream fout = new FileOutputStream("test.zip");
ZipOutputStream zout = new ZipOutputStream(fout);
for all files
{
    ZipEntry ze = new ZipEntry(filename);
    zout.putNextEntry(ze);
    send data to zout;
    zout.closeEntry();
}
zout.close();

ZipInputStream(InputStream in)  //创建一个ZipInputStream
ZipEntry getNextEntry()  //为下一项返回ZipEntry对象，否则没有更多的项时返回null
void closeEntry()  //关闭这个ZIP文件中当前打开的项

ZipOutputStream(OutputStream out)  //创建一个将压缩数据写出到指定的OutputStream的ZipOutputStream
void putNextEntry(ZipEntry ze)  //将给定的ZipEntry中的信息写出到流中，并定为用于写出数据的流，然后这些数据可以通过write()写出到这个流中
void closeEntry()  //关闭这个ZIP文件中当前打开的项
void setLevel(int level)  //设置后续的各个DEFAULTED项的默认压缩级别。
void setMethod(int method)  //设置用于这个ZipOutputStream的默认压缩方法，压缩方法：DEFLATED或STORED

ZipEntry(String name)  //这一项的名字
long getCrc()  //返回用于这个ZipEntry的CRC32校验和的值
String getName()  //返回这一项的名字
long getSize()  //返回这一项不被压缩的大小
boolean isDirectory()  //当这一项是目录时返回true
void setSize(long size)  //设置这一项的大小，当压缩方法是STORED时才必需
void setCrc(long crc)  //给这一项设置CRC32校验和，这个校验和是使用CRC32类计算的，STORED时必需

ZipFile(String name)
ZipFile(File file)  //创建一个ZipFile，用于从给定的字符串或File对象中读入数据
Enumeration entries()  //返回一个Enumeration对象，它枚举了描述这个ZipFile中各个项的ZipEntry对象
ZipEntry getEntry(String name)  //返回给定名字所对应的项，或者在没有对应项的时候返回null
InputStream getInputStream(ZipEntry ze)  //返回用于给定项的InputStream
String getName()  //返回这个ZIP文件的路径

ObjectOutputStream(OutputStream out)  //创建一个ObjectOutputStream使得你可以将对象写出到指定的OutputStream
void writeObject(Object obj)  //写出指定的对象到ObjectOutputStream，这个方法将存储指定对象的类、类的签名以及这个类及其超类中所有非静态和非瞬时的域的值

ObjectInputStream(InputStream in)  //创建一个ObjectInputStream用于从指定的InputSream中读回对象信息
Object readObject()  //从ObjectInputStream中读入一个对象

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;
private void writeObject(ObjectOutputStream out) throws IOException;

public void readExternal(ObjectInputStream in) throws IOException, ClassNotFoundException;
public void writeExternal(ObjectOutputStream out) throws IOException;

boolean canRead()
boolean canWrite()
boolean canExecute()  //表明文件是否可读、可写或可执行
boolean setReadable(boolean state, boolean ownerOnly)
boolean setWritable(boolean state, boolean ownerOnly)
boolean setExecutable(boolean state, boolean ownerOnly)  //设置这个文件的可读、可写或可执行状态。如果ownerOnly为true，状态设置只对文件拥有者有效，否则，对所有人有效。这些方法在设置状态成功后返回true
static boolean createTempFile(String prefix, String suffix)
static boolean createTempFile(String prefix, String suffix, File directory)  //在系统的默认临时目录或给定目录中创建一个临时文件，并使用给定的前缀或后缀来生成文件名
boolean delete()  //尝试删除这个文件
void deleteOnExit()  //请求在虚拟机关闭时将文件删除
boolean exists()  //如果目录存在则返回true
String getAbsolutePath()  //返回包含绝对路径名的字符串，应该用getCanonicalPath代替它
File getCanonicalFile()  //返回包含这个文件的规范路径名的File对象
String getCanonicalPath()  //返回包含这个文件的规范路径名的字符串
String getName()  //返回包含这个File对象的文件名的字符串（不包含路径）
String getParent()  //返回这个File对象的父亲名字的字符串
File getParentFile()  //返回这个File目录的父目录的File对象
String getPath()  //返回包含这个文件的路径名的字符串
boolean isDirectory()  //如果这个File对象表示一个文件而不是一个目录或一个设备，则返回true
boolean isFile()  //如果这个File对象表示一个文件而不是一个目录或一个设备，则返回true
boolean isHidden()  //如果这个File对象表示的是一个隐藏文件或目录，则返回true
long lastModified()  //返回这个文件最后被修改的时间（毫秒数）
String[] list()
String[] list(FilenameFilter filter)  //返回由这个File对象包含的满足过滤器条件的文件名和目录名构成的字符串数组
File[] listFiles()  
File[] listFiles(FilenameFilter filter)  //返回由这个File对象包含的文件和目录所对应的File对象构成的数组
static File[] listRoots()  //返回由所有可获得的文件根对应的File对象构成的数组
boolean createNewFile()  //自动创建一个由File对象给定名字的新文件
boolean mkdir()  //创建一个由这个File对象给定名字的子目录
boolean mkdirs()  //与mkdir不同，这个方法在必要时将创建父目录
boolean renameTo(File newName)  //如果文件名被修改，则返回true
boolean setLastModified(long time)  //设置这个文件的最后修改时间
boolean setReadOnly()  //将这个文件设置成只读
URL toURL()  //将这个File对象转换成一个文件的URL
long getTotalSpace()
long getFreeSpace()
long getUsableSpace()  //获得由File对象所描述的分区的总大小、未分配字节的数量和可用字节的数量

boolean accept(File dir, String name)  //应该定义为在文件能够匹配过滤器标准时返回true

FileChannel getChannel()  //返回用于访问这个流的通道

FileChannel getChannel()  //返回用于访问这个流的通道

FileChannel getChannel()  //返回用于访问这个流的通道

MappedByteBuffer map(FileChannel.MapMode mode, long position, long size)  //将文件的一个区域映射到内存中

boolean hasRemaining()  //如果当前的缓冲区位置没有达到这个缓冲区的界限位置则返回true
int limit()  //返回这个缓冲区的界限位置

byte get()  //从当前位置获得一个字节，并将当前位置推到下一个字节
byte get(int index)  //从指定索引处获得一个字节
ByteBuffer put(byte b)  //向当前位置推入一个字节，并将当前位置推到下一个字节，返回对这个缓冲区的引用
ByteBuffer put(int index, byte b)  //向指定索引处推入一个字节，返回对这个缓冲区的引用
ByteBuffer get(byte[] destination)
ByteBuffer get(byte[] destination, int offset, int length)  //用缓冲区的字节来填充字节数组，或者字节数组的某个区域，并将当前位置向前推读入的字节数个位置，如果缓冲区不够，不会读入任何字节，并抛出BufferUnderflowException
ByteBuffer put(byte[] source)
ByteBuffer put(byte[] source, int offset, int length)  //将字节数组中的所有字节或者给定区域的字节都推入缓冲区，并将当前位置向前推写出的字节数个位置
Xxx getXxx()
Xxx getXxx(int index)
ByteBuffer putXxx(xxx value)
ByteBuffer putXxx(int index, xxx value)  //获得或放置一个二进制数
ByteBuffer order(ByteOrder order)
ByteOrder order()  //设置或获得字节顺序，order的值是ByteOrder类的常量BIG_ENDIAN或LITTLE_ENDIAN中的一个

Buffer clear()  //通过将位置复位到0，并将界限复位到容量，使这个缓冲区为写出做好准备。返回this
Buffer flip()  //通过将界限设置为位置，并将位置复位到0，使这个缓冲区为读入做好准备，返回this
Buffer rewind()  //通过将读写位置复位到0，并保持极限不变，使这个缓冲区为重新读入相同的值做好准备，返回this
Buffer mark()  //将这个缓冲区的标记设置到读写位置，返回this
Buffer reset()  //将这个缓冲区的位置设置到标记，从而允许被标记的部分可以再次被读入或写出，返回this
int remaining()  //返回剩余可读入或可写出的值的数量，即界限与位置之间的差异
int position()  //返回这个缓冲区的位置
int capacity()  //返回这个缓冲区的容量

char get()
CharBuffer get(char[] destination)
CharBuffer get(char[] destination, int offset, int length)  //从这个缓冲区的位置处开始，获得一个char值，或者某个范围的char值，然后将位置向前推过所读入的字符，最后两个方法返回this
CharBuffer put(char c)
CharBuffer put(char[] source)
CharBuffer put(char[] source, int offset, int length)
CharBuffer put(String source)
CharBuffer put(CharBuffer source)  //从这个缓冲区的位置处开始，推入一个char值，或者某个范围的char值，然后将位置向前推过所写出的字符
CharBuffer read(CharBuffer destination)  //从这个缓冲区中获得char值，然后将它们推入目标缓冲区，直至达到目标缓冲区的界限

FileLock lock()  //在整个文件上获得一个独占的锁，这个方法将阻塞直至获得锁
FileLock tryLock()  //在整个文件上获得一个独占的锁，或者在无法获得锁的情况下返回null
FileLock lock(long position, long size, boolean shared)
FileLock tryLock(long position, long size, boolean shared)  //在文件的一个区域上获得锁

void release()  //释放这个锁

String patternString = "<a\\s+href\\s*=\\s*(\"[^\"]*\"|[^\\s>]*)\\s*>"

Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(input);
if (matcher.matches()) ...

static Pattern compile(String expression)
static Pattern compile(String expression, int flags)  //把正则表达式字符串编译到一个用于快速处理匹配的模式对象中
Matcher matcher(CharSequence input)  //返回一个matcher对象，可以用它在输入定位模式的匹配
String[] split(CharSequence input)
String[] split(CharSequence input, int limit)  //将输入分割成标号，其中模式指定了分隔符的形式

boolean matches()  //如果输入匹配模式，则返回true
boolean lookingAt()  //如果输入的开头匹配模式，则返回true
boolean find()
boolean find(int start)  //尝试查找下一个匹配，找到返回true
int start()
int end()  //返回当前匹配的开始索引和结尾之后的索引
String group()  //返回当前的匹配
int groupCount()  //返回输入模式中的群组数量
int start(int groupIndex)
int end(int groupIndex)  //返回当前匹配中给定群组的开始和结尾之后的位置
String group(int groupIndex)  //返回匹配给定群组的字符串
String replaceAll(String replacement)
String replaceFirst(String replacement)  //返回从匹配器输入获得的通过将所有匹配或第一个匹配用替换字符串替换之后的字符串
Matcher reset()
Matcher reset(CharSequence input)  //复位匹配器的状态。第二个方法将使匹配器作用于另一个不同的输入，两个方法都返回this

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http:java.sun.com/j2ee/dtds/web-app_2_2.dtd">

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
File f = ...
Document doc = builder.parse(f);

static DocumentBuilderFactory newInstance()  //返回DocumentBuilderFactory类的一个实例
DocumentBuilder newDocumentBuilder()  //返回DocumentBuilder类的一个实例

Document parse(File f)
Document parse(String url)
Document parse(InputStream in)  //解析来自给定文件、URL或输入流的XML文档，返回解析后的文档

Element getDocumentElement()  //返回文档的根元素

String getTagName()  //返回元素的名字
String getAttribute(String name)  //返回给定名字的属性值，没有该属性时返回空字符串

NodeList getChildNodes()  //返回包含所有子元素节点的节点列表
Node getFirstChild()
Node getLastChild()  //获取该节点的第一个或最后一个子节点，在该节点没有子节点时返回null
Node getNextSibling()
Node getPreviousSibling()  //获取该节点的下一个或上一个兄弟节点，在该节点没有兄弟节点时返回null
Node getParentNode()  //获取该节点的父结点，在该节点是文档节点时返回null
NamedNodeMap getAttributes()  //返回含有描述该节点所有属性的Attr节点的映射表
String getNodeName()  //返回该节点的名字，当该结点是Attr节点时，该名字就是属性名
String getNodeValue()  //返回该节点的值，当该节点是Attr节点时，该值就是属性值

String getData()  //返回存储在节点中的文本

int getLength()  //返回列表中的节点数
Node item(int index)  //返回给定索引号的节点

int getLength()  //返回该节点映射表中的节点数
Node item(int index)  //返回给定索引号的节点

<!ELEMENT font (name,size)>

<xsd:element name="font">
    <xsd:sequence>
        <xsd:element name="name" type="xsd:string" />
        <xsd:element name="size" type="xsd:int" />
    </xsd:sequence>
</xsd:element>

<?xml version="1.0"?>
<!DOCTYPE configuration [
    <!ELEMENT configuration ...>
    more rules
    ...
]>
<configuration>
...
</configuration>

<!DOCTYPE configuration SYSTEM "config.dtd">
或者
<!DOCTYPE configuration SYSTEM "http://myserver.com/config.dtd">

<!DOCTYPE web-app
  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

factory.setValidating(true);
factory.setIgnoringElementContentWhitespace(true);

void setEntityResolver(EntityResolver resolver)  //设置解析器，来定位要分析的XML文档中引用的实体
void setErrorHandler(ErrorHandler handler)  //设置报告解析过程中出现的错误和警告的处理器

public InputSource resolveEntity(String publicID, String systemID)  //返回包含被指定ID引用数据的一个输入源，或者，当解析器不知道如何解析某个特定名字时，返回null。如果没有提供公共ID，那么参数publicID可以为null

InputSource(InputStream in)
InputSource(Reader in)
InputSource(String systemID)  //根据流、读入器、或系统ID（通常是相对或绝对URL）构建输入源

void fatalError(SAXParseException exception)
void error(SAXParseException exception)
void warning(SAXParseException exception)  //覆盖这些方法以提供处理器，对致命错误、非致命错误和警告进行处理

int getLineNumber()
int getColumnNumber()  //返回引起异常的已处理的输入信息末尾的行号和列号

boolean isValidating()
void setValidating(boolean value)  //获取和设置工厂的validating属性，当设为true时，工厂生成的解析器会验证它们的输入信息
boolean isIgnoringElementContentWhiteSpace(boolean value)  //获取和设置工厂的ignoringElementContentWhiteSpace属性，当设为true时，工厂生成的解析器会忽略没有混合内容（即元素与#PCDATA混合）的元素节点之间的空白

<?xml version="1.0"?>
<configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="config.xsd">
...
</configuration>

//必须打开对命名空间的支持
factory.setNamespaceAware(true);
//必须执行如下步骤
final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";
factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

static XPathFactory newInstance()  //返回XPathFactory实例来创建XPath对象
XPath newXpath()  //构建XPath对象来计算XPath表达式

String evaluate(String expression, Object startingPoint)  /从给定的起点计算表达式，起点可以是一个节点或节点列表，如果结果是一个节点或节点集，则返回的字符串包含所有文本节点子元素的数据
Object evaluate(String expression, Object startingPoint, QName resultType)  //从给定的起点计算表达式，起点可以是一个节点或节点列表。ResultType是XPathConstants类的常量STRING, NODE, NODESET, NUMBER或BOOLEAN之一

factory.setNamespaceAware(true);

String getLocalName()  //返回本地名（不带别名前缀），或者在解析器不支持命名空间时返回null
String getNamespaceURI()  //返回命名空间URI，或者在解析器不支持命名空间时返回null

boolean isNamespaceAware()
void setNamespaceAware(boolean value)  //获取或设置工厂的namespaceAware属性

SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
parser.parse(source, handler);

static SAXParserFactory newInstance()  //返回SAXParserFactory类的一个实例
SAXParser newSAXParser()  //返回SAXParser类的一个实例
boolean isNamespaceAware()
void setNamespaceAware(boolean value)  //获取和设置工厂的namespaceAware属性
boolean isValidating()
void setValidating(boolean value)  //获取和设置工厂的validating属性

void parse(File f, DefaultHandler handler)
void parse(String url, DefaultHandler handler)
void parse(InputStream in, DefaultHandler handler)  //解析来自给定文件、URL或输入流的XML文档，并把解析事件报告给指定的处理器

void startDocument()
void endDocument()
void startElement(String uri, String lname, String qname, Attributes attr)
void endElement(String uri, String lname, String qname)  //在元素的起始或结束时被调用
void characters(char[] data, int start, int length)  //解析器报告字符数据时被调用

int getLength()  //返回存储在该属性集合中属性数量
String getLocalName(int index)  //返回给定索引的属性的本地名（无别名前缀），或当不支持命名空间特性时返回空字符串
String getURI(int index)  //返回给定索引的属性的命名空间URI
String getQName(int index)  //返回给定索引的属性的限定名
String getValue(int index)
String getValue(String qname)
String getValue(String uri, String lname)  //根据给定索引、限定名或命名空间URI+本地名，返回属性值，该值不存在时返回null

InputStream in = url.openStream();
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader parser = factory.createXMLStreamReader(in);
while (parser.hasNext()) {
    int event = parser.next();
    Call parser methods to obtain event details
}

static XMLInputFactory newInstance()  //返回XMLInputFactory类的一个实例
void setProperty(String name, Object value)  //设置这个工厂的属性，或者在要设置的属性不支持设置成给定值时，抛出IllegalArgumentException
XMLStreamReader createXMLStreamReader(InputStream in)
XMLStreamReader createXMLStreamReader(InputStream in, String characterEncoding)
XMLStreamReader createXMLStreamReader(Reader in)
XMLStreamReader createXMLStreamReader(Source in) //创建一个从给定的流、阅读器或JAXP源读入的解析器

boolean hasNext()  //如果有另一个解析事件则返回true
int next()  //将解析器的状态设置为下一个解析事件，并返回下列常量之一：START_ELEMENT、CHARACTERS、START_DOCUMENT、END_DOCUMENT、CDATA、COMMENT、SPACE（可忽略的空白字符）、PROCESSING_INSTRUCTION、ENTITY_REFERENCE、DTD
boolean isStartElement()
boolean isEndElement()
boolean isCharacters()
boolean isWhiteSpace()  //如果当前事件是一个开始元素、结束元素、字符数据或空白字符，返回true
QName getName()
String getLocalName()  //获取在START_ELEMENT或END_ELEMENT事件中的元素的名字
String getText()  //返回一个CHARACTERS、COMMENT或CDATA事件，或一个ENTITY_REFERENCE的替换值，或者一个DTD的内部子集所对应的字符
int getAttributeCount()
QName getAttributeName(int index)
String getAttributeLocalName(int index)
String getAttributeValue(int index)
String getAttributeValue(String namespaceURI, String name)  //只要当前事件是START_ELEMENT，则获取给定属性的值，如果namespaceURI为null，则不检查名字空间

Document doc = builder.newDocument();
Element rootElement = doc.createElement(rootName);
Element childElement = doc.createElement(childName);
Text textNode = doc.createTextNode(textContents);
doc.appendChild(rootElement);
rootElement.appendChild(childElement);
childElement.appendChild(textNode);
rootElement.setAttribute(name, value);

//construct the "do nothing" transformation
Transformer t = TransformerFactory.newInstance().newTransformer();
//set output properties to get a DOCTYPE node
t.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, systemIdentifier);
t.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, publicIdentifier);
//set indentation
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.setOutputProperty(OutputKeys.METHOD, "xml");
//apply the "do nothing" transformation and send the output to a file
t.transform(new DOMSource(doc), new StreamResult(new FileOutputStream(file)));

Document newDocument()  //返回一个空文档

Element createElement(String name)  //返回具有给定名字的元素
Text createTextNode(String data)  //返回具有给定数据的文本节点

Node appendChild(Node child)  //将一个节点附加到该节点的子节点列表，返回该节点

void setAttribute(String name, String value)  //将有给定名字的属性设置为指定的值
void setAttributeNS(String uri, String qname, String value)  //将带有给定命名空间URI和限定名的属性设置为指定的值

static TransformerFactory newInstance()  //返回TransformerFactory类的一个实例
transformer newTransformer()  //返回Transformer类的一个实例，带有标识符或“无操作”的转换

void setOutputProperty(String name, String value)  //设置输出属性
void transform(Source from, Result to)  //转换一个XML文档

DOMSource(Node n)  //根据指定的节点构建一个源。通常，n是文档节点

StreamResult(File f)
StreamResult(OutputStream out)
StreamResult(Writer out)
StreamResult(String systemID)根据文件、流、写入程序或系统ID（通常是相对或绝对URL）来构建数据流结果

XMLOutputFactory factory = XMLOutputFactory.newInstance();
XMLStreamWriter writer = factory.createXMLStreamWriter(out);
writer.writeStartDocument();
writer.writeStartElement(name);
writer.writeAttribute(name, value);
writer.writeCharacters(text);
writer.writeEndElement();
writer.writeEmptyElement(name);
writer.writeEndDocument();

static XMLOutputFactory newInstance()  //返回这个XMLOutputFactory类的一个实例
XMLStreamWriter createXMLStreamWriter(OutputStream in)
XMLStreamWriter createXMLStreamWriter(OutputStream in, String characterEncoding)
XMLStreamWriter createXMLStreamWriter(Writer in)
XMLStreamWriter createXMLStreamWriter(Result in)  //创建写入给定流、写出器和JAXP结果的写出器

void writeStartDocument()
void writeStartDocument(String xmlVersion)
void writeStartDocument(String encoding, String xmlVersion)  //在文档的顶部写入XML处理指令
void setDefaultNamespace(String namespaceURI)
void setPrefix(String prefix, String namespaceURI)
设置默认的命名空间，或具有前缀的命名空间，作用域仅为当前元素
void writeStartElement(String localName)
void writeStartElement(String namespaceURI, String localName)  //写出一个开始标签，其中namespaceURI将用相关联的前缀来代替
void writeEndElement()  //关闭当前元素
void writeEndDocument()  //关闭所有打开的元素
void writeEmptyElement(String localName)
void writeEmptyElement(String namespaceURI, String localName)  //写出一个自闭合的标签
void writeAttribute(String localName, String value)
void writeAttribute(String namespaceURI, String localName, String value)  //写出一个用于当前元素的属性
void writeCharacters(String text)  //写出字符数据
void writeCData(String text)  //写出CDATA块
void writeDTD(String dtd)  //写出dtd字符串，该字串需要包含一个DOCTYPE声明
void writeComment(String comment)  //写出一个注释
void close()  //关闭这个写出器

<xsl:template match="/staff/employee">
  <tr><xsl:apply-templates/></tr>
</xsl:template>

<xsl:template match="/staff/employee/hiredate">
  <td><xsl:value-of select="@year"/>-<xsl:value-of select="@month"/>-<xsl:value-of select="@day"/></td>
</xsl:template>

File styleSheet = new File(filename);
StreamSource styleSource = new StreamSource(styleSheet);
Transformer t = TransformerFactory.newInstance().newTransformer(styleSource);
t.transform(source, result);

transformer newTransformer(Source stylesheet)  //返回一个transformer类的实例，用来从指定的源中读取样式表

StreamSource(File f)
StreamSource(InputStream in)
StreamSource(Reader in)
StreamSource(String stystemID)  //根据一个文件、流、阅读器或系统ID（通常是相对或绝对URL）来构建一个数据流源

SAXSource(XMLReader reader, InputSource source)  //构建一个SAX数据源，以便从给定输入源获取数据，并使用给定的阅读器来解析输入数据

void setContentHandler(ContentHandler handler)  //设置在输入被解析时会被告知解析事件的处理器
void parse(InputSource source)  //根据给定输入源解析输入数据，并将解析事件发送到内容处理器

DOMResult(Node n)  //根据给定结点构建一个数据源，通常n是一个新文档节点

void addAtrribute(String uri, String lname, String qname, String type, String value)  //将一个属性添加到该属性集合
void clear()  //删除属性集合中的所有属性

Socket(String host, int port)  //构建一个套接字，用来连接给定的主机和端口
InputStream getInputStream()
OutputStream getOutputStream()  //获取可以从套接字中读取数据的流，以及可以向套接字写出数据的流
Socket()  //创建一个还未被连接的套接字
void connect(SocketAddress address) //将该套接字连接到给定的地址
void connect(SocketAddress address, int timeoutInMilliSeconds)  //将套接字连接到给定的地址，如果在给定的时间内没有响应，则返回
void setSoTimeout(int timeoutInMilliseconds)  //设置该套接字上读请求的阻塞时间，如果超出时间，则抛出一个InterruptedIOException异常
boolean isConnected()  //如果该套接字已被连接，则返回true
boolean isClosed()  //如果该套接字已被关闭，返回true

InetAddress address = InetAddress.getByName("time-A.timefreq.bldrdoc.gov");
byte[] addressBytes = address.getAddress();

static InetAddress getByName(String host)
static InetAddress[] getAllByName(String host)  //为给定的主机名，创建一个InetAddress对象，或者一个包含了该主机名所对应的所有因特网地址的数组
static InetAddress getLocalHost()  //为本地主机创建一个InetAddress对象
byte[] getAddress()  //返回一个包含数字型地址的字节数组
String getHostAddress()  //返回一个由十进制数组成的字符串，各数字间用圆点符号隔开
String getHostName()  //返回主机名

ServerSocket s = new ServerSocket(8189);
Socket incoming = s.accept();
InputStream inStream = incoming.getInputStream();
OutputStream outStream = incoming.getOutputStream();
Scanner in = new Scanner(inStream);
PrintWriter out = new PrintWriter(outStream, true /* autoFlush */);
out.println("Hello!Enter BYE to exit.“);
String line = in.nextLine();
out.println("Echo:" + line);
if (line.trim().equals("BYE")) done = true;
incoming.close();

ServerSocket(int port)  //创建一个监控端口的服务器套接字
Socket accept()  //等待连接，阻塞当前线程直到建立连接为止
void close()  //关闭服务器套接字

while (true) {
    Socket incoming = s.accept();
    Runnable r = new ThreadedEchoHandler(incoming);
    Thread t = new Thread(r);
    t.start();
}

void shutdownOutput()  //将输出流设为“流结束”
void shutdownInput()  //将输入流设为“流结束”
boolean isOutputShutdown()  //如果输出已被关闭返回true
boolean isInputShutdown()  //如果输入已被关闭，返回true

SocketChannel channel = SocketChannel.open(new InetSocketAddress(host, port));
Scanner in = new Scanner(channel);
OutputStream outStream = Channels.newOutputStream(channel);

InetSocketAddress(String hostname, int port)  //通过主机和端口参数创建一个地址对象，并在创建过程中解析主机名，如果主机名不能被解析，那么该地址对象的unresolved属性被设为true
boolean isUnresolved()  //如果不能解析该地址对象，返回true

static SocketChannel open(SocketAddress address)  //打开一个套接字通道，并将其连接到远程地址

static InputStream newInputStream(ReadableByteChannel channel)  //创建一个输入流，用以从指定的通道读取数据
static OutputStream newOutputStream(WritableByteChannel channel)  //创建一个输出流，用以向指定的通道写入数据

Socket s = new Socket("mail.yourserver.com", 25);
PrintWriter out = new PrintWriter(s.getOutputStream));

URL url = new URL(urlString);
InputStream inStream = url.openStream();
Scanner in = new Scanner(inStream);

relative = base.relativize(combined);
combined = base.resolve(relative);

URLConnection connection = url.openConnection()

setDoInput
setDoOutput
setIfModifiedSince
setUseCaches
setAllowUserInteraction
setRequestProperty
setConnectTimeout
setReadTimeout

connection.connect();

getContentType
getContentLength
getContentEncoding
getDate
getExpiration
getLastModified

getInputStream

String input = username + ":" + password;
String encoding = base64Encode(input);
connection.setRequestProperty("Authorization", "Basic " + encoding);

InputStream openStream()  //打开一个用于读取资源数据的输入流
URLConnection openConnection()  //返回一个URLConnection对象，该对象负责管理与资源之间的连接

void setDoInput()  //如果doInput为true，那么用户可以接收来自该URLConnection的输入
void setDoOutput(boolean doOutput)
boolean getDoOutput(boolean doOutput)  //如果doOutput为true，那么用户可以将输出发送到该URLConnection
void setIfModifiedSince(long time)
long getIfModifiedSince()  //属性ifModifiedSince用于配置URLConnection对象，使它只获取那些自从某个给定时间以来被修改过的数据
void setUseCaches(boolean useCaches)
boolean getUseCaches()  //如果useCaches为true，那么数据可以从本地缓存中得到，URLConnection本身并不维护这个缓存，缓存必须由浏览器之类的外部程序提供
void setAllowUserInteraction(boolean allowUserInteraction)
boolean getAllowUserInteraction()  //如果为true，那么可以查询用户的口令
void setConnectTimeout(int timeout)
int getConnectionTimeout()  //设置或得到连接超时时限
void setRequestProperty(String key, String value)  //设置请求头的一个字段
Map<String, List<String>> getRequestProperties()  //返回请求头属性的一个映射表，相同的键对应的所有值被放置在同一个映射表中
void connect()  //连接远程资源并获取响应头信息
Map<String, List<String>> Map getHeaderFields()  //返回响应的一个映射表，相同的键对应的所有值被放置在同一个映射表中
String getHeaderFieldKey(int n)  //得到响应头第n个字段的键，如果n等于0或大于响应头字段的总数返回null值
String getHeaderField(int n)  //得到响应头第n个字段的值
int getContentLength()  //如果知道内容长度，则返回该长度值，否则返回-1
String getContentType()  //获取内容的类型，比如text/plain或image/gif
String getContentEncoding()  //获取内容的编码，比如gzip
long getDate()
long getExpiration()
long getLastModified()  //获取创建日期、过期日以及最后一次被修改的日期
InputStream getInputStream()
OutputStream getOutputStream()  //返回从资源读取信息或向资源写入信息的流
Object getContent()  //选择适当的内容处理器，以便读取资源数据并将它转换成对象。该方法不能用于读取诸如text/plain或image/gif之类的标准内容类型，除非安装了自己的内容处理器

URL url = new URL("http://host/script");
URLConnection connection = url.openConnection();
connection.setDoOutput(true);
PrintWriter out = new PrintWriter(connection.getOutputStream());
out.print(name1 + "=" + URLEncoder.encode(value1, "UTF-8") + "&");
out.print(name2 + "=" + URLEncoder.encode(value2, "UTF-8"));
out.close();

InputStream getErrorStream()  //返回一个流，通过这个流可以读取Web服务器的错误信息

static String encode(String s, String encoding)  //采用指定的字符编码模式对字符串s进行编码，并返回它的URL编码形式

static String decode(String s, String encoding)  //采用指定编码模式对已编码字符串s进行解码，并返回结果

String url = "jdbc:postgresql:COREJAVA";
String username = "dbuser";
String password = "scret";
Connection conn = DriverManager.getConnection(url, username, password);

static Connection getConnection(String url, String user, String password)  //建立一个到指定数据库的连接，并返回一个Connection对象

Statement createStatement()  //创建一个Statement对象，用以执行不带参数的SQL查询和更新
void close()  //用于立即关闭当前的连接以及释放由它所创建的JDBC资源

ResultSet executeQuery(String sqlQuery)  //执行给定字符串中的SQL语句，并返回一个用于查看查询结果的ResultSet对象
int executeUpdate(String sqlStatement)  //执行字符串中指定的INSERT、UPDATE或DELETE等SQL语句，也可以执行CREATE TABLE等语句，返回受影响的记录总数
boolean execute(String sqlStatement)  //执行字符串中指定的SQL语句，可能会产生多个结果集和更新数。如果第一个执行结果是结果集，则返回true，反之返回false。调用getResultSet或getUpdateCount方法可以得到第一个执行结果
ResultSet getResultSet()  //返回前一条查询语句的结果集，如果前一条语句未产生结果集则返回null值，对于每一条执行过的语句，该方法只能被调用一次
void close()  //关闭Statement对象以及它所对应的结果集
boolean isClosed()  //如果语句被关闭返回true

boolean next()  //将结果集中的当前行向前移动一行。如果已经到达最后一行的后面，返回false，注意初始情况必须调用该方法才能转到第一行
Xxx getXxx(int columnNumber)
Xxx getXxx(String columnName)  //用给定的列序号或列标签返回该列的值，并将之转换成指定类型
int findColumn(String columnName)  //根据给定的列名，返回该列的序号
void close()  //立即关闭当前的结果集
boolean isClosed()  //如果语句被关闭，则返回true

SQLException getNextException()  //返回链接到该SQL异常的下一个SQL异常，或者在到达链尾时返回null
Iterator<Throwable> iterator()  //获取迭代器，可以迭代链接的SQL异常和它们的成因
String getSQLState()  //获取“SQL状态”，即标准化的错误代码
int getErrorCode()  //获取提供商相关的错误代码

SQLWarning getNextWarning()  //返回链接到该警告的下一个警告，或者在到达链尾时返回null

QLWarning getWarnings()
SQLWarning getWarnings() //返回未处理警告中的第一个，或者在没有未处理警告时返回null

boolean getParameter()  //如果在参数上进行了数据截断，则返回true，如果在列上进行了数据截断返回false
int getIndex()  //返回被截断的参数和列的索引
int getDataSize()  //返回应该被传输的字节数量，或者在该值未知的情况下返回-1
int getTransferSize()  //返回实际被传输的字节数量，或者在该值未知的情况下返回-1

ResultSet result = stat.getResultSet();
ResultSetMetaData metaData = result.getMetaData();
int columnCount = metaData.getColumnCount();
metaData.getColumnLabel(i);

PreparedStatement PublisherQueryStat = conn.prepareStatement(publisherQuery);
publisherQueryStat.setString(1, publisher);
ResultSet rs = publisherQueryStat.executeQuery();

PreparedStatement prepareStatement(String sql)  //返回一个含预编译语句的PreparedStatement对象

void setXxx(int n, Xxx x)  //设置第n个参数值为x
void clearParameters()  //清除预备语句中的所有当前参数
ResultSet executeQuery()  //执行预备SQL查询，并返回一个ResultSet对象
int executeUpdate()  //执行预备SQL语句INSERT UPDATE或DELETE，返回受影响的记录数，如果执行CREATE TABLE,返回0

PreparedStatement stat = conn.preapareStatement("SELECT Cover FROM BookCovers WHERE ISBN=?");
stat.set(1, isbn);
ResultSet result = stat.executeQuery();
if (result.next()) {
    Blob coverBlob = result.getBlob(1);
    Image coverImage = ImageIO.read(coverBlob.getInputstream());
}

Blob coverBlob = connection.createBlob();
int offset = 0;
OutputStream out = coverBlob.setBinaryStream(offset);
ImageIO.write(coverImage, "PNG", out);
PreparedStatement stat = conn.prepareStatement("INSET INTO Cover VALUES (?, ?)");
stat.set(1, isbn);
stat.set(2, coverBlob);
stat.executeUpdate();

Blob getBlob(int columnIndex)
Blob getBlob(String columnLabel)
Clob getClob(int columnIndex)
Clob getClob(String columnLabel)  //获取给定列的BLOB或CLOB

long length()  //获取该BLOB的长度
byte[] getBytes(long startPosition, long length)  //获取该BLOB中给定范围的数据
InputStream getBinaryStream()
InputStream getBinaryStream(long startPosition, long length)  //返回一个输入流，用于读取该BLOB中全部或给定范围的数据
OutputStream setBinaryStream(long startPosition)  //返回一个输出流，用于从给定位置开始写入该BLOB

long length()  //获取该CLOB中的字符总数
String getSubString(long startPosition, long length)  //获取该CLOB中给定范围的字符
Reader getCharacterStream()
Reader getCharacterStream(long startPosition, long length)  //返回一个读入器（而不是流），用于读取CLOB中全部或给定范围的数据
Writer setCharacterStream(long startPosition)  //返回一个写出器（而不是流），用于从给定位置开始写入该CLOB

Blob createBlob()
Clob createClob()  //创建一个空的BLOB或CLOB

boolean done = false;
boolean isResult = stmt.execute(command);
while (!done) {
    if (isResult) {
        ResultSet result = stmt.getResultSet();
        do something with result
    } else {
        int updateCount = stmt.getUpdateCount();
        if (updateCount >= 0)
            do something with updateCount
        else
            done = true;
    }
    isResult = stmt.getMoreResults();
}

boolean getMoreResults()  //获取该语句的下一个结果集，如果存在返回true

stmt.executeUpdate(insertStatement, Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys();
if (rs.next()) {
    int key = rs.getInt(1);
    ...
}

boolean execute(String statement, int autogenerated)
int executeUpdate(String statement, int autogenerated)  //如果autogenerated被设置为Statement.RETURN_GENERATED_KEYS，并且该语句是一条INSERT语句，那么第一列中就是自动生成的键

Statement stat = conn.createStatement(type, concurrency);
PreparedStatement stat = conn.prepareStatement(command, type, concurrency);

if (rs.previous()) ...

rs.relative(n);

rs.absolute(n);
int currentRow = rs.getRow();

Statement stat = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);

String query = "SELECT * FROM Books";
ResultSet rs = stat.executeQuery(query);
while (rs.next()) {
    if (...) {
        double increase = ...
        double price = rs.getDouble("Price");
        rs.updateDouble("Price", price + increase);
        rs.updateRow();
    }
}

rs.moveToInsertRow();
rs.updateString("Title", title);
rs.updateString("ISBN", isbn);
rs.updateString("Publisher_Id", pubid);
rs.updateDouble("Price", price);
rs.insertRow();
rs.moveToCurrentRow();

rs.deleteRow();

Statement createStatement(int type, int concurrency)
PreparedStatement prepareStatement(String command, int type, int concurrency)  //创建一个语句或预备语句，且该语句可以产生指定类型和并发模式的结果集

int getType()  //返回结果集的类型
int getConcurrency()  //返回结果集的并发设置
boolean previous()  //把光标移动到前一行
int getRow()  //得到当前行的序号
boolean absolute(int r)  //移动光标到第r行
boolean relative(int d)  //将光标移动d行，如果d为负数，则光标向后移动，如果光标位于某一行上，返回true
boolean first()
boolean last()  //移动光标到第一行或最后一行
void beforeFirst()
void afterLast()  //移动光标到第一行之前或最后一行之后的位置
boolean isFirst()
boolean isLast()  //测试光标是否在第一行或最后一行
boolean isBeforeFirst()
boolean isAfterLast()  //测试光标是否在第一行之前或最后一行之后的位置
void moveToInsertRow()  //移动光标到插入行
void moveToCurrentRow()  //将光标从插入行移回到调用moveToInsertRow之前所在那一行
void insertRow()  //将插入行上的内容插入到数据库和结果集中
void deleteRow()  //从数据库和结果集中删除当前行
void updateXxx(int column, Xxx data)
void updateXxx(String columnName, Xxx data)  //更新结果中当前行上的某个字段值
void updateRow()  //将当前行的更新信息发送到数据库
void cancelRowUpdates()  //撤销对当前行的更新