FileOutputStream fos = new FileOutputStream(args[0]);

ObjectOutputStream oos = new ObjectOutputStream(fos);

Person p = new Person("gaoyanbing", "haiger");
oos.writeObject(p);

FileInputStream fis = new FileInputStream(args[0]);

ObjectInputStream ois = new ObjectInputStream(fis);

Object o = ois.readObject();
2.克隆。分为深度克隆和浅克隆。java object自身的克隆是浅克隆。
3.List转换成数组
List<PrizeStatistic> pList = cwlGameDAO.getLatestPrizeStatistic(gameId);
  prizeStatistic = pList.toArray(new PrizeStatistic[pList.size()]);

4.math.floor(i) 小于等于i的最大整数
  math.ceil(i) 大于等于i的最小整数   
  Math.round(x)：四舍五入。      
  Math.round(x)返回long型，其余的返回double型。
 int pageCount = (int) Math.ceil((double)historyAmount/pageSize)

5.double,float 等浮点数是不准确的，想使用准确的，可以用BigDecimal 或者直接用 int/long 这类整数.
  DecimalFormat format = new DecimalFormat("0.0");
        double a = 1.9;
        double b = 0.3;
        double d = Double.valueOf(format.format(a + b));
        System.out.println(a+"+"+b+"="+d);//这样就是2.2了

6   取a和b之间的随即数 int m=(int)Math.rint(Math.random()*(b-a)+a);

7

作用域           当前类         同一package         子孙类             其他package

public          √                    √              √                  √ 
protected       √                   √               √×                × 
friendly        √                   √               ×                  × 
private         √                   ×               ×                  ×
protected:不同包的子类就规规矩矩的在自己的代码里用父类的属性就行了（继承了父类的属性）。其它的使用都是不允许的（例如实例化父类，然后调用protected属性或者方法）。
protected只有本包和子类可以访问。freindly只有本包可以访问。当然当前类都可以访问。
8 java数据类型转换
在混合运算中，容器小的类型自动提升为为容器大的类型，数据类型容器大小顺序如下:
byte short char->int->long->float->double
byte short char之前不会相互转换，他们运算时先提升为int
容器大的转换为容器小的需要加上强制转换符，可能造成数据溢出或者精度降低
在存在多种数据类型计算时，先把数据类型转换为容量最大的类型进行计算。
实数常量如（1.2）默认为double,整数常量(123)默认为int
byte1个字节，8位(-2/7----2/7-1)。 short 2个字节，16位(-2/16----2/16-1)。 int 4个字节，32位(-2/32----2/32-1)。char 8位 无符号
double双精度,8个字节。flot单精度4个字节。float没有double的精确度高。如果对精确度要求特别高，可以使用BigDecimal.
整数除0，抛异常。浮点数除0，得到无穷大，得到正无穷大positive_infinity或者福无穷大negative_infinity。NAN意思是not a number,NAN有可能不等于NAN.
赋值变量类型转换的规则
byte short char->int->long->float->double
byte->short->int    char->int
9 java集合 
iterator.remove()删除左边的元素 collection接口的子类都有默认的构造函数（例如 ArrayList l = new ArrayList(l1)）;
Collection 有retainAll、addAll、toArray方法
10 io
InputStream OutputStream 字节流，Reader Writer字符流
常见子类FileInputStream FileOutputStream FileReader FileWriter
每一个抽象流都有一个缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
BufferedReader有readLine读取一行字符，BufferedWriter有newLine（）创建新的一行.readLine是同步的阻塞的。
转换流 OutputStreamWriter 将流转换为writer，可以写字符。InputStreamReader可以将流转换为Reader，可以读取字符。外面还可以套Buffered
DataOutputStream DataInputStream属于处理流，可以修饰所有的OutputStream和InputStream子类（包括Buffer流），用于读写java的原始数据类型数据.DataOutputStream写的都是二进制文件，需要用DataInputStream打开。
打印流 PrintWriter PrintStream分别对用于字符和字节,可以套接FileOutput流。不会抛异常，具有自动flush功能。
一般套接情况，file流外套buffer流，将支持buffer功能，然后套格式化流（比如DataOutputSream和PrinterWirter等），就支持了格式化输入输出。
对象流 

