sm性调教片在线观看,99re6这里只有精品,久久日本片精品aaaaa国产

丑男 — Thu, 13 Jul 2017 03:39:00 GMT

一句话解释�Q�预备~~~开�?br />

1 import java.util.concurrent.BrokenBarrierException;
2 import java.util.concurrent.CyclicBarrier;
3
4 import org.slf4j.Logger;
5 import org.slf4j.LoggerFactory;
6
7 public class CyclicBarrierLearn {
8
9     private Logger log = LoggerFactory.getLogger(CyclicBarrierLearn.class);
10
11     private class Work extends Thread {
12
13         private String name;
14         private CyclicBarrier cyclicBarrier;
15
16         public Work(String name, CyclicBarrier cyclicBarrier) {
17             this.name = name;
18             this.cyclicBarrier = cyclicBarrier;
19         }
20
21         @Override
22         public void run() {
23             try {
24                 log.debug("thread name: " + name + " waiting work");
25                 cyclicBarrier.await();
26                 log.debug("thread name: " + name + " working");
27             } catch (InterruptedException e) {
28                 e.printStackTrace();
29             } catch (BrokenBarrierException e) {
30                 e.printStackTrace();
31             }
32
33         }
34     }
35
36     public void cyclicBarrier() {
37         CyclicBarrier cyclicBarrier = new CyclicBarrier(50, new Runnable() {
38
39             @Override
40             public void run() {
41                 log.debug("let's begin work");
42             }
43         });
44
45         for (int i = 0; i < cyclicBarrier.getParties(); i++) {
46             Work work = new Work(String.valueOf(i), cyclicBarrier);
47             work.start();
48         }
49
50     }
51
52     public static void main(String[] args) {
53         CyclicBarrierLearn cyclicBarrierLearn = new CyclicBarrierLearn();
54         cyclicBarrierLearn.cyclicBarrier();
55
56     }
57
58 }
59

丑男 2017-07-13 11:39 发表评论

丑男 — Thu, 13 Jul 2017 03:18:00 GMT

一句话解释�Q�主�U�程��d��Q�其他线�E�完成后�Q�主�U�程被唤醒后�l�箋执行

1 import java.util.Random;
2 import java.util.concurrent.CountDownLatch;
3
4 import org.slf4j.Logger;
5 import org.slf4j.LoggerFactory;
6
7 public class CountDownLatchLearn {
8
9     private Logger log = LoggerFactory.getLogger(CountDownLatchLearn.class);
10     private CountDownLatch countDownLatch;
11
12     public CountDownLatchLearn() {
13         countDownLatch = new CountDownLatch(50);
14     }
15
16     public void countDown() {
17         Long count = countDownLatch.getCount();
18         log.debug("countDownLatch count is:" + count.toString());
19
20         for (int i = 0; i < count; i++) {
21             Work work = new Work(String.valueOf(i), countDownLatch);
22             work.start();
23         }
24         try {
25             countDownLatch.await();
26         } catch (InterruptedException e) {
27             e.printStackTrace();
28         }
29         log.debug("work finish!!!");
30     }
31
32     private class Work extends Thread {
33
34         private String name;
35         private CountDownLatch countDownLatch;
36
37         public Work(String name, CountDownLatch countDownLatch) {
38             this.name = name;
39             this.countDownLatch = countDownLatch;
40         }
41
42         @Override
43         public void run() {
44             Random r = new Random();
45             int sleep = r.nextInt(2000);
46             try {
47                 log.debug("thread sleep: "+ sleep);
48                 Thread.sleep(sleep);
49             } catch (InterruptedException e) {
50                 e.printStackTrace();
51             }
52             log.debug("thread: " + name + ": do work");
53             countDownLatch.countDown();
54         }
55     }
56
57     public static void main(String[] args) {
58         System.out.println("main start!!!");
59
60         CountDownLatchLearn countDownLatchLearn = new CountDownLatchLearn();
61         countDownLatchLearn.countDown();
62
63         System.out.println("main end!!!");
64     }
65
66 }

丑男 2017-07-13 11:18 发表评论

丑男 — Sun, 11 Dec 2005 10:12:00 GMT

