Constructor constructors[] = tehClass.getConstructors();
Class parameterTypes[] = constructors[i].getParameterTypes();
if ( parameterTypes.length == 1 && parameterTypes[0].equals(String.class))) {
// win
}

1. Constructor c = theClass.getConstructor(new Class[]{String.class});

1. void start() {
2.         buildQueueThread = new Thread(this, "BuildQueueThread" );
3.         buildQueueThread.setDaemon(false);
4.         buildQueueThread.start();
5.         while (!buildQueueThread.isAlive()) {
6.             try {
7.                 Thread.sleep(500);
8.             } catch (InterruptedException e) {
9.                 String message = "BuildQueue.start() interrupted";
10.                 LOG.error(message, e);
11.                 throw new RuntimeException(message);
12.             }
13.         }
14.     }

1. void serviceQueue() {
2.         while (!queue.isEmpty()) {
3.             Project nextProject;
4.             synchronized (queue) {
5.                 nextProject = (Project) queue.remove(0);
6.             }
7.             if (nextProject != null) {
8.                 LOG.info("now adding to the thread queue: " + nextProject.getName());
9.                 ProjectWrapper pw = new ProjectWrapper(nextProject);
10.                 // let's not add the task more than once
11.                 String name = nextProject.getName();
12.                 if (ThreadQueue.isActive(name)) {
13.                   // it's already there... don't re-add it.
14.                   // later, we'll need to add it to a queued up list
15.                   // so we don't 'forget' about the new build request
16.                 } else {
17.                   ThreadQueue.addTask(pw);
18.                 }
19.             }
20.         }
21.     }
23.     public void run() {
24.         try {
25.             LOG.info("BuildQueue started" );
26.             while (true) {
27.                 synchronized (queue) {
28.                     if (queue.isEmpty()) {
29.                         waiting = true;
30.                         queue.wait();
31.                     }
32.                     waiting = false;
33.                 }
34.                 serviceQueue();
35.             }
36.         } catch (InterruptedException e) {
37.             String message = "BuildQueue.run() interrupted. Stopping?";
38.             LOG.debug(message, e);
39.         } catch (Throwable e) {
40.             LOG.error("BuildQueue.run()", e);
41.         } finally {
42.             waiting = false;
43.             LOG.info("BuildQueue thread is no longer alive" );
44.         }
45.     }

1. void stop() {
2.         LOG.info("Stopping BuildQueue" );
3.         buildQueueThread.interrupt();
4.         synchronized (queue) {
5.             queue.notify();
6.         }
7.     }