11 父类子类的构造函数

如果父类没有声明无参构造函数，那么子类也不能使用无参构造函数，只能使用跟父类一样参数的构造函数。

如果父类声明了无参构造函数，那么子类也可以使用无参构造函数还可以使用其他参数类型的构造函数（有人叫它重载构造函数）

12 内部类。
  内部类分为静态内部类和非静态内部类。
 非静态内部类,不能有静态方法/属性/静态块,不能访问外部类的静态方法和属性。private修饰的内部类只能在外部类内使用。
 非静态内部类维护着对外部类的对象的引用。可以访问外部类的private属性。属性如果同名，类名.this.属性名这种方式访问。
 外部类不能访问内部类的成员属性和方法，只能通过创建对象来访问。
------------------------------------------------------------------------------------------------------------------------------------------
 静态内部类，只能访问外部类的静态属性和静态方法。因为静态内部类维护的是外部类的类引用而不是对象引用。
 外部类不能访问静态内部类的成员，但可以通过内部类的类名做为调用者来调用静态属性。
 也可以构建子类的对象来访问子类的方法。
13 线程和多线程 
  sleep suspend resume join属于Thread的方法，wait notify notifyall属于object的方法。wait notify notifyall必须放在同步方法或者同步块里，否则报异常。
  一般情况下会使用notifyall而不是notify.sleep睡眠一段时间后会执行,sleep被阻塞了但是不放弃锁。wait会放弃锁。
  用suspend()暂停了线程的执行。除非线程收到resume()消息，否则不会返回可运行状态；
  阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。 

     1. sleep() 方法：sleep() 允许 
指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。
典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。 

     2. suspend() 和 resume() 
方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。
典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。 

    3. yield() 方法：
yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。
调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。 

     4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 
指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。 
 初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。 
Thread类的方法基本上都不会放弃锁，object同步方法会放弃锁.
    volatile变量只能保证可预见性，加锁可以保证原子性和可见性。volatile是若同步，不会加锁，可以读取到变量的最新值。   在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一
个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。要解决这个问题，只需要像在本程序中的这样，把该变量声明为
volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应
该加volatile修饰。Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
 
 ReenTrantLock显示锁可以替代synchronized，提供了更高级的应用。ReentTranloack典型用法如下：
  
ReentrantLock lock = new ReentrantLock(); // not a fair lock
lock.lock();
try {
    //
synchronized do something
} finally {

lock.unlock();
}
ReentTranLock提供了更高级的用法trylock方法.
if (fromAcct.lock.tryLock()) {do somthing} //lock是formAcct类的一个属性。
定时方法如下：
import static java.util.concurrent.TimeUnit.NANOSECONDS;
    private Lock lock = new ReentrantLock();
    public boolean trySendOnSharedLine(String message,long timeout, TimeUnit unit)throws InterruptedException {
        long nanosToLock = unit.toNanos(timeout)- estimatedNanosToSend(message);
        if (!lock.tryLock(nanosToLock, NANOSECONDS))
            return false;
        try {
            return sendOnSharedLine(message);
        } finally {
            lock.unlock();
        }
    }



  

1、 泛化(Generalization)<o:p></o:p>

很简单，就是我们常说的继承。是说子类获得父类的功能的同时，还可以扩展自己的功能。

如图:

Java代码中表现为：extends 和 implements

2、 依赖(Dependency)<o:p></o:p>

两个相对独立的咚咚(A和B)，当A负责构造B时，A与B形成依赖关系，即A使用B。

如图：

<v:shape id="_x0000_i1026" style="WIDTH: 378pt; HEIGHT: 81.75pt" type="#_x0000_t75"><v:imagedata o:title="Dependency" src="file:///D:\DOCUME~1\Yaogao\LOCALS~1\Temp\msohtml1\01\clip_image003.wmz"></v:imagedata></v:shape>

