public static void main(String[] args) throws DocumentException, IOException { 
   
  	Document document = new Document(); 
  	String path = System.getProperty("user.home") + "\\Desktop"; 
  	PdfWriter.getInstance(document,new FileOutputStream(path+"\\abc.pdf")); 
  	BaseFont bf1 = BaseFont.createFont(BaseFont.TIMES_ROMAN, "iso-8859-9", BaseFont.EMBEDDED); 
          Font font1 = new Font(bf1); 
          document.open(); 
           
          Paragraph paragraph2 = new Paragraph(); 
           
          paragraph2.setAlignment(Element.ALIGN_JUSTIFIED); 
          paragraph2.setFont(font1); 
          paragraph2.setIndentationLeft(20); 
          paragraph2.setIndentationRight(20); 
          paragraph2.add("HelloWorld HelloWorld HelloWorld HelloWorld HelloWorld HelloWorld HelloWorldHelloWorldHelloWorldHelloWorld HelloWorld HelloWorld HelloWorld HelloWorldHelloWorldHelloWorld"); 
          document.add(paragraph2); 
           
          document.close(); 
  	} 
   
  

import java.io.File; 
  import java.io.FileInputStream; 
  import java.io.FileOutputStream; 
  import java.io.IOException; 
  import java.nio.channels.FileChannel; 
  import java.util.Arrays; 
  import java.util.HashSet; 
  import java.util.Set; 
   
   
  /** 
   * Utility class for synchronizing files/directories. 
   * 
   * @author Emmanuel Bernard 
   * @author Sanne Grinovero 
   * @author Hardy Ferentschik 
   */ 
  public abstract class FileHelper { 
   
    private static final int FAT_PRECISION = 2000; 
    public static final long DEFAULT_COPY_BUFFER_SIZE = 16 * 1024 * 1024; // 16 MB 
   
   
    public static boolean areInSync(File source, File destination) throws IOException { 
      if ( source.isDirectory() ) { 
        if ( !destination.exists() ) { 
          return false; 
        } 
        else if ( !destination.isDirectory() ) { 
          throw new IOException( 
              "Source and Destination not of the same type:" 
                  + source.getCanonicalPath() + " , " + destination.getCanonicalPath() 
          ); 
        } 
        String[] sources = source.list(); 
        Set<String> srcNames = new HashSet<String>( Arrays.asList( sources ) ); 
        String[] dests = destination.list(); 
   
        // check for files in destination and not in source 
        for ( String fileName : dests ) { 
          if ( !srcNames.contains( fileName ) ) { 
            return false; 
          } 
        } 
   
        boolean inSync = true; 
        for ( String fileName : sources ) { 
          File srcFile = new File( source, fileName ); 
          File destFile = new File( destination, fileName ); 
          if ( !areInSync( srcFile, destFile ) ) { 
            inSync = false; 
            break; 
          } 
        } 
        return inSync; 
      } 
      else { 
        if ( destination.exists() && destination.isFile() ) { 
          long sts = source.lastModified() / FAT_PRECISION; 
          long dts = destination.lastModified() / FAT_PRECISION; 
          return sts == dts; 
        } 
        else { 
          return false; 
        } 
      } 
    } 
   
    public static void synchronize(File source, File destination, boolean smart) throws IOException { 
      synchronize( source, destination, smart, DEFAULT_COPY_BUFFER_SIZE ); 
    } 
   
    public static void synchronize(File source, File destination, boolean smart, long chunkSize) throws IOException { 
      if ( chunkSize <= 0 ) { 
        System.out.println("Chunk size must be positive: using default value." ); 
        chunkSize = DEFAULT_COPY_BUFFER_SIZE; 
      } 
      if ( source.isDirectory() ) { 
        if ( !destination.exists() ) { 
          if ( !destination.mkdirs() ) { 
            throw new IOException( "Could not create path " + destination ); 
          } 
        } 
        else if ( !destination.isDirectory() ) { 
          throw new IOException( 
              "Source and Destination not of the same type:" 
                  + source.getCanonicalPath() + " , " + destination.getCanonicalPath() 
          ); 
        } 
        String[] sources = source.list(); 
        Set<String> srcNames = new HashSet<String>( Arrays.asList( sources ) ); 
        String[] dests = destination.list(); 
   
        //delete files not present in source 
        for ( String fileName : dests ) { 
          if ( !srcNames.contains( fileName ) ) { 
            delete( new File( destination, fileName ) ); 
          } 
        } 
        //copy each file from source 
        for ( String fileName : sources ) { 
          File srcFile = new File( source, fileName ); 
          File destFile = new File( destination, fileName ); 
          synchronize( srcFile, destFile, smart, chunkSize ); 
        } 
      } 
      else { 
        if ( destination.exists() && destination.isDirectory() ) { 
          delete( destination ); 
        } 
        if ( destination.exists() ) { 
          long sts = source.lastModified() / FAT_PRECISION; 
          long dts = destination.lastModified() / FAT_PRECISION; 
          //do not copy if smart and same timestamp and same length 
          if ( !smart || sts == 0 || sts != dts || source.length() != destination.length() ) { 
            copyFile( source, destination, chunkSize ); 
          } 
        } 
        else { 
          copyFile( source, destination, chunkSize ); 
        } 
      } 
    } 
   
    private static void copyFile(File srcFile, File destFile, long chunkSize) throws IOException { 
      FileInputStream is = null; 
      FileOutputStream os = null; 
      try { 
        is = new FileInputStream( srcFile ); 
        FileChannel iChannel = is.getChannel(); 
        os = new FileOutputStream( destFile, false ); 
        FileChannel oChannel = os.getChannel(); 
        long doneBytes = 0L; 
        long todoBytes = srcFile.length(); 
        while ( todoBytes != 0L ) { 
          long iterationBytes = Math.min( todoBytes, chunkSize ); 
          long transferredLength = oChannel.transferFrom( iChannel, doneBytes, iterationBytes ); 
          if ( iterationBytes != transferredLength ) { 
            throw new IOException( 
                "Error during file transfer: expected " 
                    + iterationBytes + " bytes, only " + transferredLength + " bytes copied." 
            ); 
          } 
          doneBytes += transferredLength; 
          todoBytes -= transferredLength; 
        } 
      } 
      finally { 
        if ( is != null ) { 
          is.close(); 
        } 
        if ( os != null ) { 
          os.close(); 
        } 
      } 
      boolean successTimestampOp = destFile.setLastModified( srcFile.lastModified() ); 
      if ( !successTimestampOp ) { 
        System.out.println("Could not change timestamp for {}. Index synchronization may be slow. " + destFile ); 
      } 
    } 
   
    public static void delete(File file) { 
      if ( file.isDirectory() ) { 
        for ( File subFile : file.listFiles() ) { 
          delete( subFile ); 
        } 
      } 
      if ( file.exists() ) { 
        if ( !file.delete() ) { 
          System.out.println( "Could not delete {}" + file ); 
        } 
      } 
    } 
  }