1. public void connectTo(final Project project, final ServerResource resource) throws UserException {
2.         assert (resource instanceof CaliberServerResource);
3.         final CaliberServerResource t_caliberServerResource = (CaliberServerResource) resource;
4.         final CaliberServer t_server = new CaliberServer(resource.getServerName());
5. ...

1. package com.nraynaud.nraynum.web;
3. import com.nraynaud.nraynum.Message;
4. import com.nraynaud.nraynum.MessageStore;
5. import com.nraynaud.nraynum.User;
7. import javax.servlet.ServletException;
8. import javax.servlet.http.HttpServlet;
9. import javax.servlet.http.HttpServletRequest;
10. import javax.servlet.http.HttpServletResponse;
11. import java.io.IOException;
12. import java.io.PrintWriter;
13. import java.text.DateFormat;
14. import java.util.Collection;
15. import java.util.List;
16. import java.util.concurrent.*;
18. public class IndexServlet extends HttpServlet {
19.     private static final TableContentWriter<User> USER_TABLE_CONTENT_WRITER = new TableContentWriter<User>() {
21.         public void writeLine(User line, PrintWriter writer) {
22.             writeCell(line.getName(), writer);
23.         }
24.     };
25.     private static final TableContentWriter<Message> MESSAGE_TABLE_CONTENT_WRITER = new TableContentWriter<Message>() {
27.         public void writeLine(Message line, PrintWriter writer) {
28.             writeCell(line.getText(), writer);
29.             writeCell(line.getAuthor().getName(), writer);
30.             writeCell(DateFormat.getDateInstance().format(line.getDate()), writer);
31.         }
32.     };
35.     private final ExecutorService executor = Executors.newSingleThreadExecutor();
36.     private final MessageStore<?> store = findStore("com.nraynaud.nraynum.hibernate.HibernateMessageStore" );
40.     private Callable<List<? extends Message>> callableMessageList = new Callable<List<? extends Message>>() {
41.         public List<? extends Message> call() throws Exception {
42.             return store.getAllMessages();
43.         }
44.     };
46.     private Callable<Collection<? extends User>> callableUserCollection = new Callable<Collection<? extends User>>() {
47.         public Collection<? extends User> call() throws Exception {
48.             return store.getAllUsers();
49.         }
50.     };
52.     public IndexServlet() {
53.         store.createMessage("pouet les nains !", "Marcel" );
54.         store.createMessage("coucou les grands !", "Marcel" );
55.         store.createMessage("salut  !", "Jean" );
56.     }
58.     protected void doGet(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
59.         //start SQL stuff in background before anything else
60.         final Future<List<? extends Message>> messages = executor.submit(callableMessageList);
61.         final Future<Collection<? extends User>> users = executor.submit(callableUserCollection);
62.         final PrintWriter writer = httpServletResponse.getWriter();
63.         writer.write("<html>" );
64.         writeTable(messages, writer, MESSAGE_TABLE_CONTENT_WRITER);
65.         writeTable(users, writer, USER_TABLE_CONTENT_WRITER);
66.         writer.write("</html>" );
67.     }
69.     private static <LINETYPE>  void writeTable(Future<? extends Collection<? extends LINETYPE>> lines, final PrintWriter writer, final TableContentWriter<LINETYPE> tableContentWriter) {
70.         writer.write("<table BORDER='10' BORDERCOLOR='RED'>" );
71.         try {
72.             for (LINETYPE line : lines.get()) {
73.                 writer.write("<tr>" );
74.                 tableContentWriter.writeLine(line, writer);
75.                 writer.write("</tr>" );
76.             }
77.         } catch (InterruptedException e) {
78.             throw new RuntimeException(e);
79.         } catch (ExecutionException e) {
80.             throw new RuntimeException(e);
81.         }
82.         writer.write("</table>" );
83.     }
85.     private static void writeCell(String content, PrintWriter writer) {
86.         writer.write("<td>" );
87.         writer.write(content);
88.         writer.write("</td>" );
89.     }
91.     private static MessageStore<?> findStore(final String storeName) {
92.         try {
93.             final Class<MessageStore<?>> storeClass = (Class<MessageStore<?>> ) Class.forName(storeName);
94.             return storeClass.newInstance();
95.         } catch (InstantiationException e) {
96.             throw new RuntimeException(e);
97.         } catch (IllegalAccessException e) {
98.             throw new RuntimeException(e);
99.         } catch (ClassNotFoundException e) {
100.             throw new RuntimeException(e);
101.         }
102.     }
104.     private interface TableContentWriter<LINETYPE> {
105.         void writeLine(LINETYPE line, PrintWriter writer);
106.     }
107. }

1. public class TestBean {
3. private String test;
5. public TestBean(String test){
6.  setTest(test);
7. }
8. public String getTest() {return test;}
9. public void setTest(String test) {this.test = test;}
10. public boolean equals(TestBean bean){
11.  return this.getTest().equals(bean.getTest());
12. }
13. }

1. TestBean t1 = new TestBean("T1" );
2.  TestBean t2 = new TestBean("T2" );
3.  TestBean t3 = new TestBean("T1" );
4.  System.out.println("On ajoute T1" );
5.  set.add(t1);
6.  System.out.println("On ajoute T2" );
7.  set.add(t2);
8.  System.out.println("On teste la présence de T3 "+set.contains(t3));

1. private static <ENTITY_TYPE> MyCriteria<ENTITY_TYPE> createCriteria(Session session) {
2.         Class<ENTITY_TYPE> clazz = ????
3.         return new MyCriteria<ENTITY_TYPE>(session.createCriteria(clazz));
4.     }