实际上，从依赖 -----〉聚合--------〉组合，类与类之间的关系更加紧密，互相之间的影响越来越大，其实我们平常比较少去区分这些关系，而且事实上这东西的定义不太好理解，所以肯定会导致认识上的偏差，所以我们使用这些东西的时候，尽量靠近大家都认同的做法，这样容易让别人理解。

　　对于Java而言。这些Api存在与Java.net这个包里面。因此只要导入这个包就可以准备网络编程了。网络编程的基本模型就是客户机到服务器模型。简单的说就是两个进程之间相互通讯，然后其中一个必须提供一个固定的位置，而另一个则只需要知道这个固定的位置，并去建立两者之间的联系。然后完成数据的通讯就可以了。这里提供固定位置的通常称为服务器，而建立联系的通常叫做客户端。基于这个简单的模型，就可以进入网络编程。

　　Java对这个模型的支持有很多种Api.而这里我只想介绍有关Socket的编程接口。对于Java而言已经简化了Socket的编程接口。首先我们来讨论有关提供固定位置的服务方是如何建立的。Java提供了ServerSocket来对其进行支持。事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你。

以下是引用片段： 　　ServerSocket server=new ServerSocket(6789);

　　这里稍微要注意的是端口的分配必须是唯一的。因为端口是为了唯一标识每台计算机唯一服务的。另外端口号是从0~65535之间的，前1024个端口已经被Tcp/Ip 作为保留端口，因此你所分配的端口只能是1024个之后的。

　　好了。我们有了固定位置。现在所需要的就是一根连接线了。该连接线由客户方首先提出要求。因此Java同样提供了一个Socket对象来对其进行支持。只要客户方创建一个Socket的实例对象进行支持就可以了。

以下是引用片段： 　　Socket client=new Socket(InetAddress.getLocalHost()，5678);

　　客户机必须知道有关服务器的IP地址。对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供。它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法。

　　好了，上面的方法基本可以建立一条连线让两台计算机相互交流了。可是数据是如何传输的呢?事实上I/O操作总是和网络编程息息相关的。因为底层的网络是继续数据的。除非远程调用，处理问题的核心在执行上。

　　否则数据的交互还是依赖于IO操作的。所以你也必须导入Java.io这个包。Java的IO操作也不复杂。它提供了针对于字节流和Unicode的读者和写者，然后也提供了一个缓冲用于数据的读写。

以下是引用片段： 　　BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); 　　PrintWriter out=new PrintWriter(server.getOutputStream());

　　上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作。而原始的字节流来源于Socket的两个方法，getInputStream()和getOutputStream()方，分别用来得到输入和输出。那么现在有了基本的模型和基本的操作工具，我们可以做一个简单的Socket例程了服务方：

以下是引用片段： 　　import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.*; public class MyServer{ public static void main (String[] args) throws IOException {    ServerSocket server=new ServerSocket(5678);    Socket client = server.accept();    BufferedReader in=new BufferedReader(new InputStreamReader (client.getInputStream()));    PrintWriter out=new PrintWriter(client.getOutputStream());    while(true)    {     String str=in.readLine();     System.out.println(str);     out.println(str+"has receive...");     out.flush();     if(str.equals("end"))     break;    }    client.close(); } }

　　这个程序的主要目的在于服务器不断接收客户机所写入的信息只到。客户机发送"End"字符串就退出程序。并且服务器也会做出"Receive"为回应。告知客户机已接收到消息。客户机代码：

以下是引用片段： 　import java.net.*; import java.io.*; public class Client{ static Socket server; public static void main(String[] args) throws Exception {    server = new Socket(InetAddress.getLocalHost(),5678);    BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream()));    PrintWriter out=new PrintWriter(server.getOutputStream());    BufferedReader wt=new BufferedReader(new InputStreamReader(System.in));    while(true)    {     String str=wt.readLine();     out.println(InetAddress.getLocalHost()+"--"+str);     out.flush();     if(str.equals("end"))     {      break;     }     System.out.println(in.readLine());    }    server.close(); } }

