java 基础，基础...(二）
数组： 存在地址连续的内存空间，作为对象实现。
声明数组引用:int[] a; int a[]; (这里不能直接定义长度）
数组长度：a.length
二维数组 定义：int[][] a=new int[2][3];
不规则数组定义： int a[][] =new int[2][]; / int a[][]={{1,2,3},{1,2,3,4,5}};
a[0]=new int[4];
a[1]=new int[5];
声明数组引用:int[] a; int a[]; (这里不能直接定义长度）
数组长度：a.length
二维数组 定义：int[][] a=new int[2][3];
不规则数组定义： int a[][] =new int[2][]; / int a[][]={{1,2,3},{1,2,3,4,5}};
a[0]=new int[4];
a[1]=new int[5];
foreach语句:
int[][]a={...};
for(int[] i:a){
for(int j:i){}
int[][]a={...};
for(int[] i:a){
for(int j:i){}
}
四、Java API
基础类库（JFC，java Foundation class）,即API
将静态方法包装成类，直接调用。
语言包(java.lang) : 基本数据类型，数学函数，字符串处理，线程和异常处理 （默认导入）
实用程序包(java.util) :实用方法和数据结构。 如Date,Calendar,Random,堆栈，向量。
Object类： 所有类隐性继承Objexct类。
目的： 1.可声明Object类型的对象引用 指向任何类型的对象，如容器类。
2.定义一些方法，自动继承给所有类。
boolean equals(Object oth) 【对象引用是否相等】
String toString() 【将对象转换为字符串】
finalize() 【释放内存】
wait() 【线程等待】
notify() 【唤醒线程】
Object clone() 生成当前对象的备份并返回
int hashCode() 返回对象的散列代码值
Class getClass() 返回该对象所属的类
目的： 1.可声明Object类型的对象引用 指向任何类型的对象，如容器类。
2.定义一些方法，自动继承给所有类。
boolean equals(Object oth) 【对象引用是否相等】
String toString() 【将对象转换为字符串】
finalize() 【释放内存】
wait() 【线程等待】
notify() 【唤醒线程】
Object clone() 生成当前对象的备份并返回
int hashCode() 返回对象的散列代码值
Class getClass() 返回该对象所属的类
equals() 与 "=="的异同：
比较引用变量时，，quals()比较两个引用变量指向的对象的值； “==”比较该变量的值（存放了对象在内存中的首地址）
Integer obj1=new Integer(5); Integer obj2=new Integer(5) Integer obj3=obj2;
obj1.equals(obj2) true; "obj1==obj2" false; obj3.equals(obj2) true; obj2==obj3 true;
(Object类的equal()方法采用==比较，所以一个类没有重写equals()那equal()与==的结果相同）
比较引用变量时，，quals()比较两个引用变量指向的对象的值； “==”比较该变量的值（存放了对象在内存中的首地址）
Integer obj1=new Integer(5); Integer obj2=new Integer(5) Integer obj3=obj2;
obj1.equals(obj2) true; "obj1==obj2" false; obj3.equals(obj2) true; obj2==obj3 true;
(Object类的equal()方法采用==比较，所以一个类没有重写equals()那equal()与==的结果相同）
Arrays类 数组的操作类，提供用来操作数组的静态方法
int binarySearch(type[]a,type key) 二分查找key
equals(a[],b[])
deepEquals(a[],b[]) 多维数组
fill(a[],var a) a[]中全部赋值为a
sort(a[]) 非递减排序
sort(a[],int start,int end) start~end的元素非递减排序
toString(a[])
deepToString(a[][]) 多维数组
int[] copyOf(int[] original,int newLength) 数组复制
String类 一旦创建了String对象，其值不可改变，多用于表示字符串常量 null ，String , char[] , StringBuffer， String a="hello"
equals(String str)
indexOf(String str)
substring(int begin,int end)
String[] split(STring ch)
toCharArray()
String 类的+运算
String s1="java" ;String s2="java";String s3=new String("java");String s4=new STring("java");
s1==s2 true ; s1.equals(s2) true //堆中存放隐式对象（字符串常量）,,JVM在堆中建立字符串缓存池，s1定义时构造一个值为“Java”的对象，s2也指向该内存。
s3==s4 false; s3.equals(s4) true //s3,s4在堆中建立的对象地址不同。
equals(String str)
indexOf(String str)
substring(int begin,int end)
String[] split(STring ch)
toCharArray()
String 类的+运算
String s1="java" ;String s2="java";String s3=new String("java");String s4=new STring("java");
s1==s2 true ; s1.equals(s2) true //堆中存放隐式对象（字符串常量）,,JVM在堆中建立字符串缓存池，s1定义时构造一个值为“Java”的对象，s2也指向该内存。
s3==s4 false; s3.equals(s4) true //s3,s4在堆中建立的对象地址不同。
StringBuffer类 用于字符串变量 支持多线程 null（初始容量为16字符）, int size ,String
delete(int start,int end)
int capacity(),
indexOf(String str),
reverse(),
replace(int start,int end,String str)
trimToSize()
append(String)
insert(int index,String)
String s=StringBuffer.toString(str)
StringBuffer str=new StringBuffer(s)
delete(int start,int end)
int capacity(),
indexOf(String str),
reverse(),
replace(int start,int end,String str)
trimToSize()
append(String)
insert(int index,String)
String s=StringBuffer.toString(str)
StringBuffer str=new StringBuffer(s)
StringBuilder类 不支持多线程
stringTokenizer类 分析字符串分解成独立单词
stringTokenizer(String str,String delim) 分隔符delim,默认字符集（空格、换行、回车Tab等）
nextToken(); hasMoreTokens(); countTokens()
向量类Vector java.util 允许不同类型共存的可变长数组。 属性：长度，容量（自动扩容），增量 (),(Collention c),(int capacity),(int capacity, int increm)
add(Object o)
size()
lastElement()
insertElementAt(Object o,int index) 插入
setElementAt(int index) 替换
removeElementAt(int index) 移除
removeAllElements()
get(int index)
indexOf(Object o) 查找元素位置
Math类
long round(double x) :x距离相邻整数距离不同，则取距离近的那一个； 相同则取真值大的那一个；
round(-11.5);//-11 round(11.5);//12
long round(float x)
double floor(double x) 向下取整
double ceil(double x) 向上取整
double random() 返回0~1之间一个伪随机数
Random类 随机数产生器
nexrInt(); nextDoublel(); nextBytes(Byte[] bytes)
Date类 时间默认顺序W M d h:m:s yy
getTime() 返回一个长整数
日期格式化：
long round(double x) :x距离相邻整数距离不同，则取距离近的那一个； 相同则取真值大的那一个；
round(-11.5);//-11 round(11.5);//12
long round(float x)
double floor(double x) 向下取整
double ceil(double x) 向上取整
double random() 返回0~1之间一个伪随机数
Random类 随机数产生器
nexrInt(); nextDoublel(); nextBytes(Byte[] bytes)
Date类 时间默认顺序W M d h:m:s yy
getTime() 返回一个长整数
日期格式化：
1.DateFormat类：
static final DateFormat getDateInstance().format(Date d); 返回yy-MM-dd
static final DateFormat getDateTimeInstance().format(Date d); 返回yy-MM-dd hh-mm-ss
2.SimpleDateFormat类
构造方法:sd=new SimpleDateFormat("yy年MM月dd日---hh:mm:ss") //自定义日期格式 ，‘E’:星期
1.时间-->字符串
sd.Format(Date date)
2.字符串-->日期
sd1.parse("2014年5月8日---8:30:00") str需要与构造参数str格式相同
构造方法:sd=new SimpleDateFormat("yy年MM月dd日---hh:mm:ss") //自定义日期格式 ，‘E’:星期
1.时间-->字符串
sd.Format(Date date)
2.字符串-->日期
sd1.parse("2014年5月8日---8:30:00") str需要与构造参数str格式相同
Calendar类：
1.创建 Calendar c=Calendar.getInstance();
2.设置日历字段值 set(int yy,MM,dd); set(int yy,MM,dd,hh,mm) set(int yy,MM,dd,hh,mm,ss)
3.获取日历字段值 get(int field)
日历字段：YEAR, MONTH ,DAY_OF_MONTH ,DAY_OF_WEEK ,HOUR ,MINUTE ,SECOND;
4.更改日历值：add(int field ,int amount)
5.Calendar-->Date
public Date getTime();
6. Calendar-->毫秒
public long getTimeInMillis();
Class类： 保存对象的类型信息，自动创建。
String getName();
1.创建 Calendar c=Calendar.getInstance();
2.设置日历字段值 set(int yy,MM,dd); set(int yy,MM,dd,hh,mm) set(int yy,MM,dd,hh,mm,ss)
3.获取日历字段值 get(int field)
日历字段：YEAR, MONTH ,DAY_OF_MONTH ,DAY_OF_WEEK ,HOUR ,MINUTE ,SECOND;
4.更改日历值：add(int field ,int amount)
5.Calendar-->Date
public Date getTime();
6. Calendar-->毫秒
public long getTimeInMillis();
Class类： 保存对象的类型信息，自动创建。
String getName();
五、异常处理
顶级接口 Throwable接口，派生Error 和 Exception类
1. Error类及子类 ：描述 java运行时 系统内部的错误或者资源枯竭导致的错，，此类错误不能抛出，出现几率很小。
2.Exception类 (),(String message),toString() ,printStackTrace()
2.1.RuntimeException异常, 属于程序缺陷异常，设计或实现上的问题，，，
可以不使用try...catch进行处理，不处理也不会出现语法上的异常，被称为 非受检异常(unchecked exception)，有异常产生时，由JVM处理，程序中断。如ArrayIndexOutOfBoundException,ArithmetticException
2.2.非RuntimeException异常 一般是程序外部问题引起。如文件 cant't found ,网络不畅通等。这类语法上要求必须处理 ，受检异常(checked exception)，如FileNotFound,IOException.UnknownHostException
3.用户自定义异常类（通常继承Throwable或者Exception类） 用try...catch(xxxException e)...finally...捕捉，自己定义，自己抛出
Java异常处理机制：
1.声明和抛出
public void func() throws 异常列表名{ //声明
...
throw 异常类名; //抛出
如果main()方法使用，因为main()是程序的起点，向上抛出异常，只能抛给JVM处理，将导致程序的中断。
2.捕捉异常
try{...}catch(xxxException e){...}finally(...一定会执行，除非System.exit()等强制退出)
3.自定义
定义：class exception extends Exception{ ...}
抛出：public void func() throw exception {
if (...) throw
}
捕捉：try{ func();...}catch(exception e){...}finally{...}
1. Error类及子类 ：描述 java运行时 系统内部的错误或者资源枯竭导致的错，，此类错误不能抛出，出现几率很小。
2.Exception类 (),(String message),toString() ,printStackTrace()
2.1.RuntimeException异常, 属于程序缺陷异常，设计或实现上的问题，，，
可以不使用try...catch进行处理，不处理也不会出现语法上的异常，被称为 非受检异常(unchecked exception)，有异常产生时，由JVM处理，程序中断。如ArrayIndexOutOfBoundException,ArithmetticException
2.2.非RuntimeException异常 一般是程序外部问题引起。如文件 cant't found ,网络不畅通等。这类语法上要求必须处理 ，受检异常(checked exception)，如FileNotFound,IOException.UnknownHostException
3.用户自定义异常类（通常继承Throwable或者Exception类） 用try...catch(xxxException e)...finally...捕捉，自己定义，自己抛出
Java异常处理机制：
1.声明和抛出
public void func() throws 异常列表名{ //声明
...
throw 异常类名; //抛出
如果main()方法使用，因为main()是程序的起点，向上抛出异常，只能抛给JVM处理，将导致程序的中断。
2.捕捉异常
try{...}catch(xxxException e){...}finally(...一定会执行，除非System.exit()等强制退出)
3.自定义
定义：class exception extends Exception{ ...}
抛出：public void func() throw exception {
if (...) throw
}
捕捉：try{ func();...}catch(exception e){...}finally{...}
六、泛型和集合框架
1.泛型：本质是参数化类型，，将程序使用的数据类型指定为参数 。
目的：建立具有类型安全的集合框架
泛型参数只能是引用类型或自定义类。
class Generic <T,E,...>
Genetic<String> obj=new Generic<String>("Cenetic class example")
注意：参数可使用extends 限制它必须继承自指定父类或父类本身。如<T extends Number>或<? extends Number> '?'表示未定型。
限制：
1.泛型的参数不能实例化
2.不能声明参数化类型的数组
3.不能使用基本数据类型替换类型参数
4.不能定义带泛型的异常。不允许定义Throwable的泛型子类
5.不能在静态变量或静态方法中引用类中声明的类型参数。
2.集合框架 对常用数据结构
1.Connection接口 ：集合框架的基础; 表示同类型对象的集合; 声明了所有集合都将拥有的核心方法。
boolean add(Object obj) ; addAll(obj)
clear()
boolean contains(Object obj) ; contains(Connection c)
boolean remove(obj) ; removeAll(obj)
Iterator iterator() Connection不能随机访问某个元素，只能通过迭代器遍历。
int size()
------------------------------------------------------------------------
注意： 有些方法可能会引发UnsupportedOperationException
不兼容的对象加入会引发ClassCastException
2.List接口：拓展Connection接口
特性：允许元素重复; 且元素有序(即添加顺序); 允许针对位置索引的随机操作。
boolean add(obj , int index)
Object get(int index)
int indexOf(obj) 没有则返回-1
List subList(int start,int end)
ListIterator listIterator(int index) 从指定下标开始的迭代器
-----------------------------------------------------------
下标超出：IndexOutException
3.Set接口：拓展Connection接口，不允许重复，元素采用内部排序机制存放。没有引用新方法。
4.Map接口：没有继承Connection接口，键不允许重复，值随意。
clear()
containsKey(key) ;containsValue(value)
V get(key)
put(key,value) ; putAll(Map p)
Set<Map.Entry<K,V>> entrySet()
Set<K> keySet()
Set<V> valueSet()
1.泛型：本质是参数化类型，，将程序使用的数据类型指定为参数 。
目的：建立具有类型安全的集合框架
泛型参数只能是引用类型或自定义类。
class Generic <T,E,...>
Genetic<String> obj=new Generic<String>("Cenetic class example")
注意：参数可使用extends 限制它必须继承自指定父类或父类本身。如<T extends Number>或<? extends Number> '?'表示未定型。
限制：
1.泛型的参数不能实例化
2.不能声明参数化类型的数组
3.不能使用基本数据类型替换类型参数
4.不能定义带泛型的异常。不允许定义Throwable的泛型子类
5.不能在静态变量或静态方法中引用类中声明的类型参数。
2.集合框架 对常用数据结构
1.Connection接口 ：集合框架的基础; 表示同类型对象的集合; 声明了所有集合都将拥有的核心方法。
boolean add(Object obj) ; addAll(obj)
clear()
boolean contains(Object obj) ; contains(Connection c)
boolean remove(obj) ; removeAll(obj)
Iterator iterator() Connection不能随机访问某个元素，只能通过迭代器遍历。
int size()
------------------------------------------------------------------------
注意： 有些方法可能会引发UnsupportedOperationException
不兼容的对象加入会引发ClassCastException
2.List接口：拓展Connection接口
特性：允许元素重复; 且元素有序(即添加顺序); 允许针对位置索引的随机操作。
boolean add(obj , int index)
Object get(int index)
int indexOf(obj) 没有则返回-1
List subList(int start,int end)
ListIterator listIterator(int index) 从指定下标开始的迭代器
-----------------------------------------------------------
下标超出：IndexOutException
3.Set接口：拓展Connection接口，不允许重复，元素采用内部排序机制存放。没有引用新方法。
4.Map接口：没有继承Connection接口，键不允许重复，值随意。
clear()
containsKey(key) ;containsValue(value)
V get(key)
put(key,value) ; putAll(Map p)
Set<Map.Entry<K,V>> entrySet()
Set<K> keySet()
Set<V> valueSet()
size()
Map.Entry类：单独操作键-对值
常用方法： equals(Object o)
K getKey()
V getValue()
V setValue()
5.迭代器接口Iterator:
hasNext() ; next() ; remove()
==========================数据结构实现类===============================================
集合常用实现类：
1.ArrayList类： 随需要而增长的动态数组。自动增加或缩小长度。 ArrayLIst(nulll//Connection c//int capacity)
2.LinkedList（链表对象）： 双向链表数据结构 LinkedList（null//Connection c)
addFirst(obj) （在列表头添加）; addLast(obj)
E getFirst() ; E getLast()
E removeFirst(); E removeLast()
3.HashSet类：用散列表存，。不允许重复，内部排序（用户不能参与创建排序集合）
HashSet(null//Connection c//int capacity//int capacity, float fillRatio) 填充比fillRatio 介于0.0~1.0默认0.75
4.TreeSet类：树集。不允许重复。树结构存储，按元素大小升序存储。
TreeSet（null / Collention c / Comparator comp / SortedSet ss)
1.TreeSet根据指定比较器Comparator排序,默认根据元素的自然顺序按升序排序。(要求放入的元素可排序)
2.集合框架 提供 用于排序的接口 Comparable和Comparator。基本数据类型和String类实现了Comparable接口，可直接添加到TreeSet中。
3.Comparable的 compareTo() 用于确定对象的大小;
5.HashMap类：散列映射。（允许使用null值和null键）
6.TreeMmap类：按照key的大小升序排序
3.foreach语句：
for(Object o: Iterable){...} //遍历对象需实现Iterable接口，而Collection接口继承了它。
注：foreach语句不能引用数组或集合的索引，无法修改、删除数组和集合中的元素。
七、java IO 流
1.字节流：以字节方式处理 2.字符流：字符方式处理， 使用Unicode字符集，需要两个字节
InputStream Reader
OutputStream Writer
...都时抽象类
1.节点流：直接操作目标设备所对应的IO流。
2.过滤流：通过一个间接IO流去调用相应的节点流，此间接流称为过滤流(Filter Stream)，也成为包装流。
Map.Entry类：单独操作键-对值
常用方法： equals(Object o)
K getKey()
V getValue()
V setValue()
5.迭代器接口Iterator:
hasNext() ; next() ; remove()
==========================数据结构实现类===============================================
集合常用实现类：
1.ArrayList类： 随需要而增长的动态数组。自动增加或缩小长度。 ArrayLIst(nulll//Connection c//int capacity)
2.LinkedList（链表对象）： 双向链表数据结构 LinkedList（null//Connection c)
addFirst(obj) （在列表头添加）; addLast(obj)
E getFirst() ; E getLast()
E removeFirst(); E removeLast()
3.HashSet类：用散列表存，。不允许重复，内部排序（用户不能参与创建排序集合）
HashSet(null//Connection c//int capacity//int capacity, float fillRatio) 填充比fillRatio 介于0.0~1.0默认0.75
4.TreeSet类：树集。不允许重复。树结构存储，按元素大小升序存储。
TreeSet（null / Collention c / Comparator comp / SortedSet ss)
1.TreeSet根据指定比较器Comparator排序,默认根据元素的自然顺序按升序排序。(要求放入的元素可排序)
2.集合框架 提供 用于排序的接口 Comparable和Comparator。基本数据类型和String类实现了Comparable接口，可直接添加到TreeSet中。
3.Comparable的 compareTo() 用于确定对象的大小;
5.HashMap类：散列映射。（允许使用null值和null键）
6.TreeMmap类：按照key的大小升序排序
3.foreach语句：
for(Object o: Iterable){...} //遍历对象需实现Iterable接口，而Collection接口继承了它。
注：foreach语句不能引用数组或集合的索引，无法修改、删除数组和集合中的元素。
七、java IO 流
1.字节流：以字节方式处理 2.字符流：字符方式处理， 使用Unicode字符集，需要两个字节
InputStream Reader
OutputStream Writer
...都时抽象类
1.节点流：直接操作目标设备所对应的IO流。
2.过滤流：通过一个间接IO流去调用相应的节点流，此间接流称为过滤流(Filter Stream)，也成为包装流。
-----------------------------------------------
文件流 FileReader
FileWriter
FileInputStream
FileOutputStream
-----------------------------------------------
缓冲 BufferReader
BufferWriter
BufferInputStream
BufferOutputStream
--------------------------------------------------
数据 DataInputStream
DataOutputStream
--------------------------------------------------
对象 ObjectInputStream
ObjectOutputStream
--------------------------------------------------
过滤 FilterReader
FilterWriter
FilterInputStream
FilterOutputStream
--------------------------------------------------
打印 PrintReader
PrintWriter
--------------------------------------------------
内存 ByteArrayInputStream
ByteArrayOutputStream
CharArrayReader
CharArrayWriter
--------------------------------------------------
管道 PipeInputStream 用于一个线程输出连接到另一个线程的输入
PipeOutputStream
PipeReader
PipeWriter
--------------------------------------------------
联结 SequenceInputStream 多个输入流联结成一个输入流
-------------------------------------------------
转换 InputStreamReader 字节流、字符流之间的转换
OutputStreamWriter
----------------------------------------------------
计数 LineNumberInputStream 在读取时记录行数
LineNumberReader
字节流和字符连 抽象类，需要通过子类实现
字节输入流
------------------------
abstract int read() throw IOException 读出一个字节（0~255），没有则返回-1
int read (byte[]) ... 读多个字节到数组中
int available()... 返回流中可用字数
close()...
------------
字节输出流
----------
abstract void write(int b)() throw IOException 将一个整数输出到流中
write(byte[] b)...
flush()...将流缓冲区中的数据输出
close()
---------------
字符输入流(两个字节)
-----------
int read()...读取一个字符并将其作为int 返回，结束位置返回-1
int read(char[])... 读多个字符到数组中
abstract close()...
字符输出流
-------------------
write(int c)...
write(char[] c)...
write(String c)...
flush()...将缓存区内容输出
append(char c)增加一个字符到输出流末尾
close()...
------------
文件流 FileReader
FileWriter
FileInputStream
FileOutputStream
-----------------------------------------------
缓冲 BufferReader
BufferWriter
BufferInputStream
BufferOutputStream
--------------------------------------------------
数据 DataInputStream
DataOutputStream
--------------------------------------------------
对象 ObjectInputStream
ObjectOutputStream
--------------------------------------------------
过滤 FilterReader
FilterWriter
FilterInputStream
FilterOutputStream
--------------------------------------------------
打印 PrintReader
PrintWriter
--------------------------------------------------
内存 ByteArrayInputStream
ByteArrayOutputStream
CharArrayReader
CharArrayWriter
--------------------------------------------------
管道 PipeInputStream 用于一个线程输出连接到另一个线程的输入
PipeOutputStream
PipeReader
PipeWriter
--------------------------------------------------
联结 SequenceInputStream 多个输入流联结成一个输入流
-------------------------------------------------
转换 InputStreamReader 字节流、字符流之间的转换
OutputStreamWriter
----------------------------------------------------
计数 LineNumberInputStream 在读取时记录行数
LineNumberReader
字节流和字符连 抽象类，需要通过子类实现
字节输入流
------------------------
abstract int read() throw IOException 读出一个字节（0~255），没有则返回-1
int read (byte[]) ... 读多个字节到数组中
int available()... 返回流中可用字数
close()...
------------
字节输出流
----------
abstract void write(int b)() throw IOException 将一个整数输出到流中
write(byte[] b)...
flush()...将流缓冲区中的数据输出
close()
---------------
字符输入流(两个字节)
-----------
int read()...读取一个字符并将其作为int 返回，结束位置返回-1
int read(char[])... 读多个字符到数组中
abstract close()...
字符输出流
-------------------
write(int c)...
write(char[] c)...
write(String c)...
flush()...将缓存区内容输出
append(char c)增加一个字符到输出流末尾
close()...
------------
File类：对文件进行操作
-----------------------------------------------------
static final String pathSeparator() 返回路径分隔符
static final String separator 返回名称分隔符
File(String filePath)
-----------------------------------------------------
文件的读写：
1.定义文件类 new File("path")
2.构造输入输出流
FileInputStream(File f)/(String path);
FileOutputStream(File/File f,boolean append/String filePath)
3.读写
4.关闭
-----------------------------------------------------
static final String pathSeparator() 返回路径分隔符
static final String separator 返回名称分隔符
File(String filePath)
-----------------------------------------------------
文件的读写：
1.定义文件类 new File("path")
2.构造输入输出流
FileInputStream(File f)/(String path);
FileOutputStream(File/File f,boolean append/String filePath)
3.读写
4.关闭
RandomAccessFile类 ：随机读写（文件指定位置读写），以上是顺序读写（文件开头到结尾）
RandomAccessFile(File ,String mode'r/w') throw FileNotFoundException
RandomAccessFile(String filePath,String mode)...
long getFilePointer 当前文件指针
seek(long pos) 跳到pos指定位置
skipBytes(int n) 后移n个字节
int read(byte[] )
write(byte[] )
byte readByte() readInt()
writeByte(int v)
readLine()
-------------------------------------‘r','rw' close()后写入文件 ,'rws' 和 'rwd' 直接写入文件，数据实时更新，防止中断数据丢失
RandomAccessFile(File ,String mode'r/w') throw FileNotFoundException
RandomAccessFile(String filePath,String mode)...
long getFilePointer 当前文件指针
seek(long pos) 跳到pos指定位置
skipBytes(int n) 后移n个字节
int read(byte[] )
write(byte[] )
byte readByte() readInt()
writeByte(int v)
readLine()
-------------------------------------‘r','rw' close()后写入文件 ,'rws' 和 'rwd' 直接写入文件，数据实时更新，防止中断数据丢失
过滤流： 同步机制，同一时刻只有一个线程能访问一个输出/入流。
子类：
1.缓冲流 如：BufferInputStream(FileInputStream,int capacity) 包装节点流，指定缓冲区(默认32B)大小，
缓冲区满时才一次输入数据，flush()人为将未满缓冲区中数据送出。
2.数据流 实现不同类型数据的读写。 readType()...readDouble() writeType()...writeChar()
注：需按照数据写入的顺序读出，否则数据错误。
3.打印流 打印出任何数据类型，小数，整数，字符串等。格式化打印。
子类：
1.缓冲流 如：BufferInputStream(FileInputStream,int capacity) 包装节点流，指定缓冲区(默认32B)大小，
缓冲区满时才一次输入数据，flush()人为将未满缓冲区中数据送出。
2.数据流 实现不同类型数据的读写。 readType()...readDouble() writeType()...writeChar()
注：需按照数据写入的顺序读出，否则数据错误。
3.打印流 打印出任何数据类型，小数，整数，字符串等。格式化打印。
标准流： System类管理标准IO流和错误流。是final类。
1.public sstatic final InputStream in:标准输入，一般是键盘
2.public sstatic final PrintStream out:标准输出，一般是显示器
3.public sstatic final PrintStream err:错误信息输出，一般是显示器
对象流：
1.对象序列化 把对象变为二进制数据流的方法只有实现java.io.Serializable接口的类才能被序列化。
ObjectInputStream类和ObjectOutputStream 使用readObject(),writeObject()读写数据。
注：序列化使得 对象的所有属性被串行化，可以通过读取文件或者拦截网络传输数据 来非法获取信息。
使用transient修饰8属性 不会被串行化，对象流中也没有它的数据。
1.public sstatic final InputStream in:标准输入，一般是键盘
2.public sstatic final PrintStream out:标准输出，一般是显示器
3.public sstatic final PrintStream err:错误信息输出，一般是显示器
对象流：
1.对象序列化 把对象变为二进制数据流的方法只有实现java.io.Serializable接口的类才能被序列化。
ObjectInputStream类和ObjectOutputStream 使用readObject(),writeObject()读写数据。
注：序列化使得 对象的所有属性被串行化，可以通过读取文件或者拦截网络传输数据 来非法获取信息。
使用transient修饰8属性 不会被串行化，对象流中也没有它的数据。
七。Applet
嵌入网页或其他特定容器，需继承 java.awt.Applet类 或 java.swing.JApplet
html中使用<applet code="path.class" width="300",height="400">指定Applet类位置，浏览我i访问网页时将applet小程序下载到本地执行。
Applet查看器：appeltview first.html .
int()
start()
stop()
destroy()
paint(Graphics p) ; repaint()
安全问题： 由于applet在本地运行（从服务器下载）
对Applet的限制（抛出SecurityException异常）
1.applet不能运行任何本地可执行文件
2.除了applet的下载服务器，applet不能与其他主机通信
3.applet不能对本地文件系统进行读写操作
4.applet弹出式窗体必须带有一个警告信息
注： 可通过签名技术给与applet不同级别的安全等级，赋予更多的权限。
<applet code="path.class" archive="myAppletClass.jar" width="300",height="400" align=LEFT>
向applet传递参数：
<applet...> <param name="str",valu="hello"/></applet>
Applet 类使用getParameter("str");
八、线程
多进程：进程同时运行多个程序，实际上单CPU一次只能运行一个，在多个进程之间快速切换。
多线程：程序同一时间内执行多个操作。
区别：
１.粒度不同，进程由操作系统管理，线程是在一个程序内。
２.进程是操作系统分配资源和处理器调度的基本单位，拥有独立的代码、内部数据和状态（进程上下文）
而一个进程内的多线程只是处理器调度的基本单位，共享进程的资源。线程间有可能相互影响。
３.线程本身的数据只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程之间的切换比进程切换的负担小。
实现多线程：
１.继承Thread类， 覆写run()；创建这个线程类的对象
２.实现Runnable接口 覆写run() ；Runnable实现类的对象 ；用Thread（Runnable r）创建Thread类。
3.使用Callable和Future
3.使用线程池，如Executor框架
线程的优先级：setPriority()
public static final int MIN_PRIORITY : 1
..... NORM_PRIORITY : 5 (默认）
..... MAX_PRIORITY : 10
线程调度采用 优先级基础上的“先到先服务” 原则。
线程睡眠 static sleep(millins)
状态测试 final isAlive()
线程加入 final join()
线程礼让 static yield() 让给同优先级的线程.
线程的同步与死锁：
1.同步代码块：
synchronized{ ...} 临界区：同一时刻只有一个线程能访问，被占用时，线程等待。
2.同步方法：
sychronized 返回类型 function(...){ .....}
线程间交互同步：等待/通知(wait/notify 机制) :在synchronized作用的范围内。
九、Java网络编程 java.net包
127.0.0.1 本机地址
端口 0~65535 1~1024为系统保留端口
(套接字)Socket，通信端点，IP+端口，可完全分辨一个运行程序。
1.流式套接字 面向连接，发送有序数据
2.数据包套接字， 无连接，数据通过独立报文传输，无序。
InetAddress类：表示Internet上的主机地址，由主机名和IP组成。
static InetAddress getByName(String host) throw UnknownHostException;
... getLocalHost() ...
URLConnection类
TCP通信
1：服务器：
server=new ServerSocket(int port) 服务器在端口port等待
client=server.accept() 等待客户端连接
...=client.getInputStream() 获得套接字的输入流
.... . 操作输入输出流读写数据。
2.客户端
client=new Socket(String ip,int port) 连接服务器
client.getOutputStream() 获得输入输出流
.....
UDP通信
1.接收
建立数据报Socket对象,在端口port上监听
socket=new DatagramSocket(int port)
构造用于接收数据的数据包
receiveData= new DatagramPackge(buf,buf.length());
利用数据报接口对象的receive()接收数据包
socket.receive()
2.发送
获取数据报中IP、端口信息，构造发送报文
sendData=new DatagramPackge(buf,buf.length,receiveData.getAddress(),receiveData.getPort())
发回数据
socket.send(sendData);
接收数据时，receive()阻塞当前系统报文，直到有报文到达socket,类似于监听功能。
多进程：进程同时运行多个程序，实际上单CPU一次只能运行一个，在多个进程之间快速切换。
多线程：程序同一时间内执行多个操作。
区别：
１.粒度不同，进程由操作系统管理，线程是在一个程序内。
２.进程是操作系统分配资源和处理器调度的基本单位，拥有独立的代码、内部数据和状态（进程上下文）
而一个进程内的多线程只是处理器调度的基本单位，共享进程的资源。线程间有可能相互影响。
３.线程本身的数据只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程之间的切换比进程切换的负担小。
实现多线程：
１.继承Thread类， 覆写run()；创建这个线程类的对象
２.实现Runnable接口 覆写run() ；Runnable实现类的对象 ；用Thread（Runnable r）创建Thread类。
3.使用Callable和Future
3.使用线程池，如Executor框架
线程的优先级：setPriority()
public static final int MIN_PRIORITY : 1
..... NORM_PRIORITY : 5 (默认）
..... MAX_PRIORITY : 10
线程调度采用 优先级基础上的“先到先服务” 原则。
线程睡眠 static sleep(millins)
状态测试 final isAlive()
线程加入 final join()
线程礼让 static yield() 让给同优先级的线程.
线程的同步与死锁：
1.同步代码块：
synchronized{ ...} 临界区：同一时刻只有一个线程能访问，被占用时，线程等待。
2.同步方法：
sychronized 返回类型 function(...){ .....}
线程间交互同步：等待/通知(wait/notify 机制) :在synchronized作用的范围内。
九、Java网络编程 java.net包
127.0.0.1 本机地址
端口 0~65535 1~1024为系统保留端口
(套接字)Socket，通信端点，IP+端口，可完全分辨一个运行程序。
1.流式套接字 面向连接，发送有序数据
2.数据包套接字， 无连接，数据通过独立报文传输，无序。
InetAddress类：表示Internet上的主机地址，由主机名和IP组成。
static InetAddress getByName(String host) throw UnknownHostException;
... getLocalHost() ...
URLConnection类
TCP通信
1：服务器：
server=new ServerSocket(int port) 服务器在端口port等待
client=server.accept() 等待客户端连接
...=client.getInputStream() 获得套接字的输入流
.... . 操作输入输出流读写数据。
2.客户端
client=new Socket(String ip,int port) 连接服务器
client.getOutputStream() 获得输入输出流
.....
UDP通信
1.接收
建立数据报Socket对象,在端口port上监听
socket=new DatagramSocket(int port)
构造用于接收数据的数据包
receiveData= new DatagramPackge(buf,buf.length());
利用数据报接口对象的receive()接收数据包
socket.receive()
2.发送
获取数据报中IP、端口信息，构造发送报文
sendData=new DatagramPackge(buf,buf.length,receiveData.getAddress(),receiveData.getPort())
发回数据
socket.send(sendData);
接收数据时，receive()阻塞当前系统报文，直到有报文到达socket,类似于监听功能。
十、JDBC
1.加载数据库驱动程序：
Class.forName("Driver name")
1.mysql : com.mysql.jdbc.Driver
2.Oracle: oracle.jdbc.driver.OracleDriver
3.SQL Server: com.Microsoft.jdbc.sqlserver.SQLServerDriver.
4.JDBC-ODBC: sun.jdbc.odbc.JdbcOdbcDriver
2.连接数据库：
Connection conn=DriverManager.getConnection( url , username , password )
url= jdbc:<子协议>:<子名称>
1.mysql : "jdbc:mysql://localhost:3306/databaseName"
2.Oracle: "jdbc:oracle:thin:@localhost:1521:orcl"
3.sqlserver: "jdbc:sqlserver://localhost:1433;databaseName=mydb"
4.JDBC-ODBC : "jdbc:odbc:databaseName"
1.加载数据库驱动程序：
Class.forName("Driver name")
1.mysql : com.mysql.jdbc.Driver
2.Oracle: oracle.jdbc.driver.OracleDriver
3.SQL Server: com.Microsoft.jdbc.sqlserver.SQLServerDriver.
4.JDBC-ODBC: sun.jdbc.odbc.JdbcOdbcDriver
2.连接数据库：
Connection conn=DriverManager.getConnection( url , username , password )
url= jdbc:<子协议>:<子名称>
1.mysql : "jdbc:mysql://localhost:3306/databaseName"
2.Oracle: "jdbc:oracle:thin:@localhost:1521:orcl"
3.sqlserver: "jdbc:sqlserver://localhost:1433;databaseName=mydb"
4.JDBC-ODBC : "jdbc:odbc:databaseName"
java.sql.Driver |数据库驱动程序 接口
静态方法Class.forName("driverName)： 加载数据库驱动程序类
---------------------------------------------------------------------
java.sql.DriverManager |驱动程序管理器类
建立与数据库的连接DriverManager.getConnection("jdbc:mysql://localhoat:3306/databasename","useName","password"))
---------------------------------------------------------------------
java.sql.Connection |数据库连接对象
建立createStatement()
---------------------------------------------------------------------
java.sql.Statement |静态的数据库操作类(简单SQL语句）
executeUpdate()返回表更新计数; executeQuery()返回单个结果集 ;execute()返回多个结果集或多个计数结果.
---------------------------------------------------------------------
java.sql.PreparedStatement |Statement的子接口，动态数据库操作类（带参数的预编译SQL语句)
setInt(int index,int data)| ,setString(int index,String data) 设置参数
---------------------------------------------------------------------
java.sql.CallableStatement |PreparedStatement子接口，执行SQL存储过程
---------------------------------------------------------------------
java.sql.ResultSet
java.sql.SQLExeption
使用存储过程：
CallableStatement继承了Statement接口和 PreparedStatement接口，用于执行SQL存储过程
SQL存储过程：
1包含 程序流、逻辑 、及数据库查询；接收输出、输入参数 ；返回一个或多个结果集及返回值。
2.具有预编译机制，，执行速度比单个语句快。
3.将多个SQL语句作为一个单元处理，向数据库发送的请求少，减少网络堵塞。
1.创建：
CallableStatement csmt=conn.prepareCall("{call pro_name"});
... ("{call pro_name(?,?)}); //有输入参数
... ("{?=call pro_name(?,?)}); //有返回值
2.输入参数赋值：setXXX(int index , obj)
3.输出参数的使用：
1.执行存储过程前：对输出参数 进行 类型注册
csmt.registerOutParamenter(int index,int sqlType); //(参数占位符，参数类型);
//java.sql.Types的静态常量：java.sql.Types.INTEGER , java.sql.Types.VARCHAR等。
2.执行存储过程后：获取输出参数
getXXX(int index)
4.执行 存储过程：execute()
存储过程get_count:
create procedure get_count (IN dep varchar(50),OUT sum1 int)
begain
select count(*) into sum1 from table where key1=dep;
end
数据库元数据操作：
1.元数据（Metadata）：用于描述数据的数据。数据库的元数据 描述 数据库中的表，表名，表索引等信息。
2.DatabaseMetadata接口 ：获取数据库元数据，通过Connection对象的getMetaData()获取。
getURL() , getUserName() , getDriverName() 等。
3.ResultSetMetaData接口：获取结果集元数据，如列的数量，列名等。通过ResultSet对象的getMetaData()获取。
getColumnCount() , getColumnName()等
CallableStatement继承了Statement接口和 PreparedStatement接口，用于执行SQL存储过程
SQL存储过程：
1包含 程序流、逻辑 、及数据库查询；接收输出、输入参数 ；返回一个或多个结果集及返回值。
2.具有预编译机制，，执行速度比单个语句快。
3.将多个SQL语句作为一个单元处理，向数据库发送的请求少，减少网络堵塞。
1.创建：
CallableStatement csmt=conn.prepareCall("{call pro_name"});
... ("{call pro_name(?,?)}); //有输入参数
... ("{?=call pro_name(?,?)}); //有返回值
2.输入参数赋值：setXXX(int index , obj)
3.输出参数的使用：
1.执行存储过程前：对输出参数 进行 类型注册
csmt.registerOutParamenter(int index,int sqlType); //(参数占位符，参数类型);
//java.sql.Types的静态常量：java.sql.Types.INTEGER , java.sql.Types.VARCHAR等。
2.执行存储过程后：获取输出参数
getXXX(int index)
4.执行 存储过程：execute()
存储过程get_count:
create procedure get_count (IN dep varchar(50),OUT sum1 int)
begain
select count(*) into sum1 from table where key1=dep;
end
数据库元数据操作：
1.元数据（Metadata）：用于描述数据的数据。数据库的元数据 描述 数据库中的表，表名，表索引等信息。
2.DatabaseMetadata接口 ：获取数据库元数据，通过Connection对象的getMetaData()获取。
getURL() , getUserName() , getDriverName() 等。
3.ResultSetMetaData接口：获取结果集元数据，如列的数量，列名等。通过ResultSet对象的getMetaData()获取。
getColumnCount() , getColumnName()等
事务操作：独立的操作单元。
1.原子性。要么全部完成，要么均不完成。
2.一致性。几个并行执行的事务，其结果必须与按某一顺序串行执行的结果相同。
3.隔离性。事物执行不受其他事务干扰。
4.持久性。已提交的事务，数据库必须保证其改变不被丢失，即使数据库出现故障
1.关闭自动提交模式
boolean aotuCommit=conn.getAutoCommit(); //得到数据库原有事物提交状态
conn.setAutoCommit(false) //关闭自动提交模式
...
conn.setAutoCommit(aotuCommit) //恢复数据库原有事物提交状态
2.处理事务
stmt.executeUpdate(sql1); //添加批处理语句
stmt.executeUpdate(sql2);
stmt.executeUpdate(sql3);
conn.commit(); //提交
3.抛出SQL异常时，进行事物回滚
conn.rollBack()
4.保存点操作
Savepoint s1=conn.Set() //在批处理语句中设置，执行时对s1保存点到当前SQL语句之间的操作进行部分回滚。
注：MySQL数据库中， 默认的存储引擎 是MyISAM,不支持事务处理，只有InnoDB支持。
boolean aotuCommit=conn.getAutoCommit(); //得到数据库原有事物提交状态
conn.setAutoCommit(false) //关闭自动提交模式
...
conn.setAutoCommit(aotuCommit) //恢复数据库原有事物提交状态
2.处理事务
stmt.executeUpdate(sql1); //添加批处理语句
stmt.executeUpdate(sql2);
stmt.executeUpdate(sql3);
conn.commit(); //提交
3.抛出SQL异常时，进行事物回滚
conn.rollBack()
4.保存点操作
Savepoint s1=conn.Set() //在批处理语句中设置，执行时对s1保存点到当前SQL语句之间的操作进行部分回滚。
注：MySQL数据库中， 默认的存储引擎 是MyISAM,不支持事务处理，只有InnoDB支持。
浙公网安备 33010602011771号