jasperreport可以用Collection做�ؓ数据源，�q�种方式比用Connection方式更�ؓ灉|��方便

丑男 2005-12-11 18:12 发表评论

[转帖]学习Reflection

丑男 — Sat, 06 Aug 2005 17:02:00 GMT

Reflection �?Java �E�序开发语�a�的特征之一�Q�它允许�q�行中的 Java �E�序对自�w�进行检查，或者说“自审”，�q�能直接操作�E�序的内部属性。例如，使用它能获得 Java �c�M��各成员的名称�q�显�C�出来�?/DIV>

Java 的这一能力在实际应用中也许用得不是很多�Q�但是在其它的程序设计语�a�中根本就不存在这一�Ҏ��。例如，Pascal、C 或�?C++ 中就没有办法在程序中获得函数定义相关的信息�?/DIV>

JavaBean �?reflection 的实际应用之一�Q�它能让一些工具可视化的操作��Y件组件。这些工具通过 reflection 动态的载入�q�取�?Java �l��g(�c? 的属性�?/DIV>

1. 一个简单的例子

考虑下面�q�个��单的例子�Q�让我们看看 reflection 是如何工作的�?/DIV>

import java.lang.reflect.*;
public class DumpMethods {
   public static void main(String args[]) {
       try {
           Class c = Class.forName(args[0]);
           Method m[] = c.getDeclaredMethods();
           for (int i = 0; i < m.length; i++)
               System.out.println(m[i].toString());
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

按如下语句执行：

java DumpMethods java.util.Stack

它的�l�果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

�q�样��列��Z��java.util.Stack �cȝ��各方法名以及它们的限制符和返回类型�?/DIV>

�q�个�E�序使用 Class.forName 载入指定的类�Q�然后调�?getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描�q�某个类中单个方法的一个类�?/DIV>

2.开始��?Reflection

用于 reflection 的类�Q�如 Method�Q�可以在 java.lang.relfect 包中扑ֈ�。��用这些类的时候必��要遵��@三个步骤�Q�第一步是获得你想操作的类�?java.lang.Class 对象。在�q�行中的 Java �E�序中，�?java.lang.Class �c�L��描述�c�d��接口�{��?/DIV>

下面��是获得一�?Class 对象的方法之一�Q?/DIV>

Class c = Class.forName("java.lang.String");

�q�条语句得到一�?String �cȝ��c�d��象。还有另一�U�方法，如下面的语句�Q?/DIV>

Class c = int.class;

或�?/DIV>

Class c = Integer.TYPE;

它们可获得基本类型的�c�M��息。其中后一�U�方法中讉K��的是基本�c�d��的封装类 (�?Integer) 中预先定义好�?TYPE 字段�?/DIV>

�W�二步是调用诸如 getDeclaredMethods 的方法，以取得该�c�M��定义的所有方法的列表�?/DIV>

一旦取得这个信息，��可以进行第三步了——��?reflection API 来操作这些信息，如下面这�D�代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的�W�一个方法的原型�?/DIV>

在下面的例子中，�q�三个步骤将��Z��?reflection 处理�Ҏ��应用�E�序提供例证�?/DIV>

模拟 instanceof 操作�W?/DIV>

得到�c�M��息之后，通常下一个步骤就是解军_��?Class 对象的一些基本的问题。例如，Class.isInstance �Ҏ��可以用于模拟 instanceof 操作�W�：

class A {
}

public class instance1 {
   public static void main(String args[]) {
       try {
           Class cls = Class.forName("A");
           boolean b1 = cls.isInstance(new Integer(37));
           System.out.println(b1);
           boolean b2 = cls.isInstance(new A());
           System.out.println(b2);
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

在这个例子中创徏了一�?A �cȝ�� Class 对象�Q�然后检查一些对象是否是 A 的实例。Integer(37) 不是�Q�但 new A() 是�?/DIV>

3.扑և��cȝ��Ҏ��

扑և�一个类中定义了些什么方法，�q�是一个非常有价��g��非常基础�?reflection 用法。下面的代码��实��C��q�一用法�Q?/DIV>

import java.lang.reflect.*;

public class method1 {
   private int f1(Object p, int x) throws NullPointerException {
       if (p == null)
           throw new NullPointerException();
       return x;
   }

   public static void main(String args[]) {
       try {
           Class cls = Class.forName("method1");
           Method methlist[] = cls.getDeclaredMethods();
           for (int i = 0; i < methlist.length; i++) {
               Method m = methlist[i];
               System.out.println("name = " + m.getName());
               System.out.println("decl class = " + m.getDeclaringClass());
               Class pvec[] = m.getParameterTypes();
               for (int j = 0; j < pvec.length; j++)
                   System.out.println("param #" + j + " " + pvec[j]);
               Class evec[] = m.getExceptionTypes();
               for (int j = 0; j < evec.length; j++)
                   System.out.println("exc #" + j + " " + evec[j]);
               System.out.println("return type = " + m.getReturnType());
               System.out.println("-----");
           }
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

�q�个�E�序首先取得 method1 �cȝ��描述�Q�然后调�?getDeclaredMethods 来获取一�p�d��?Method 对象�Q�它们分别描�q�C��定义在类中的每一个方法，包括 public �Ҏ��、protected �Ҏ��、package �Ҏ��?private �Ҏ��{�。如果你在程序中使用 getMethods 来代�?getDeclaredMethods�Q�你�q�能获得�l�承来的各个�Ҏ��的信息�?/DIV>

取得�?Method 对象列表之后�Q�要昄��q�些�Ҏ��的参数类型、异常类型和�q�回值类型等��׃��难了。这些类型是基本�c�d��q�是�cȝ��型，都可以由描述�cȝ��对象按顺序给出�?/DIV>

输出的结果如下：

name = f1

decl class = class method1

param #0 class java.lang.Object

param #1 int

exc #0 class java.lang.NullPointerException

return type = int

-----

name = main

decl class = class method1

param #0 class [Ljava.lang.String;

return type = void

-----

4.获取构造器信息

获取�c�L��造器的用法与上述获取�Ҏ��的用法类��|��如：

import java.lang.reflect.*;

public class constructor1 {
public constructor1() {
}

protected constructor1(int i, double d) {
}

   public static void main(String args[]) {
       try {
           Class cls = Class.forName("constructor1");
           Constructor ctorlist[] = cls.getDeclaredConstructors();
           for (int i = 0; i < ctorlist.length; i++) {
               Constructor ct = ctorlist[i];
               System.out.println("name = " + ct.getName());
               System.out.println("decl class = " + ct.getDeclaringClass());
               Class pvec[] = ct.getParameterTypes();
               for (int j = 0; j < pvec.length; j++)
                   System.out.println("param #" + j + " " + pvec[j]);
               Class evec[] = ct.getExceptionTypes();
               for (int j = 0; j < evec.length; j++)
                   System.out.println("exc #" + j + " " + evec[j]);
               System.out.println("-----");
           }
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

�q�个例子中没能获得返回类型的相关信息�Q�那是因为构造器没有�q�回�c�d��?/DIV>

�q�个�E�序�q�行的结果是�Q?/DIV>

name = constructor1

decl class = class constructor1

-----

name = constructor1

decl class = class constructor1

param #0 int

param #1 double

-----

5.获取�cȝ��字段(�?

扑և�一个类中定义了哪些数据字段也是可能的，下面的代码就在干�q�个事情�Q?/DIV>

import java.lang.reflect.*;

public class field1 {
   private double d;
   public static final int i = 37;
   String s = "testing";

   public static void main(String args[]) {
       try {
           Class cls = Class.forName("field1");
           Field fieldlist[] = cls.getDeclaredFields();
           for (int i = 0; i < fieldlist.length; i++) {
               Field fld = fieldlist[i];
               System.out.println("name = " + fld.getName());
               System.out.println("decl class = " + fld.getDeclaringClass());
               System.out.println("type = " + fld.getType());
               int mod = fld.getModifiers();
               System.out.println("modifiers = " + Modifier.toString(mod));
               System.out.println("-----");
           }
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

�q�个例子和前面那个例子非常相伹{��例中��用了一个新东西 Modifier�Q�它也是一�?reflection �c�，用来描述字段成员的修饰语�Q�如“private int”。这些修饰语自��n由整数描�q�ͼ�而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描�q?(如“static”在“final”之�?。这个程序的输出是：

name = d

decl class = class field1

type = double

modifiers = private

-----

name = i

decl class = class field1

type = int

modifiers = public static final

-----

name = s

decl class = class field1

type = class java.lang.String

modifiers =

-----

和获取方法的情况一下，获取字段的时候也可以只取得在当前�c�M��x��了的字段信息 (getDeclaredFields)�Q�或者也可以取得父类中定义的字段 (getFields) �?/DIV>

6.�Ҏ��Ҏ��的名�U�来执行�Ҏ��

文本到这里，所丄��例子无一例外都与如何获取�cȝ��信息有关。我们也可以�?reflection 来做一些其它的事情�Q�比如执行一个指定了名称的方法。下面的�C�Z��演示了这一操作�Q?/DIV>

import java.lang.reflect.*;
public class method2 {
   public int add(int a, int b) {
       return a + b;
   }
   public static void main(String args[]) {
       try {
           Class cls = Class.forName("method2");
           Class partypes[] = new Class[2];
           partypes[0] = Integer.TYPE;
           partypes[1] = Integer.TYPE;
           Method meth = cls.getMethod("add", partypes);
           method2 methobj = new method2();
           Object arglist[] = new Object[2];
           arglist[0] = new Integer(37);
           arglist[1] = new Integer(47);
           Object retobj = meth.invoke(methobj, arglist);
           Integer retval = (Integer) retobj;
           System.out.println(retval.intvalue());
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

假如一个程序在执行的某处的时候才知道需要执行某个方法，�q�个�Ҏ��的名�U�是在程序的�q�行�q�程中指定的 (例如�Q�JavaBean 开发环境中��׃��做这��L��?�Q�那么上面的�E�序演示了如何做到�?/DIV>

上例中，getMethod 用于查找一个具有两个整型参��C��名�ؓ add 的方法。找到该�Ҏ��q�创��Z��相应�?Method 对象之后�Q�在正确的对象实例中执行它。执行该�Ҏ��的时候，需要提供一个参数列表，�q�在上例中是分别包装了整�?37 �?47 的两�?Integer 对象。执行方法的�q�回的同��h��一�?Integer 对象�Q�它��装了返回�?84�?/DIV>

7.创徏新的对象

对于构造器�Q�则不能像执行方法那栯��行，因�ؓ执行一个构造器��意味着创徏了一个新的对�?(准确的说�Q�创��Z��个对象的�q�程包括分配内存和构造对�?。所以，与上例最�怼�的例子如下：

import java.lang.reflect.*;

public class constructor2 {
public constructor2() {
}

   public constructor2(int a, int b) {
       System.out.println("a = " + a + " b = " + b);
   }

   public static void main(String args[]) {
       try {
           Class cls = Class.forName("constructor2");
           Class partypes[] = new Class[2];
           partypes[0] = Integer.TYPE;
           partypes[1] = Integer.TYPE;
           Constructor ct = cls.getConstructor(partypes);
           Object arglist[] = new Object[2];
           arglist[0] = new Integer(37);
           arglist[1] = new Integer(47);
           Object retobj = ct.newInstance(arglist);
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

�Ҏ��指定的参数类型找到相应的构造函数�ƈ执行它，以创��Z��个新的对象实例。��用这�U�方法可以在�E�序�q�行时动态地创徏对象�Q�而不是在�~�译的时候创建对象，�q�一炚w��常有价倹{�?/DIV>

8.改变字段(�?的�?/DIV>

reflection 的还有一个用处就是改变对象数据字�D늚�倹{��reflection 可以从正在运行的�E�序中根据名�U�找到对象的字段�q�改变它�Q�下面的例子可以说明�q�一点：

import java.lang.reflect.*;

public class field2 {
public double d;

   public static void main(String args[]) {
       try {
           Class cls = Class.forName("field2");
           Field fld = cls.getField("d");
           field2 f2obj = new field2();
           System.out.println("d = " + f2obj.d);
           fld.setDouble(f2obj, 12.34);
           System.out.println("d = " + f2obj.d);
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

�q�个例子中，字段 d 的��D��变�ؓ�?12.34�?/DIV>

9.使用数组

本文介绍�?reflection 的最后一�U�用法是创徏的操作数�l�。数�l�在 Java 语言中是一�U�特�D�的�cȝ��型，一个数�l�的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：

import java.lang.reflect.*;

public class array1 {
   public static void main(String args[]) {
       try {
           Class cls = Class.forName("java.lang.String");
           Object arr = Array.newInstance(cls, 10);
           Array.set(arr, 5, "this is a test");
           String s = (String) Array.get(arr, 5);
           System.out.println(s);
       } catch (Throwable e) {
           System.err.println(e);
       }
   }
}

例中创徏�?10 个单位长度的 String 数组�Q��ؓ�W?5 个位�|�的字符串赋了��|��最后将�q�个字符串从数组中取得�ƈ打印了出来�?/DIV>

下面�q�段代码提供了一个更复杂的例子：

import java.lang.reflect.*;

public class array2 {
   public static void main(String args[]) {
       int dims[] = new int[]{5, 10, 15};
       Object arr = Array.newInstance(Integer.TYPE, dims);
       Object arrobj = Array.get(arr, 3);
       Class cls = arrobj.getClass().getComponentType();
       System.out.println(cls);
       arrobj = Array.get(arrobj, 5);
       Array.setInt(arrobj, 10, 37);
       int arrcast[][][] = (int[][][]) arr;
       System.out.println(arrcast[3][5][10]);
   }
}
例中创徏了一�?5 x 10 x 15 的整型数�l�，�q��ؓ处于 [3][5][10] 的元素赋了��gؓ 37。注意，多维数组实际上就是数�l�的数组�Q�例如，�W�一�?Array.get 之后�Q�arrobj 是一�?10 x 15 的数�l�。进而取得其中的一个元素，即长度�ؓ 15 的数�l�，�q��?Array.setInt 为它的第 10 个元素赋倹{�?/DIV>

注意创徏数组时的�c�d��是动态的�Q�在�~�译时�ƈ不知道其�c�d��?BR>

丑男 2005-08-07 01:02 发表评论

��单应用日期类

丑男 — Fri, 05 Aug 2005 15:31:00 GMT

1.自定义格�?BR>   用到java.text.SimpleDateFormat�Q�其中参数如下：
   ss�Q�秒
   mm�Q�分
   hh�Q�小�?BR>   EEEE�Q�星�?BR>   MMMM�Q�月�?BR>   dd�Q�日�?BR>   yyyy�Q�年�?BR>

        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("ss-mm-hh-EEEE-MMMM-dd-yyyy");
        System.out.println(sdf.format(d));

�q�行�l�果

58-21-11-星期�?七月-22-2005

2.DateFormat自带格式

        Date date = new Date();

        DateFormat shortDateFormat = DateFormat.getDateTimeInstance( DateFormat.SHORT,
                                                                                                                 DateFormat.SHORT);
           System.out.println(shortDateFormat.format(date));
           //输出�l�果      05-7-22 下午11:47

           DateFormat mediumDateFormat = DateFormat.getDateTimeInstance( DateFormat.MEDIUM,
                                                                                                                      DateFormat.MEDIUM);
           System.out.println (mediumDateFormat.format(date));
           //输出�l�果       2005-7-22 23:48:11

           DateFormat longDateFormat = DateFormat.getDateTimeInstance( DateFormat.LONG,
                                                                                                                DateFormat.LONG);
           System.out.println(longDateFormat.format(date));
           //输出�l�果      2005�q?�?2�?下午11�?8�?5�U?/SPAN>

           DateFormat fullDateFormat = DateFormat.getDateTimeInstance( DateFormat.FULL,
                                                                                                               DateFormat.FULL);
           System.out.println (fullDateFormat.format(date));
           //输出�l�果      Saturday, September 29, 2001 8:44:45 PM EDT

丑男 2005-08-05 23:31 发表评论

sm性调教片在线观看,99re6这里只有精品,久久日本片精品aaaaa国产

[转帖]学习Reflection

���单应用日期类

��单应用日期类