/** 
   * Upload a whole directory (including its nested sub directories and files) 
   * to a FTP server. 
   * 
   * @param ftpClient 
   *            an instance of org.apache.commons.net.ftp.FTPClient class. 
   * @param remoteDirPath 
   *            Path of the destination directory on the server. 
   * @param localParentDir 
   *            Path of the local directory being uploaded. 
   * @param remoteParentDir 
   *            Path of the parent directory of the current directory on the 
   *            server (used by recursive calls). 
   * @throws IOException 
   *             if any network or IO error occurred. 
   */ 
  public static void uploadDirectory(FTPClient ftpClient, 
          String remoteDirPath, String localParentDir, String remoteParentDir) 
          throws IOException { 
    
      System.out.println("LISTING directory: " + localParentDir); 
    
      File localDir = new File(localParentDir); 
      File[] subFiles = localDir.listFiles(); 
      if (subFiles != null && subFiles.length > 0) { 
          for (File item : subFiles) { 
              String remoteFilePath = remoteDirPath + "/" + remoteParentDir 
                      + "/" + item.getName(); 
              if (remoteParentDir.equals("")) { 
                  remoteFilePath = remoteDirPath + "/" + item.getName(); 
              } 
    
    
              if (item.isFile()) { 
                  // upload the file 
                  String localFilePath = item.getAbsolutePath(); 
                  System.out.println("About to upload the file: " + localFilePath); 
                  boolean uploaded = uploadSingleFile(ftpClient, 
                          localFilePath, remoteFilePath); 
                  if (uploaded) { 
                      System.out.println("UPLOADED a file to: " 
                              + remoteFilePath); 
                  } else { 
                      System.out.println("COULD NOT upload the file: " 
                              + localFilePath); 
                  } 
              } else { 
                  // create directory on the server 
                  boolean created = ftpClient.makeDirectory(remoteFilePath); 
                  if (created) { 
                      System.out.println("CREATED the directory: " 
                              + remoteFilePath); 
                  } else { 
                      System.out.println("COULD NOT create the directory: " 
                              + remoteFilePath); 
                  } 
    
                  // upload the sub directory 
                  String parent = remoteParentDir + "/" + item.getName(); 
                  if (remoteParentDir.equals("")) { 
                      parent = item.getName(); 
                  } 
    
                  localParentDir = item.getAbsolutePath(); 
                  uploadDirectory(ftpClient, remoteDirPath, localParentDir, 
                          parent); 
              } 
          } 
      } 
  } 
  /** 
   * Upload a single file to the FTP server. 
   * 
   * @param ftpClient 
   *            an instance of org.apache.commons.net.ftp.FTPClient class. 
   * @param localFilePath 
   *            Path of the file on local computer 
   * @param remoteFilePath 
   *            Path of the file on remote the server 
   * @return true if the file was uploaded successfully, false otherwise 
   * @throws IOException 
   *             if any network or IO error occurred. 
   */ 
  public static boolean uploadSingleFile(FTPClient ftpClient, 
          String localFilePath, String remoteFilePath) throws IOException { 
      File localFile = new File(localFilePath); 
    
      InputStream inputStream = new FileInputStream(localFile); 
      try { 
          ftpClient.setFileType(FTP.BINARY_FILE_TYPE); 
          return ftpClient.storeFile(remoteFilePath, inputStream); 
      } finally { 
          inputStream.close(); 
      } 
  }

