J2SE知识点

1 Thread

  (1)实现方式

      1) MyThread继承Thread类，override其void run(){}方法;  new MyThread().start();

      2) MyThread实现接口Runnable的void run(){}方法；  new Thread( new MyThread() ).start();

  (2)状态

      [new thread]  ---- start()--->  [runnable] yield()  ----------------sleep(); wait(); I/O----->  [not runnable]

                                                                                  <---notify(); notifyAll(); interrupt(); I/O结束----

  (3)锁

      1) 同步

      a)  public void test(){
           Object o = new Object();

          synchornized(obj){
          //...............
         }  }  这个同步没有任何意义，各线程都是获得全新对象锁

      b)   class Test{
    Object o = new Object();
    public void test(){

    synchornized(o){
    //...............
    }    }  }  所有执行到此Test实例的synchornized(o)的线程,只有一个线程可以获取到监视锁运行.

       c)   public void test(){

    synchornized(this){
    //...............
    }    }  执行Test实例的线程只能有一个线程执行.执行到Test实例的synchornized(o)的线程等待时,其它线程可以执行Test实例的 synchornized(o1)部分,但多个线程同时只有一个可以执行Test实例的synchornized(this)

      d) synchornized(Test.class){
    //...............
    }　　这样的同步块而言,所有调用Test多个实例的线程赐教只能有一个线程可以执行.

      e) 如果一个方法声明为synchornized的,则等同于把在为个方法上调用synchornized(this).
　　如果一个静态方法被声明为synchornized,则等同于把在为个方法上调用synchornized(类.class).


      2)wait(),wait(long),notify(),notifyAll()等方法是当前类的实例方法,
   
        wait()是使持有对象锁的线程释放锁;    当一个线程调用了wait 方法后, 这个线程就进入了这个锁对象的休息室(waitset), 这个waitset记录当前对象中有哪些程线程在等待. 当一个线程进入等待时, 它就会释放锁, 让其它线程来获取这个锁.
        wait(long)是使持有对象锁的线程释放锁时间为long(毫秒)后,再次获得锁,wait()和wait(0)等价;
        notify()是唤醒一个正在等待该对象锁的线程,如果等待的线程不止一个,那么被唤醒的线程由jvm确定;
        notifyAll是唤醒所有正在等待该对象锁的线程.

       wait,notify必须在synchronized 同步段里 ，并且两对象(即对象锁)必须一致，即

       synchroed(obj1 ) {
              obj1 .wait(); (或者obj1.notifyAll())
                }

       否则会出现java.lang.IllegalMonitorStateException: current thread not owner异常

  

  (4)生产者、消费者示例  

        1) class WareHouse {
                  Product[] products= new Car[6];
                  int index=-1; //指向最后一下产品，-1表示为空
                  public synchronized void put(Product product) throws Exception {
                 while (index == 6) {
                          this.wait();
                   }
                  products[++index] = car;
                  this.notify();
           }

                 public synchronized Product get() throws Exception {
                    while (index < 0) {
                    this.wait();
                 }

                   int currentPdt=products[index--];
                   this.notify();
                  return currentPdt;
          }
     }

        2)  class Consumer implements Runnable {
             WareHouse wh;   
             Consumer(WareHouse wh) {
                   this.wh = wh;
            }   
             public void run() {
                 for (int i = 0; i < 20; i++) {
                 wh.get();
             }
     }
 }

     3. public class TestProducerConsumer {
 
       public static void main(String[] args) {
         WareHouse wh = new WareHouse();
         Producer per = new Producer(wh);
         Consumer cer = new Consumer(wh);
 
         new Thread(per).start();
         new Thread(cer).start();
     }
 
 }
 
 
2. thread

  (1)后台线程，即Daemon线程，它是一个在背景执行服务的线程，例如操作系统中的隐藏线程，Java中的垃圾自动回收线程等。如果所有的非后台线程结束了，则后台线程也会自动终止。

 

3.日期类型

   -----------------                       引用

  |    util.Date  |            <---------------------------------     DateFormat(格式化日期输出)

  |  before()     |   <----------  Calendar(对日期加减操作)                    ^

  |  after()        |      引用                                                                  |

          ^                                                                                SimpleDateFormat

           | 继承

   -------------------------------

  |           sql.Date              |

  |static valueof(String)     |


   eg:   Date today=new Date();   //得到今天时间

           // 日期推后一天

           Calendar calendar = Calendar.getInstance();

           calendar.setTime(today);

           calendar.add(Calendar.DATE, -1);

           Date yesterday = calendar.getTime();

           // 格式化输出

           SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

           dateFormat.format(yesterday);



3.集合
Iterator
{Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}

