import java.io.File;
import java.io.IOException;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.sanselan.ImageReadException;
import org.apache.sanselan.ImageWriteException;

import exifremover.exifremover.model.EXIFRemover;

/**
* Command line interface for exifremover.
*
* @author deque
*
*/
public class CLI {

    private static final String TEMP_DIR = \"temp\";
    private static final String VERSION = \"EXIFRemover 0.1\";
    private static final String USAGE = \"exifremover -d <filename/folder>\"
            + \" [-dest <filename/folder>]\";

    private static final String FILE_SEPARATOR = System
            .getProperty(\"file.separator\");

    public static void main(String[] args) {
        new CLI(args);
    }

    /**
     * Initializes options, invokes parsing of command line arguments.
     *
     * @param args
     *            the command line arguments
     */
    public CLI(String[] args) {
        Options options = initOptions();
        parseCommandLine(args, options);
    }

    /**
     * Parses arguments for available options.
     *
     * @param args
     *            the command line arguments
     * @param options
     *            the command line options for which the arguments are parsed
     */
    private void parseCommandLine(String[] args, Options options) {
        CommandLineParser parser = new PosixParser();
        try {
            CommandLine line = parser.parse(options, args);

            if (line.hasOption(\"version\")) {
                System.out.println(VERSION);
            }
            if (line.hasOption(\"help\") || args.length == 0) {
                showHelp(options);
            }
            if (line.hasOption(\"show-exif\")) {
                showExif(line);
            }
            if (line.hasOption(\"delete-exif\")) {
                deleteEXIF(line);
            }
        } catch (ParseException e) {
            System.err.println(e.getMessage());
        } catch (ImageWriteException e) {
            System.err.println(e.getMessage());
        } catch (IOException e) {
            System.err.println(e.getMessage());
        } catch (ImageReadException e) {
            System.err.println(e.getMessage());
        }
    }

    /**
     * Prints out all EXIF data found in given file.
     *
     * @param line
     *            command line that contains the image path
     * @throws IOException
     * @throws ImageReadException
     */
    private void showExif(CommandLine line) throws IOException,
            ImageReadException {
        File file = new File(line.getOptionValue(\"show-exif\"));
        EXIFRemover remover = new EXIFRemover(file);
        System.out.println(remover.getExifData());
    }

    /**
     * Prints out help information like usage and available options.
     *
     * @param options
     *            command line options to be shown
     */
    private void showHelp(Options options) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(USAGE, options);
    }

    /**
     * Removes EXIF data from a single image file or all image files in a folder
     * given as command line argument.
     *
     * If a folder is given, it saves the resulting images into destination
     * folder. A TEMP_DIR is created if no destination is given (this is mainly
     * for security reasons, so you are not able to overwrite a whole folder of
     * images by mistake).
     *
     * If a single image file is given, it saves the resulting image into a
     * given destination. If there is no destination, the image file is
     * overwritten, which means EXIF data of the original file is lost unless
     * you have a copy.
     *
     * @param line
     *            command line that contains the paths for source and maybe
     *            destination
     * @throws IOException
     * @throws ImageReadException
     * @throws ImageWriteException
     */
    private void deleteEXIF(CommandLine line) throws IOException,
            ImageReadException, ImageWriteException {
        File source = new File(line.getOptionValue(\"delete-exif\"));
        // if no destination folder given, assign source folder to dest
        File dest = line.hasOption(\"dest\") ? new File(
                line.getOptionValue(\"dest\")) : source;

        if (source.isDirectory()) {
            deleteEXIFFromDir(source, dest);
        } else {
            deleteEXIFForSingleFile(source, dest);
        }
    }

    /**
     * Removes EXIF data from all files in a given source directory and saves
     * new images into the destination directory. Destination directory is
     * created if it doesn't exist.
     *
     * @param source
     *            source folder that contains the image files
     * @param dest
     *            destination folder where the new images are saved to
     */
    private void deleteEXIFFromDir(File source, File dest) {
        assert source.isDirectory();
        if (!dest.isDirectory()) {
            if (dest.exists()) {
                System.err.println(\"destination file is no directory\");
                return;
            } else {
                dest.mkdir();
            }

        }
        // create temp folder if destination folder equals source folder
        if (dest.equals(source)) {
            removeAllEXIFFromFolder(source, new File(dest.getAbsolutePath()
                    + FILE_SEPARATOR + TEMP_DIR));
        } else {
            removeAllEXIFFromFolder(source, dest);
        }
    }

    /**
     * Removes EXIF data from a single image file which is the source file.
     * Resulting images is saved into the destination file which may be the same
     * as the source file (in that case the image is overwritten).
     *
     * @param source
     *            source folder that contains the image files
     * @param dest
     *            destination folder where the new images are saved to
     * @throws IOException
     * @throws ImageReadException
     * @throws ImageWriteException
     */
    private void deleteEXIFForSingleFile(File source, File dest)
            throws IOException, ImageReadException, ImageWriteException {
        EXIFRemover remover = new EXIFRemover(source);
        remover.removeEXIFData(dest);
        System.out.println(\"All EXIF data successfully removed from \"
                + source.getAbsolutePath());
        System.out.println(\"Result saved in \" + dest.getAbsolutePath());
    }

    /**
     * Deletes EXIF information from every file in a given source folder.
     * Resulting images are saved the destination folder. The given arguments
     * files must be directories.
     *
     * Directories within the source folder are ignored. Everything else will be
     * treated as an image.
     *
     * @param srcFolder
     *            source folder that contains the image files
     * @param destFolder
     *            destination folder where the new images are saved to
     */
    private void removeAllEXIFFromFolder(File srcFolder, File destFolder) {
        assert srcFolder.isDirectory() && destFolder.isDirectory();
        File[] files = srcFolder.listFiles();

        if (!destFolder.exists()) {
            destFolder.mkdir();
        }
        for (File file : files) {
            if (file.isFile()) { // make sure that file is no directory

                try {
                    EXIFRemover remover = new EXIFRemover(file);
                    File destFile = new File(destFolder.getAbsolutePath()
                            + FILE_SEPARATOR + file.getName());
                    remover.removeEXIFData(destFile);
                    System.out.println(\"created file \"
                            + destFile.getAbsolutePath());
                } catch (IOException e) {
                    System.err.println(\"Can not convert or read file \"
                            + file.getAbsolutePath());
                } catch (ImageReadException e) {
                    System.err.println(\"Unable to remove EXIF data from \"
                            + file.getAbsolutePath());
                } catch (ImageWriteException e) {
                    System.err.println(\"Unable to remove EXIF data from \"
                            + file.getAbsolutePath());
                }
            }
        }
    }

    /**
     * Initializes command line options like d, s, dest, help.
     *
     * @return initialized options
     */
    private Options initOptions() {
        Options options = new Options();

        options.addOption(\"v\", \"version\", false, \"show version\");
        options.addOption(\"h\", \"help\", false, \"print help message\");

        options.addOption(\"s\", \"show-exif\", true, \"show exif data\");
        options.getOption(\"s\").setArgName(\"filename\");

        options.addOption(\"d\", \"delete-exif\", true,
                \"delete all exif data of given file(s)\");
        options.getOption(\"d\").setArgName(\"filename\");

        options.addOption(\"dest\", true, \"save changed image(s) into file\");
        options.getOption(\"dest\").setArgName(\"filename\");

        return options;
    }

}

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
* A helper class for file input and output.
*
* @author deque
*
*/
public class FileIO {

    /**
     * @param file
     *            file to get the bytes from
     * @return byte array that represents the given file
     * @throws IOException
     */
    public static byte[] getBytesFromFile(File file) throws IOException {
        byte[] data = null;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(file);
            data = new byte[(int) file.length()];
            fileInputStream.read(data);
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return data;
    }

}

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import org.apache.sanselan.ImageReadException;
import org.apache.sanselan.ImageWriteException;
import org.apache.sanselan.Sanselan;
import org.apache.sanselan.common.IImageMetadata;
import org.apache.sanselan.formats.jpeg.exifRewrite.ExifRewriter;

import exifremover.exifremover.FileIO;

/**
* A class that utilizes the sanselan library to show or remove EXIF data
*
* @author deque
*
*/
public class EXIFRemover {

    private final File image;
    private final byte[] imageBytes;

    /**
     * Constructor. Retrieves image bytes from given image file.
     *
     * @param image
     *            file that shall be treated
     * @throws IOException
     */
    public EXIFRemover(File image) throws IOException {
        this.image = image;
        imageBytes = FileIO.getBytesFromFile(image);
    }

    /**
     * @return String that describes the meta data of the given image file.
     * @throws ImageReadException
     * @throws IOException
     */
    public String getExifData() throws ImageReadException, IOException {
        IImageMetadata metdata = Sanselan.getMetadata(imageBytes);
        return metdata.toString();
    }

    /**
     * @return image file
     */
    public File getImageFile() {
        return image;
    }

    /**
     * Completely deletes EXIF data from the extracted image bytes. Saves the
     * resulting images bytes into the destination file.
     *
     * @param dest
     *            the destination file
     * @throws ImageReadException
     * @throws ImageWriteException
     * @throws IOException
     */
    public void removeEXIFData(File dest) throws ImageReadException,
            ImageWriteException, IOException {
        OutputStream os = null;
        try {
            os = new FileOutputStream(dest);
            ExifRewriter exifWriter = new ExifRewriter();
            exifWriter.removeExifMetadata(imageBytes, os);
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

package model;

import java.awt.Color;
import java.awt.Graphics;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class Boid {

	private static int boidNr;
	private final int panelWidth;
	private final int panelHeight;
	private Vector position;
	private Vector positionToDraw;
	private Vector velocity = new Vector(0, 0);
	private Color color;
	private final static List<Boid> boids = new LinkedList<Boid>();
	private static int updateSkip;
	private static int updates = 1;
	private static int velocityLimit;
	private static int radiusLimit;
	private static int flockRadius;

	public Boid(int pwidth, int pheight) {
		this.panelWidth = pwidth;
		this.panelHeight = pheight;
		setRandomPosition();
		setRandomColor();
	}

	public Boid(Boid boid) {
		this.panelWidth = boid.panelWidth;
		this.panelHeight = boid.panelHeight;
		this.position = new Vector(boid.position);
		this.positionToDraw = new Vector(boid.positionToDraw);
		this.velocity = new Vector(boid.velocity);
		this.color = boid.color;
	}

	public static void initBoids(int pwidth, int pheight) {
		for (int i = 0; i < boidNr; i++) {
			boids.add(new Boid(pwidth, pheight));
		}
	}

	public static void drawBoids(Graphics g) {
		for (Boid boid : boids) {
			boid.draw(g);
		}
	}

	public static void updateBoids() {
		updates++;
		if (updates == updateSkip) {
			updates = 1;
			for (Boid boid : boids) {
				boid.updateWithBounds();
			}
		}
		for (Boid boid : boids) {
			// makes the boids move slowlier
			boid.positionToDraw = new Vector(boid.position);
			boid.positionToDraw.subtract(boid.velocity);
			Vector ivel = new Vector(boid.velocity);
			ivel.multiply(updates / (double) updateSkip);
			boid.positionToDraw.add(ivel);
		}
	}

	private void setRandomPosition() {
		Random rand = new Random();
		position = new Vector();
		position.x = rand.nextInt(panelWidth);
		position.y = rand.nextInt(panelHeight);
	}

	private void draw(Graphics g) {
		g.setColor(color);
		g.fillOval((int) positionToDraw.x, (int) positionToDraw.y, 10, 10);
	}

	private void setRandomColor() {
		Random rand = new Random();
		this.color = new Color(rand.nextInt(256), rand.nextInt(256),
				rand.nextInt(256));
	}

	private void updateWithoutBounds() {
		velocity.add(rule1(), rule2(), rule3());
		limitVelocity();
		position.add(velocity);

		if (position.x > panelWidth) {
			position.x = 0;
		}
		if (position.x < 0) {
			position.x = panelWidth;
		}
		if (position.y > panelHeight) {
			position.y = 0;
		}
		if (position.y < 0) {
			position.y = panelHeight;
		}
	}

	private void updateWithBounds() {
		velocity.add(rule1(), rule2(), rule3());
		limitVelocity();
		position.add(velocity);

		if (position.x > panelWidth) {
			position.x = panelWidth;
			velocity.x = -velocity.x;
		}
		if (position.x < 0) {
			position.x = 0;
			velocity.x = -velocity.x;
		}
		if (position.y > panelHeight) {
			position.y = panelHeight;
			velocity.y = -velocity.y;
		}
		if (position.y < 0) {
			position.y = 0;
			velocity.y = -velocity.y;
		}
	}

	/**
	 * boids try to fly towards the centre of mass of neighbouring boids
	 * 
	 * @return resulting vector
	 */
	private Vector rule1() {
		Vector center = new Vector(0, 0);
		List<Boid> flock = flock();
		for (Boid boid : flock) {
			if (!boid.equals(this)) {
				center.add(boid.position);
			}
		}
		center.divide(flock.size() - 1);
		Vector result = new Vector(center);
		result.subtract(this.position);
		result.divide(100);
		return result;
	}

	/**
	 * try to keep a small distance away from other objects
	 * 
	 * @return
	 */
	private Vector rule2() {
		Vector result = new Vector(0, 0);
		for (Boid boid : flock()) {
			if (!boid.equals(this)) {
				if (isClose(boid.position)) {
					Vector sub = new Vector(boid.position);
					sub.subtract(position);
					result.subtract(sub);
				}
			}
		}
		return result;
	}

	/**
	 * boids try to match velocity with near boids
	 * 
	 * @return
	 */
	private Vector rule3() {
		Vector pvj = new Vector(0, 0);
		List<Boid> flock = flock();
		for (Boid boid : flock) {
			if (!boid.equals(this)) {
				pvj.add(boid.velocity);
			}
		}
		pvj.divide(flock.size() - 1);
		pvj.subtract(velocity);
		pvj.divide(:);
		return pvj;
	}

	private void limitVelocity() {
		if (velocity.length() > velocityLimit) {
			velocity.divide(velocity.length());
			velocity.multiply(velocityLimit);
		}
	}

	public List<Boid> flock() {
		List<Boid> flock = new LinkedList<Boid>();
		for (Boid boid : boids) {
			if (isInFlock(boid.position)) {
				flock.add(boid);
			}
		}
		return flock;
	}

	private boolean isInFlock(final Vector pos) {
		Vector range = new Vector(position);
		range.subtract(pos);
		return range.length() < flockRadius;
	}

	private boolean isClose(final Vector pos) {
		Vector range = new Vector(position);
		range.subtract(pos);
		return range.length() < radiusLimit;
	}

	public static void setOptions(Options options) {
		velocityLimit = options.velocityLimit;
		radiusLimit = options.radiusLimit;
		boidNr = options.boidNr;
		updateSkip = options.speedReduction;
		flockRadius = options.flockRadius;
	}

}

import java.io.*;
import java.net.*;

public class IRCConnection {

    private String tmp = null;
    private String nick = \"Test5000\";
    private String channel = \"#back2hack\";

    public void connectToIRC(String url, int port) {
        try {
            Socket sock = new Socket(url, port);
            BufferedReader br = new BufferedReader(new InputStreamReader(sock
                    .getInputStream()));
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sock
                    .getOutputStream()));

            // Connection shizzl
            bw.write(\"NICK \" + nick + \"\r\n\");
            bw.write(\"USER \" + nick + \" aaa bbb ccc\r\n\");

            // Ping Pong Shizzle

            while ((tmp = br.readLine()) != null) {
                System.out.println(tmp);
                if (tmp.startsWith(\"PING \")) {
                    bw.write(\"PONG \" + tmp.substring(5) + \"\r\n\");
                    bw.flush();
                }

                // 004 = erfolgreich connected
                if (tmp.indexOf(\"004\") >= 0) {
                    break;
                }
                // Falls nick schon in use is
                else if (tmp.indexOf(\"433\") >= 0) {
                    System.out.println(\"Nickname already in use\");
                    return;
                }

            }

            // join channel

            bw.write(\"JOIN \" + channel + \"\r\n\");
            bw.write(\"PRIVMSG \" + channel + \" :blaaa\r\n\");
            bw.flush();

            // chat weiterhin einlesen
            while ((tmp = br.readLine()) != null) {
                System.out.println(tmp);
                // antworten auf bla
                if ((tmp.contains(\"PRIVMSG\"))) {
                    if ((tmp.contains(\"bla\"))) {
                        bw.write(\"PRIVMSG \" + channel + \" :blaaaaaaa\r\n\");
                    }
                }
                // Still looking for ping pong shizzle
                else if (tmp.startsWith(\"PING \")) {
                    bw.write(\"PONG \" + tmp.substring(5) + \"\r\n\");
                    bw.flush();
                }

            }

        } catch (UnknownHostException e) {
            System.out.println(\"host fail\");
        } catch (IOException e) {

        }
    }

    public static void main(String[] args) {
        new IRCConnection().connectToIRC(\"irc.freenode.org\", 6667);
    }

}

package control;

import gui.MainFrame;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

import javax.swing.SwingUtilities;

public class ImageSteno {

	public static final int ALPHA = 0;
	public static final int RED = 1;
	public static final int GREEN = 2;
	public static final int BLUE = 3;

	private BufferedImage mask;
	private BufferedImage toHide;
	private BufferedImage toExtract;

	private Quality quality = Quality.GOOD;

	public static void main(String[] args) throws IOException {

		try {
			SwingUtilities.invokeAndWait(new Runnable() {
				@Override
				public void run() {
					new MainFrame();
				}
			});
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}

	public void setQuality(Quality quality) {
		this.quality = quality;
	}

	public BufferedImage extractHiddenImage() throws NoImageException {
		if (toExtract == null) {
			throw new NoImageException();
		}
		return extractHiddenImage(toExtract);
	}

	public BufferedImage extractHiddenImage(BufferedImage img) {
		BufferedImage imgCopy = copyImage(img);
		for (int x = 0; x < imgCopy.getWidth(); x++) {
			for (int y = 0; y < imgCopy.getHeight(); y++) {
				int rgb = imgCopy.getRGB(x, y);
				rgb = extractRGB(rgb);
				imgCopy.setRGB(x, y, rgb);
			}
		}
		return imgCopy;
	}

	public static BufferedImage copyImage(BufferedImage image) {
		BufferedImage destImage = new BufferedImage(image.getWidth(),
				image.getHeight(), BufferedImage.TYPE_INT_ARGB);

		Graphics2D g = destImage.createGraphics();
		g.drawImage(image, null, 0, 0);
		g.dispose();
		return destImage;
	}

	public BufferedImage hideImage() throws NoImageException {
		if (mask == null || toHide == null) {
			throw new NoImageException();
		}
		BufferedImage maskCopy = getScaledInstance(copyImage(mask),
				toHide.getWidth(), toHide.getHeight(),
				RenderingHints.VALUE_INTERPOLATION_BICUBIC, false);

		for (int x = 0; x < toHide.getWidth(); x++) {
			for (int y = 0; y < toHide.getHeight(); y++) {
				int destRGB = toHide.getRGB(x, y);
				int oldRGB = maskCopy.getRGB(x, y);
				int newRGB = computeNewRGB(oldRGB, destRGB);
				maskCopy.setRGB(x, y, newRGB);
			}
		}
		return maskCopy;
	}

	private int extractRGB(int rgb) {
		int[] rgbArr = getRGBArray(rgb);
		for (int i = 1; i <= 3; i++) {
			rgbArr[i] = rgbArr[i] & quality.leastBitsSum;
			rgbArr[i] = rgbArr[i] << quality.shift;
		}
		return getRGBFromArray(rgbArr);
	}

	private int computeNewRGB(int oldRGB, int destRGB) {
		int[] dest = getRGBArray(destRGB);
		int[] old = getRGBArray(oldRGB);
		for (int i = 1; i <= 3; i++) {
			old[i] = old[i] & quality.cuttingMask;
			dest[i] = dest[i] >> quality.shift;
			old[i] += dest[i];
		}
		return getRGBFromArray(old);
	}

	private int getRGBFromArray(int[] rgbArr) {
		return new Color(rgbArr[RED], rgbArr[GREEN], rgbArr[BLUE]).getRGB();
	}

	private int[] getRGBArray(int rgb) {
		return new int[] { (rgb >> 24) & 0xff, (rgb >> 16) & 0xff,
				(rgb >> 8) & 0xff, rgb & 0xff };
	}
}

public enum Quality {
	
	GOOD(4), MEDIUM(3), BAD(2);
	
	public int leastBitsSum;
	public int shift;
	public int cuttingMask;
	
	private Quality(int bits){
		computeLeastBitsSum(bits);
		computeCuttingMask(bits);
		computeShift(bits);
	}

	private void computeShift(int bits) {
		shift = 8 - bits;
	}

	private void computeLeastBitsSum(int bits) {
		leastBitsSum = 0;
		for(int i = 0; i < bits; i++){
			leastBitsSum += Math.pow(2, i);
		}
	}

	private void computeCuttingMask(int bits) {
		cuttingMask = 255 - leastBitsSum;
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class FileIO {

	public static void main(String[] args) {
		writeFile(\"test.txt\");
		readFile(\"test.txt\");
	}

	/**
	 * reads a given textfile and prints it out
	 * 
	 * @param filename
	 */
	public static void readFile(String filename) {
		FileInputStream fin = null;
		DataInputStream din = null;
		try {
			fin = new FileInputStream(filename);
			din = new DataInputStream(fin);
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					din));
			String line;

			while ((line = reader.readLine()) != null) { // read line by line
				System.out.println(line); // print the content
			}
		} catch (FileNotFoundException e) {
			System.err.println(\"File \" + filename + \" not found\");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fin != null) {
					fin.close();
				}
				if (din != null) {
					din.close(); // always close your streams within finally
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * writes \"Hello World\" into a textfile
	 * 
	 * @param filename
	 */
	public static void writeFile(String filename) {
		FileWriter writer = null;
		BufferedWriter out = null;
		try {
			writer = new FileWriter(filename);
			out = new BufferedWriter(writer);
			out.write(\"Hello World\");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
                                if (out != null) {
					out.close();
				}
				if (writer != null) { 
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

public class Person {
	
	private String name;
	private int age;
	
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
}

name:Peter
age:12

public static String newline = System.getProperty(\"line.separator\");

out.write(\"name:\" + person.getName() + newline + \"age:\"
					+ person.getAge());

String name = null; //initialize variables for the Person attributes
Integer age = null;
try {
	fin = new FileInputStream(filename);
	din = new DataInputStream(fin);
	BufferedReader reader = new BufferedReader(new InputStreamReader(din));
	String line;
	while ((line = reader.readLine()) != null) { 
		String[] attributes = line.split(\":\"); //split the line
		if(attributes != null && attributes.length == 2){ //make sure not to go over bounds 
                                                                      //there may be an empty line
			if(attributes[0].equals(\"name\")){ //get name attribute
				name = attributes[1];
			}
			if(attributes[0].equals(\"age\")){ //get age attribute
				age = Integer.parseInt(attributes[1]);
			}
		}
	}
	return new Person(name, age); //return the new person object

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class FileIO {

	public static String newline = System.getProperty(\"line.separator\");

	public static void main(String[] args) {
		Person peter = new Person(\"Peter\", 12);
		writeFile(\"peter.txt\", peter);
		Person readPerson = readFile(\"peter.txt\");
		System.out.println(\"Persons name: \" + readPerson.getName());
		System.out.println(\"Persons age: \" + readPerson.getAge());
	}

	/**
	 * reads a given textfile and prints it out
	 * 
	 * @param filename
	 */
	public static Person readFile(String filename) {
		FileInputStream fin = null;
		DataInputStream din = null;
		String name = null;
		Integer age = null;
		try {
			fin = new FileInputStream(filename);
			din = new DataInputStream(fin);
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					din));
			String line;
			while ((line = reader.readLine()) != null) { 
				String[] attributes = line.split(\":\");
				if(attributes != null && attributes.length == 2){
					if(attributes[0].equals(\"name\")){
						name = attributes[1];
					}
					if(attributes[0].equals(\"age\")){
						age = Integer.parseInt(attributes[1]);
					}
				}
			}
			return new Person(name, age);
		} catch (FileNotFoundException e) {
			System.err.println(\"File \" + filename + \" not found\");
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NumberFormatException e){
			System.err.println(\"Value after age was no number\");
		} finally {
			try {
				if (fin != null) {
					fin.close();
				}
				if (din != null) {
					din.close(); // always close your streams within finally
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	/**
	 * writes \"Hello World\" into a textfile
	 * 
	 * @param filename
	 */
	public static void writeFile(String filename, Person person) {
		FileWriter writer = null;
		BufferedWriter out = null;
		try {
			writer = new FileWriter(filename);
			out = new BufferedWriter(writer);
			out.write(\"name:\" + person.getName() + newline + \"age:\"
					+ person.getAge());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
				}
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

public class Person implements Serializable {

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class FileIO {

	public static String newline = System.getProperty(\"line.separator\");

	public static void main(String[] args) {
		Person peter = new Person(\"Peter\", 12);
		writeFileByObjectStream(\"peter.txt\", peter);
		Object obj = readFileByObjectStream(\"peter.txt\");
		if (obj instanceof Person) { //do a save typecast
			Person person = (Person) obj;
			System.out.println(\"Persons name: \" + person.getName());
			System.out.println(\"Persons age: \" + person.getAge());
		}
	}

	public static void writeFileByObjectStream(String filename, Object object) {
		ObjectOutputStream oos = null;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(filename);
			oos = new ObjectOutputStream(fos);

			oos.writeObject(object);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (oos != null) {
					oos.close();
				}
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static Object readFileByObjectStream(String filename) {
		Object obj = null;
		ObjectInput in = null;
		InputStream fis = null;
		try {
			fis = new FileInputStream(filename);
			in = new ObjectInputStream(fis);
			obj = in.readObject();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (in != null) {
					in.close();
				}
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return obj;
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import com.thoughtworks.xstream.XStream;

public class FileIO {

	public static String newline = System.getProperty(\"line.separator\");

	public static void main(String[] args) {
		Person peter = new Person(\"Peter\", 12);
		writeXML(\"peter.txt\", peter);
		Object obj = readXML(\"peter.txt\");
		if (obj instanceof Person) {
			Person person = (Person) obj;
			System.out.println(\"Persons name: \" + person.getName());
			System.out.println(\"Persons age: \" + person.getAge());
		}
	}
	
	public static void writeXML(String filename, Object object) {
		XStream xstream = new XStream();
		FileWriter writer = null;

		try {
			writer = new FileWriter(filename);
			xstream.toXML(object, writer);

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static Object readXML(String filename) {
		FileReader reader = null;
		Object obj = null;

		try {
			reader = new FileReader(filename);
			XStream xstream = new XStream();
			obj = xstream.fromXML(reader);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		return obj;
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import com.thoughtworks.xstream.XStream;

public class FileIO {

	public static String newline = System.getProperty(\"line.separator\");

	public static void main(String[] args) {
		Person peter = new Person(\"Peter\", 12);
		writeXML(\"peter.txt\", peter);
		Object obj = readXML(\"peter.txt\");
		if (obj instanceof Person) {
			Person person = (Person) obj;
			System.out.println(\"Persons name: \" + person.getName());
			System.out.println(\"Persons age: \" + person.getAge());
		}
	}
	
	public static void writeXML(String filename, Object object) {
		XStream xstream = new XStream();
		FileWriter writer = null;

		try {
			writer = new FileWriter(filename);
			xstream.toXML(object, writer);

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static Object readXML(String filename) {
		FileReader reader = null;
		Object obj = null;

		try {
			reader = new FileReader(filename);
			XStream xstream = new XStream();
			obj = xstream.fromXML(reader);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		return obj;
	}

	public static Person readFile(String filename) {
		FileInputStream fin = null;
		DataInputStream din = null;
		String name = null;
		Integer age = null;
		try {
			fin = new FileInputStream(filename);
			din = new DataInputStream(fin);
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					din));
			String line;
			while ((line = reader.readLine()) != null) {
				String[] attributes = line.split(\":\");
				if (attributes != null && attributes.length == 2) {
					if (attributes[0].equals(\"name\")) {
						name = attributes[1];
					}
					if (attributes[0].equals(\"age\")) {
						age = Integer.parseInt(attributes[1]);
					}
				}
			}
			return new Person(name, age);
		} catch (FileNotFoundException e) {
			System.err.println(\"File \" + filename + \" not found\");
		} catch (IOException e) {
			e.printStackTrace();
		} catch (NumberFormatException e) {
			System.err.println(\"Value after age was no number\");
		} finally {
			try {
				if (fin != null) {
					fin.close();
				}
				if (din != null) {
					din.close(); // always close your streams within finally
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public static void writeFile(String filename, Person person) {
		FileWriter writer = null;
		BufferedWriter out = null;
		try {
			writer = new FileWriter(filename);
			out = new BufferedWriter(writer);
			out.write(\"name:\" + person.getName() + newline + \"age:\"
					+ person.getAge());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
				}
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void writeFileByObjectStream(String filename, Object object) {
		ObjectOutputStream oos = null;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(filename);
			oos = new ObjectOutputStream(fos);

			oos.writeObject(object);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (oos != null) {
					oos.close();
				}
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static Object readFileByObjectStream(String filename) {
		Object obj = null;
		ObjectInput in = null;
		InputStream fis = null;
		try {
			fis = new FileInputStream(filename);
			in = new ObjectInputStream(fis);
			obj = in.readObject();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (in != null) {
					in.close();
				}
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return obj;
	}
}