import java.sql.DriverManager; 
  import java.sql.Connection; 
  import java.sql.PreparedStatement; 
  import java.sql.ResultSet; 
  import java.sql.SQLException; 
    
  public class database { 
    
    public static void main(String[] argv) throws Exception { 
    
  	System.out.println("-------- MySQL JDBC Connection Testing ------------"); 
    
  	try { 
  		Class.forName("com.mysql.jdbc.Driver"); 
  	} catch (ClassNotFoundException e) { 
  		System.out.println("Where is your MySQL JDBC Driver?"); 
  		e.printStackTrace(); 
  		return; 
  	} 
    
  	System.out.println("MySQL JDBC Driver Registered!"); 
  	Connection connection = null; 
    
  	try { 
  		connection = DriverManager.getConnection("jdbc:mysql://localhost:800/omucloud_vt","root", ""); 
    
  	} catch (SQLException e) { 
  		System.out.println("Connection Failed! Check output console"); 
  		e.printStackTrace(); 
  		return; 
  	} 
    
  	if (connection != null) { 
  		System.out.println("You made it, take control your database now!"); 
  		 
  		PreparedStatement statement = connection.prepareStatement("select * from users"); 
  	    ResultSet result = statement.executeQuery(); 
  	    while(result.next()){ 
  	    	System.out.println(result.getString(1)+" "+result.getString(2)+" "+result.getString(3)+" "+result.getString(4)+" "+result.getString(5)); 
  	    	} 
  	} else { 
  		System.out.println("Failed to make connection!"); 
  	} 
    } 
  }