一、组group
1、组是由圆括号分开的正则表达式，随后可以根据它们的组号进行调用。
第0组匹配整个表达式，第1组匹配第1个圆括号扩起来的组，......依次类推。
如：A(B(C))D
有3个组：
第0组：ABCD
第1组：BC
第2组：C

例子：
package myfile;
import java.util.regex.*;
public class GroupR2 {
 public static void main(String[] args) {
  String[] input=new String[]{
    "Java has regular expressions in 1.4",
    "regular expressions now expressing in Java",
    "Java represses oracular expressions"
  };
  Pattern
  p1=Pattern.compile("re\\w*"),
  p2=Pattern.compile("Java.*");
  for(int i=0;i<input.length;i++){
   System.out.println("input "+i+":"+input[i]);
   Matcher
   m1=p1.matcher(input[i]),
   m2=p2.matcher(input[i]);
   while(m1.find())
    System.out.println("m1.find() '"+m1.group()+"' start= "+m1.start()+" end= "+m1.end());
   while(m2.find())
    System.out.println("m2.find() '"+m2.group()+"' start= "+m2.start()+" end= "+m2.end());
   if(m1.lookingAt())
    System.out.println("m1.lookingAt() start = "+m1.start()+" end= "+m1.end());
   if(m2.lookingAt())
    System.out.println("m2.lookingAt() start = "+m2.start()+" end= "+m2.end());
   if(m1.matches())
    System.out.println("m1.matches() start= "+m1.start()+" end= "+m1.end());
   if(m2.matches())
    System.out.println("m2.matches() start= "+m2.start()+" end= "+m2.end());
  
  }
 }
 /**
 * 输u20986 结u26524 ：
 input 0:Java has regular expressions in 1.4
 m1.find() 'regular' start= 9 end= 16
 m1.find() 'ressions' start= 20 end= 28
 m2.find() 'Java has regular expressions in 1.4' start= 0 end= 35
 m2.lookingAt() start = 0 end= 35
 m2.matches() start= 0 end= 35
 input 1:regular expressions now expressing in Java
 m1.find() 'regular' start= 0 end= 7
 m1.find() 'ressions' start= 11 end= 19
 m1.find() 'ressing' start= 27 end= 34
 m2.find() 'Java' start= 38 end= 42
 m1.lookingAt() start = 0 end= 7
 input 2:Java represses oracular expressions
 m1.find() 'represses' start= 5 end= 14
 m1.find() 'ressions' start= 27 end= 35
 m2.find() 'Java represses oracular expressions' start= 0 end= 35
 m2.lookingAt() start = 0 end= 35
 m2.matches() start= 0 end= 35
 */
}

2、Matcher对象的方法：
int groupCount()    分组的数目（不含0组）
String group()    返回前一次的匹配操作
String group(int i)    返回前一次匹配操作期间指定的组
int start(int group)    返回前一次匹配操作寻找到的组的起始下标
int end(int group)    返回前一次匹配操作寻找到的组的最后一个字符下标加一的值
二、模式标记
Pattern Pattern.compile(String regex, int flag)
flag有多个值：
（1）Pattern.CANON_EQ   两个字符当且仅当它们的完全规范分解相匹配时，就认为匹配。缺省时，不考虑。
（2）Pattern.CASE_INSENSITIVE   缺省时，仅在ASCII字符集中进行。
（3）Pattern.COMMENTS   忽略空格符，且以#号开始到行末的注释也忽略
（4）Pattern.DOTALL     表达式'.'匹配所有字符，包括行终结符。缺省时，'.'不匹配行终结符。
（5）Pattern.MULTILINE  在多行模式下，表达式‘^'和'$'分别匹配一行的开始和结束。缺省时，它们仅匹配输入的完整字符串的开始和结束。
见例子：

