Ugur Dönmez

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.Vector;
 
public class ScannerExample {
 
	public static void main (String [] args) {
		Vector<Integer> vector = new Vector<Integer>();
		Scanner scanner;
		try {
			scanner = new Scanner(new File("map.txt"));
			Integer i;
			while (scanner.hasNextInt()) {
				i =  scanner.nextInt();
				vector.addElement(i);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
 
		System.out.println("the elements of vector: " + vector);
		System.out.println(vector.size());
	}
}

import java.util.Random;
import java.util.Vector;
 
public class VectorDeneme {
 
	public static void main (String [] args) {
		Vector<Integer> vector =  new Vector<Integer>();
		Random generator = new Random();
 
		int randomInteger;
		for (int i = 0 ; i < 10 ; i++) {
			randomInteger = generator.nextInt( 100 );
			vector.add(randomInteger);
		}
 
		System.out.println("the elements of vector: " + vector);
	        System.out.println("The size of vector are: " + vector.size());
	        System.out.println("The elements at position 2 is: " + vector.elementAt(2));
	        System.out.println("The first element of vector is: " + vector.firstElement());
	        System.out.println("The last element of vector is: " + vector.lastElement());
 
	        vector.removeElementAt(2);
	        vector.removeElementAt(8);
 
	        System.out.println("the elements of vector: " + vector);
	}
}

import java.io.*;
 
public class UnserializeBoolean {
 
    public UnserializeBoolean() {
        Boolean booleanData = null;
        try {
            FileInputStream fis = new FileInputStream("boolean.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            booleanData = (Boolean) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        System.out.println("Unserialized boolen from " + "boolean.ser");
        System.out.println("Boolean data: " + booleanData);
        System.out.println("Compare data with true: " + booleanData.equals(new Boolean("true")));
    }
 
    public static void main(String [] args) {
        UnserializeBoolean uab = new UnserializeBoolean();
    }
}

import java.io.*;
 
public class SerializeBoolean {
 
    public SerializeBoolean() {
        Boolean booleanDAta = new Boolean("true");
        try {
            FileOutputStream fos = new FileOutputStream("boolean.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(booleanDAta);
            oos.close();
        } catch (IOException ie) {
            ie.printStackTrace();
        }
    }
 
    public static void main(String [] args) {
        SerializeBoolean ab = new SerializeBoolean();
    }
}

 
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import javax.xml.crypto.Data;
 
 
public class ReadWriteMap {
    final Map<String,Data> m = new TreeMap<String,Data>();
    final ReentrantReadWriteLock rw1 = new ReentrantReadWriteLock();
    final Lock r = rw1.readLock();
    final Lock w = rw1.writeLock();
 
    public Data get(String key) {
        r.lock();
        try {
            return m.get(key);
        } finally  {
            r.unlock();
        }
    }
 
    public Data put(String key,Data value) {
        w.lock();
        try {
            return m.put(key, value);
        }
        finally {
            w.unlock();
        }
    }
 
    public void clear() {
        w.lock();
        try {
            m.clear();
        }
        finally {
            w.unlock();
        }
    }
}

 class Producer implements Runnable {
   private final BlockingQueue queue;
   Producer(BlockingQueue q) { queue = q; }
   public void run() {
     try {
       while(true) { queue.put(produce()); }
     } catch (InterruptedException ex) { ... handle ...}
   }
   Object produce() { ... }
 }
 
 class Consumer implements Runnable {
   private final BlockingQueue queue;
   Consumer(BlockingQueue q) { queue = q; }
   public void run() {
     try {
       while(true) { consume(queue.take()); }
     } catch (InterruptedException ex) { ... handle ...}
   }
   void consume(Object x) { ... }
 }
 
 class Setup {
   void main() {
     BlockingQueue q = new SomeQueueImplementation();
     Producer p = new Producer(q);
     Consumer c1 = new Consumer(q);
     Consumer c2 = new Consumer(q);
     new Thread(p).start();
     new Thread(c1).start();
     new Thread(c2).start();
   }
 }