Collection
├List(允许有相同的元素)
│├LinkedList  双向链表
│├ArrayList(数组方式存储数据，可变大小的数组。它允许所有元素，包括null。ArrayList没有同步，缺省情况下自动增长原来50%的数组长度)
│└Vector(非常类似ArrayList，数组方式存储数据，但是Vector是同步的，缺省情况下自动增长原来一倍的数组长度)
└Set(不包含重复的元素，查询和删除和增加元素的效率都非常高。这是通过花费大量的空间换来的：因为空间越大，取余数相同的情况就越小。)
  ├ HashSet:不允许重复，顺序不定，可以add空。
  ├LinkedHashSet:不允许重复。可以add空。  数据严格按照插入的顺序存放,删除之后会去掉那个位置，新增的数据将在集合的末尾
  └SortedSet接口,可排序
      └TreeSet:不允许重复，元素将总是排序形式的，不可以add空
Map
├Hashtable(同步的)
├HashMap(非同步的，并且Key，value允许null,Key是无序存放,可用Collections.synchronizedMap将不同步的Map返回同步的Map
├LinkedHashMap  对key列按照PUT顺序存放
└SortedMap接口
  └TreeMap  按字母顺序排列
 
  集合排序：
  (1)使用java.util.Collections类中的sort()方法对List元素进行排序两种方法：
     1)给方法传递一个List对象，并且list中的元素的类实现了Comparable接口
     2)传递一个List和一个Comparator


* LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));
* HashTable：   key的对象复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。

 

4. Socket编程

  (1) 简单示例

 server端：

class EchoMultiServerThread extends Thread
{
    private Socket echoClient = null;
    public EchoMultiServerThread(Socket socket){
          this.echoClient = socket;
    }
    public void run(){
            PrintWriter out = new PrintWriter(echoClient.getOutputStream(), true);
            BufferedReader in = new BufferedReader( new InputStreamReader(echoClient.getInputStream()));
          String strFromClient;
            while ((strFromClient = in.readLine()) != null) {
             out.println(“result is :”+ strFromClient);
          out.close();
            in.close();
            echoClient.close();

    }
}
public class EchoMultiServer
{
    public static void main (String[] args) throws IOException
    {
        ServerSocket echoServer = null;
        boolean listening = true;
        echoServer = new ServerSocket(3333);
        while (listening)
            new EchoMultiServerThread(echoServer.accept()).start();
        echoServer.close();
    }
}

 

客户端：

Socket echoClient = new Socket(“yourhostname”,3333);
//creat a new socket connected to host and port 3333
PrintWriter out = new PrintWriter(echoClient.getOutputStream(),true);
BufferedReader in = new BufferedReader(new InputStreamReader(echoClient.getInputStream()));
String fromServer,fromUser;
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
//gets the system input stream and opens a BufferedReader on it
while ((fromUser = stdIn.readLine()) != null){
    if (fromUser.equals(&quot;bye&quot;)) break;
    //when user types &quot;bye&quot; then end
    System.out.println(“input is:” + fromUser);
    out.println(fromUser);
    fromServer = in.readLine();
    System.out.println(fromServer);
out.close();
in.close();
echoClient.close();

 

(2)用J2ME在手机上通过cmwap访问https

       SocketConnection conn = null;
　　 OutputStream os = null;
　　 InputStream is = null;

　　 // url: https://ebs.95559.com .cn/corporbank/es_logon.jsp　            conn = (SocketConnection) Connector.open("socket://10.0.0.172:80 ", Connector.READ_WRITE, true);
　　 conn.setSocketOption(SocketConnection.DELAY, 0);
　　 conn.setSocketOption(SocketConnection.KEEPALIVE, 300);
　　
　　 // 发送和回复的请求
　　 os = conn.openDataOutputStream();
　　 is = conn.openDataInputStream();
　　
　　 // 在此我们使用HTTP 1.0，HTTP 1.1自己还需要处理chunk，比较麻烦
　　 String  reqStr =
　　 "GET https://ebs.95559.com.cn/corporbank/es_logon.jsp HTTP/1.0/r/n" +
　　 "Host : ebs.95559.com.cn:443/r/n" +
　　 "User-Agent : FelixBrowser/r/n" +
　　 "Accept-Charset: utf-8;/r/n" +
　　 "Connection : close;/r/n" +
　　 "Accept-Language: zh-cn/r/n/r/n";
　　
　　 os.write(reqStr.getBytes());
　　 os.flush();
　　
　　 System .out.println("Response Stream:");
　　 byte[] buf = new byte[128];
　　 while (true) {
　　 int  availSize = is.read(buf, 0, buf.length);
　　if (availSize == -1) {
　　break;
　　 }
　　 System.out.println(new String(buf, 0, availSize));
　　 }