package myfile;
import java.util.regex.*;
public class ReFlags {
 public static void main(String[] args) {
  String str="java has regex\nJava has regex\n" +
    "JaVa has pretty good regular expressions\n"+
    "Regular expressions are in JAva";
  Pattern p=Pattern.compile("^java", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
  Matcher m=p.matcher(str);
  while(m.find()) //find()尝u-29739 查u25214 与u-29723 模u24335 匹u-28339 的u-28781 入u24207 列u30340 下u19968 个u23376 序u21015 。
   System.out.println(m.group()); //group()返u22238 由u20197 前u21305 配u25805 作u25152 匹u-28339 的u-28781 入u23376 序u21015 。
 }
}
 
三、split()
它将输入字符串断开成字符串对象数组，断开边界由正则表达式确定。
String split(CharSequence charseq);
String split(CharSequence charseq, int limit);
第2种limit限制了分裂的数目。

例子：

package myfile;
import java.util.regex.*;
import java.util.*;
public class SplitDemo {
 static String input="This!!unusual use!!of exclamation!!points";
 public static void main(String[] args) {
  System.out.println(Arrays.asList(Pattern.compile("!!").split(input)));
  //Arrays.asList() 返回一个受指定数组支持的固定大小的列表。
  System.out.println(Arrays.asList(Pattern.compile("!!").split(input,3)));
  System.out.println(Arrays.asList("Aha! String has a split() built in!".split(" ")));
 }
}

四、替换操作
1）replaceFirst(String replacement)
用replacement替换输入字符串中最先匹配的那部分。
2）replaceAll(String replacement)
用replacement替换输入字符串中所有的匹配部分。
3）appendReplacement(StringBuffer sbuf, String replacement)
逐步地在sbuf中执行替换
4）appendTail(StringBuffer sbuf,String replacement)
在一个或多个appendReplacement()调用之后被调用，以便复制输入字符串的剩余部分。

例子：

package myfile;
import java.util.regex.*;
import java.io.*;
/*!Here's a block of text to use as input to
 * the regular expression matcher. Note that we'll
 * first extract the block of text by looking for
 * the special delimiters, then process the
 * extracted block.!
 */
public class TheReplacements {
 public static void main(String[] args) throws Exception{
  String s="/*!Here's a block of text to use as input to\n"+
  " the regular expression matcher. Note that we'll\n"+
  "first extract the block of text by looking for\n"+
  "the special delimiters, then process the\n"+
  "extracted block.!*/";
  Pattern p=Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL); //用以匹配在‘/*!’和‘!*/’之间的所有文本
  Matcher mInput=p.matcher(s);
  if(mInput.find())
   s=mInput.group(1); //Captured by parentheses
  //Replace two or more spaces with a single space:
  s=s.replaceAll(" {2,}"," ");
  //Replace on or more spaces at the beginning of each line with no spaces.Must enable MULTILINE mode.
  s=s.replaceAll("(?m)^+","");
  System.out.println(s);
  s=s.replaceFirst("[aeiou]","(VOWEL1)");
  StringBuffer sbuf=new StringBuffer();
  Pattern p1=Pattern.compile("[aeiou]");
  Matcher m1=p1.matcher(s);
  //Process the find information as you perform the replacements:
  while(m1.find())
   m1.appendReplacement(sbuf, m1.group().toUpperCase());
  //Put in the remainder of the text:
  m1.appendTail(sbuf);
  System.out.println(sbuf);
 }
}

五、reset()方法，可将现有的Matcher对象应用于一个新的字符序列。
例子：

package myfile;
import java.util.regex.*;
import java.io.*;
public class Resetting {

 public static void main(String[] args) {
  Matcher m=Pattern.compile("[frb][aiu][gx]").matcher("fix the rug with bags");
  while(m.find())
   System.out.println(m.group());
  m.reset("fix the rug with bags");
  while(m.find())
   System.out.println(m.group());
 }

}

六、在JDK1.4之前，将字符串分离成几部份的方法是：
利用StringTokenizer将该字符串“用标记断开”。
例子：

package myfile;
import java.util.*;
public class ReplacingStringTokenizer {
 public static void main(String[] args) {
  // TODO 自动生成方法存根
  String input ="But I'm not dead yet! I feel happy!";
  StringTokenizer stoke=new StringTokenizer(input);
  while(stoke.hasMoreElements())
   System.out.println(stoke.nextToken());
  System.out.println(Arrays.asList(input.split(" ")));
 }

}
 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/chszs/archive/2007/03/28/1544367.aspx