• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package ChapterEight;

class Tree {
	class Node {
		public long value;

		public Node leftChild;

		public Node rightChild;

		public Node(long value) {
			this.value = value;
			leftChild = null;
			rightChild = null;
		}
	}

	public Node root;

	public Tree() {
		root = null;
	}

	// 向树中插入一个节点
	public void insert(long value) {
		Node newNode = new Node(value);
		// 树是空的
		if (root == null)
			root = newNode;
		else {
			Node current = root;
			Node parentNode;
			while (true) {
				parentNode = current;
				if (value < current.value) {
					current = current.leftChild;
					// 要插入的节点为左孩子节点
					if (current == null) {
						parentNode.leftChild = newNode;
						return;
					}
				} else {
					// 要插入的节点为右孩子节点
					current = current.rightChild;
					if (current == null) {
						parentNode.rightChild = newNode;
						return;
					}
				}
			}
		}
	}

	// 先续遍历树中的所有节点
	public void preOrder(Node currentRoot) {
		if (currentRoot != null) {
			System.out.print(currentRoot.value + " ");
			preOrder(currentRoot.leftChild);
			preOrder(currentRoot.rightChild);
		}
	}

	// 中续遍历树中的所有节点
	public void inOrder(Node currentNode) {
		if (currentNode != null) {
			inOrder(currentNode.leftChild);
			System.out.print(currentNode.value + " ");
			inOrder(currentNode.rightChild);
		}
	}

	// 后续遍历树中的所有节点
	public void postOrder(Node currentNode) {
		if (currentNode != null) {
			postOrder(currentNode.leftChild);
			postOrder(currentNode.rightChild);
			System.out.print(currentNode.value + " ");
		}
	}

	public void traverse(int traverseType) {
		switch (traverseType) {
		case 1:
			preOrder(root);
			break;
		case 2:
			inOrder(root);
			break;
		case 3:
			postOrder(root);
			break;
		default:
			break;
		}
	}

	// 依据树节点的值删除树中的一个节点
	public boolean delete(int value) {
		// 遍历树过程中的当前节点
		Node current = root;
		// 要删除节点的父节点
		Node parent = root;
		// 记录树的节点为左孩子节点或右孩子节点
		boolean isLeftChild = true;
		while (current.value != value) {
			parent = current;
			// 要删除的节点在当前节点的左子树里
			if (value < current.value) {
				isLeftChild = true;
				current = current.leftChild;
			}
			// 要删除的节点在当前节点的右子树里
			else {
				isLeftChild = false;
				current = current.rightChild;
			}
			// 在树中没有找到要删除的节点
			if (current == null)
				return false;
		}
		// 要删除的节点为叶子节点
		if (current.leftChild == null && current.rightChild == null) {
			// 要删除的节点为根节点
			if (current == root)
				root = null;
			// 要删除的节点为左孩子节点
			else if (isLeftChild)
				parent.leftChild = null;
			// 要删除的节点为右孩子节点
			else
				parent.rightChild = null;
		}
		// 要删除的节点有左孩子节点，没有右孩子节点
		else if (current.rightChild == null) {
			// 要删除的节点为根节点
			if (current == null)
				root = current.leftChild;
			// 要删除的节点为左孩子节点
			else if (isLeftChild)
				parent.leftChild = current.leftChild;
			// 要删除的节点为右孩子节点
			else
				parent.rightChild = current.leftChild;
		}
		// 要删除的节点没有左孩子节点，有右孩子节点
		else if (current.leftChild == null) {
			// 要删除的节点为根节点
			if (current == root)
				root = root.rightChild;
			// 要删除的节点为左孩子节点
			else if (isLeftChild)
				parent.leftChild = current.rightChild;
			// 要删除的节点为右孩子节点
			else
				parent.rightChild = current.rightChild;
		}
		// 要删除的接节点既有左孩子节点又有右孩子节点
		else {
			Node successor = getSuccessor(current);
			// 要删除的节点为根节点
			if (current == root)
				root = successor;
			// 要删除的节点为左孩子节点
			else if (isLeftChild)
				parent.leftChild = successor;
			// 要删除的节点为右孩子节点
			else
				parent.rightChild = successor;
		}
		return true;
	}

	// 找到要删除节点的替补节点
	private Node getSuccessor(Node delNode) {
		// 替补节点的父节点
		Node successorParent = delNode;
		// 删除节点的替补节点
		Node successor = delNode;
		Node current = delNode.rightChild;
		while (current != null) {
			// successorParent指向当前节点的上一个节点
			successorParent = successor;
			// successor变为当前节点
			successor = current;
			current = current.leftChild;
		}
		// 替补节点的右孩子节点不为空
		if (successor != delNode.rightChild) {
			successorParent.leftChild = successor.rightChild;
			successor.rightChild = delNode.rightChild;
		}
		return successor;
	}
}

public class TreeApp {
	public static void main(String[] args) {
		Tree tree = new Tree();
		tree.insert(8);
		tree.insert(50);
		tree.insert(45);
		tree.insert(21);
		tree.insert(32);
		tree.insert(18);
		tree.insert(37);
		tree.insert(64);
		tree.insert(88);
		tree.insert(5);
		tree.insert(4);
		tree.insert(7);

		System.out.print("PreOrder : ");
		tree.traverse(1);
		System.out.println();

		System.out.print("InOrder : ");
		tree.traverse(2);
		System.out.println();

		System.out.print("PostOrder : ");
		tree.traverse(3);
		System.out.println();

		System.out.println(tree.delete(7));

		System.out.print("PreOrder : ");
		tree.traverse(1);
		System.out.println();

		System.out.print("InOrder : ");
		tree.traverse(2);
		System.out.println();

		System.out.print("PostOrder : ");
		tree.traverse(3);
		System.out.println();

	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package ChapterFive;

class Link<E> {

	public E data;

	public Link<E> next;

	public Link(E data) {
		this.data = data;
	}
}

class LinkList<E> {

	public Link<E> first;
	//链表中数据项的个数
	public int size;

	public LinkList() {
		first = null;
		size = 0;
	}
	//在表头插入新的数据
	public void insertFirst(E value) {
		Link<E> link = new Link<E>(value);
		link.next = first;
		first = link;
		size++;
	}
	//判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	//删除表头
	public Link<E> deleteFirst() {
		Link<E> temp = first;
		first = first.next;
		size--;
		return temp;
	}
	//输出链表中的所有数据
	public void display() {
		Link<E> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}
	//返回链表中数据项的个数
	public int size() {
		return size;
	}
	//获取从头至尾的第i个数据项
	public Link<E> get(int i) {
		if (i > size() - 1 || i < 0)
			try {
				throw new IndexOutOfBoundsException();
			} catch (Exception e) {
				e.printStackTrace();
			}
		Link<E> curr = first;
		for (int n = 0; n < size(); n++) {
			if (n == i)
				return curr;
			else
				curr = curr.next;
		}
		return null;
	}
	//输出从头至尾的第i个数据项
	public void remove(int i) {
		if (i == 0)
			deleteFirst();
		else if (i == size() - 1)
			get(i - 1).next = null;
		else {
			get(i - 1).next = get(i + 1);
		}
		size--;
	}
}

public class Link_list {
	public static void main(String[] args) {
		LinkList<Long> ll = new LinkList<Long>();
		for (int i = 0; i < 10; i++) {
			Long value = (long) (Math.random() * 100);
			ll.insertFirst(value);
		}
		ll.display();
		while (!ll.isEmpty()) {
			ll.deleteFirst();
			ll.display();
		}
		System.out.println("Ok");
	}
}

package ChapterFive;

class LinkStack<E> {

	LinkList<E> linkList;

	int size;

	public LinkStack() {
		size = 0;
		linkList = new LinkList<E>();
	}
	//入栈
	public void push(E value) {
		linkList.insertFirst(value);
		size++;
	}
	//出栈
	public Link<E> pop() {
		size--;
		return linkList.deleteFirst();
	}
	//返回栈顶元素
	public Link<E> top() {
		return linkList.first;
	}
	//判断栈是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	//显示栈中的全部数据
	public void display() {
		linkList.display();
	}
}

public class Link_stack {
	public static void main(String[] args) {
		LinkStack<Long> ls = new LinkStack<Long>();
		for (int i = 0; i < 10; i++) {
			Long value = new Long((long) (Math.random() * 100));
			ls.push(value);
		}
		while (!ls.isEmpty()) {
			ls.pop();
			ls.display();
		}
		System.out.println("Ok");
	}
}

package ChapterFive;

class SortedLink {

	public Link<Long> first;

	int size;

	public SortedLink() {
		first = null;
		size = 0;
	}
	//向有序链表中插入数据
	public void insert(long value) {
		Link<Long> newLink = new Link<Long>(value);
		Link<Long> previous = null;
		Link<Long> curr = first;
		while (curr != null && (value > curr.data)) {
			previous = curr;
			curr = curr.next;
		}
		if (previous == null)// 链表为空(在表头插入)
			first = newLink;
		else
			previous.next = newLink;//插入新的节点
		newLink.next = curr;
		size++;
	}
	//删除第一个节点
	public Link<Long> remove() {
		Link<Long> temp = first;
		first = first.next;
		size--;
		return temp;
	}
	//判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}
	//输出链表的所有数据
	public void display() {
		Link<Long> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}
}

public class SortedLinkApp {
	public static void main(String[] args) {
		SortedLink sl = new SortedLink();
		for (int i = 0; i < 10; i++) {
			sl.insert((long) (Math.random() * 100));
		}
		while (!sl.isEmpty()) {
			sl.remove();
			sl.display();
		}
	}
}

package ChapterFive;

class DoubleLink<E> {

	public Link<E> first;

	public Link<E> last;

	int size;

	@SuppressWarnings("hiding")
	class Link<E> {
		public E data;

		public Link<E> next;// 链表的下一项

		public Link<E> previous;// 链表的前一项

		public Link(E value) {
			this.data = value;
		}
	}

	public DoubleLink() {
		first = null;
		last = null;
		size = 0;
	}

	// 在链表的首部插入一项
	public void insertFirst(E value) {
		Link<E> newLink = new Link<E>(value);
		if (isEmpty())// 如果链表为空则first == last
			last = newLink;
		else
			first.previous = newLink;// 确定原first与newLink的前后关系
		newLink.next = first;
		first = newLink;// 设置新的first值
		size++;
	}

	// 在链表的尾部插入一项
	public void insertLast(E value) {
		Link<E> newLink = new Link<E>(value);
		if (isEmpty())// 如果链表为空则last == first
			first = newLink;
		else {
			last.next = newLink;// 确定原last与newLink的前后关系
			newLink.previous = last;
		}
		last = newLink;// 设置新的last值
		size++;
	}

	// 删除双向链表的表头
	public Link<E> deleteFirst() {
		Link<E> temp = first;
		if (first.next == null)// 链表中只有一项数据
			last = null;
		else
			first.next.previous = null;// 销毁原链表的头部
		first = first.next;
		size--;
		return temp;
	}

	// 删除链表的最后一项
	public Link<E> deleteLast() {
		Link<E> temp = last;
		if (first.next == null)// 链表中只有一项数据
			first = null;
		else
			last.previous.next = null;// 销毁原链表的尾部
		last = last.previous;
		size--;
		return temp;
	}

	// 判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}

	// 输出链表中的所有数据项
	public void display() {
		Link<E> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}
}

public class DoubleLinkApp {
	public static void main(String[] args) {
		DoubleLink<Integer> dl = new DoubleLink<Integer>();
		for (int i = 0; i < 5; i++) {
			dl.insertFirst((int) (Math.random() * 100));
		}
		for (int i = 0; i < 5; i++) {
			dl.insertLast((int) (Math.random() * 100));
		}
		dl.display();
		while (!dl.isEmpty()) {
			dl.deleteFirst();
			dl.deleteLast();
			dl.display();
		}
		System.out.println("Ok");
	}
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package ChapterOne;

public class Stack {
	//栈数组
	long stackArr[];
	//栈的大小
	int maxSize;
	//栈的顶部
	int top;
	//初始化一个大小为size的栈
	public Stack(int size){
		maxSize = size; 
		stackArr = new long[size];
		top = -1;
	}
	//出栈操作
	public long pop(){
		return stackArr[top--];
	}
	//进栈操作
	public void push(long value){
		stackArr[++top] = value;
	}
	//判断栈是否为空
	public boolean isEmpty(){
		return top == -1;
	}
	//判断栈是否已满
	public boolean isFull(){
		return top == maxSize-1;
	}
	//取栈顶元素
	public long peek(){
		return stackArr[top];
	}
	public static void main(String[] args) {
		Stack stack = new Stack(10);
		while(!stack.isFull()){
			long v = (long) (Math.random()*100);
			stack.push(v);
			System.out.print(v+" ");
		}
		System.out.println();
		while(!stack.isEmpty()){
			long topValue = stack.pop();
			System.out.print(topValue+" ");
		}
		System.out.println();
	}
}

package ChapterOne;

public class Queue {
	//队列数组
	private long queueArr[];
	//队列的前端下标
	private int front;
	//队列的尾端下标
	private int rear;
	//队列的大小
	private int maxSize;
	//队列中元素的个数
	private int nItems;
	//初始化一个大小为size的队列
	public Queue(int size){
		queueArr = new long[size];
		maxSize = size;
		front = 0;
		rear = -1;
		nItems = 0;
	}
	//插入操作
	public void insert(long value){
		//队列已满
		if(rear == maxSize-1)
			rear = -1;
		queueArr[++rear] = value;
		nItems++;
	}
	//删除操作
	public long remove(){
		long temp = queueArr[front++];
		if(front == maxSize)
			front = 0;
		nItems--;
		return temp;
	}
	//返回队列第一个元素
	public long peakFront(){
		return queueArr[front];
	}
	//判断是否为空
	public boolean isEmpty(){
		return nItems == 0;
	}
	//判断是否已满
	public boolean isFull(){
		return nItems == maxSize;
	}
	//返回队列中元素的个数
	public int size(){
		return nItems;
	}
	
	public void print(){
		for(int i = front;i < front+nItems;i++){
			System.out.print(queueArr[i]+" ");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		Queue q = new Queue(10);
		while(!q.isFull()){
			long value = (long)(Math.random()*100);
			q.insert(value);
		}
		q.print();
		while(!q.isEmpty()){
			q.remove();
			q.print();
		}
		q.print();
		System.out.println(q.isEmpty());
	}
}

package ChapterOne;

public class PriorityQueue {

	private int nItems;
	
	private long pqArr[];
	
	private int maxSize;
	
	public PriorityQueue(int size){
		maxSize = size;
		pqArr = new long[size];
		nItems = 0;
	}
	
	public void insert(long value){
		int i;
		if(nItems == 0)
			pqArr[nItems++] = value;
		else{
			for(i = nItems-1;i >= 0;i--){
				if(value < pqArr[i]){
					pqArr[i+1] = pqArr[i];
				}
				else
					break;
			}
			pqArr[i+1] = value;
			nItems++;
		}
	}
	
	public long remove(){
		return pqArr[--nItems];
	}
	
	public boolean isEmpty(){
		return nItems == 0;
	}
	
	public boolean isFull(){
		return nItems == maxSize;
	}
	
	public void print(){
		for(int i = 0;i < nItems;i++)
			System.out.print(pqArr[i]+" ");
		System.out.println();
	}
	
	public static void main(String[] args) {
		PriorityQueue pq = new PriorityQueue(10);
		while(!pq.isFull()){
			long value = (long)(Math.random()*100);
			pq.insert(value);
		}
		pq.print();
	}
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package ChapterOne;

public class Bubble {

	public static void main(String[] args) {
		Bubble b = new Bubble();
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		b.bubble();
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+" ");
		}
                  System.exit(0);
	}
	/**
	 * 冒泡排序
	 */
	public void bubble(){
		for(int i = arr.length-1;i > 1;i--){
			for(int j = 0;j < i;j++){
				if(arr[j] > arr[j+1])
					swap(j,j+1);
			}
		}
	}
	/**
	 * 交换数组中的两个数
	 * @param one
	 * @param two
	 */
	public void swap(int one,int two){
		long temp = arr[one];
		arr[one] = arr[two];
		arr[two] = temp;
	}
	
	static long arr[] = new long[20];
	/**
	 * 随机初始化一个长度为20的数组
	 */
	static{
		for(int i = 0;i < arr.length;i++){
			arr[i] = (long) (Math.random()*100);
		}
	}
}

package ChapterOne;

public class SelectSort {
	/**
	 * 初始化一个长度为size的数组
	 * @param size
	 */
	public SelectSort(int size){
		arr = new long[size];
		for(int i = 0;i < size;i++){
			arr[i] = (long) (Math.random()*100);
		}
	}
	/**
	 * 选择排序
	 * @return
	 */
	public long[] sort(){
		for(int i = 0;i < arr.length;i++){
			int minIndex = findMin(i);
			long min = arr[minIndex];
			//子数组中的所有的数后移一个位置
			for(int j = minIndex;j > 0;j--)
				arr[j] = arr[j-1];
			//把最小的数插入到最前端
			arr[0] = min;
		}
		return arr;
	}
	/**
	 * 查找一start为起始位置到数组最后位置这段子数组中最小的一个数的位置
	 * @param start
	 * @return
	 */
	public int findMin(int start){
		int min = start;
		for(int i = min;i < arr.length;i++)
			if(arr[min] > arr[i])
				min = i;
		return min;
	}
	
	public static void main(String[] args) {
		SelectSort ss = new SelectSort(10);
		ss.print();
		long oa[] = ss.sort();
		for(int i = 0;i < oa.length;i++)
			System.out.print(oa[i]+" ");
		System.out.println();
		System.exit(0);
	}
	public void print(){
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
	
	long arr[];
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

由于时间关系,好久没有在JAVAEYE发贴子了,现在一开始准备写点东西的时候,感觉到自己的写作水平好差,什么都写不出,但是还是要坚持写下去.暑假这段时间真忙,根本没有时间做别的事,从早到晚一直埋头写程序,这段时间也让我理解到做程序员原来是这样的艰辛!现在刚好写写东西放松下,呵呵~~

       直接写我要写的吧.在财务管理系统中经常要多财务数据进行统计计算,所以系统应为用户提供方便的计算工具,具体需求包括对数据进行统计计算外还包括取数(把文本里面的数据取到计算器),送数（把计算的结果写回到文本中）,精确度调整等.我做的已经基本实现了以上功能. 页面如下:

整个计算器在一个层里面,用户可以点击右上角关闭图标隐藏这个层,点击open按钮显示.另外用户还可以拖动这个层,随便放置它的位置.右边的划块(借用yaho的)用于调整计算的精度,最多可以保留三位小数,如果需要更多的小数位,不选中左上角的CheckBox,即可.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package com.javaeye.yongsky;

import java.awt.Color;
import java.io.FileOutputStream;
import java.sql.ResultSet;

import com.lowagie.text.Document;
import com.lowagie.text.Element;
import com.lowagie.text.Font;
import com.lowagie.text.Paragraph;
import com.lowagie.text.Rectangle;
import com.lowagie.text.pdf.BaseFont;
import com.lowagie.text.pdf.PdfPTable;
import com.lowagie.text.pdf.PdfWriter;
/**
 * 
 * @author yangshoujun
 * 
 */
public class ItextPdfDmo {

	//表头
	public static final String[] tableHeader = { "企业中文名", "所属国家", "企业英文名",
			"2003年排名", "2004年排名", "2005年排名", "2006年排名", "2007年排名", "主要业务",
			"2003年营业额", "2004年营业额", "2005年营业额", "2006年营业额", "2007年营业额", "企业编号",
			"名次升降", "图片", "状况" };
	//数据表字段数
	private static final int colNumber = 18;
	//表格的设置
	private static final int spacing = 2;
	//表格的设置
	private static final int padding = 2;
	//导出Pdf文挡
	public static void exportPdfdocument() {
		// 创建文Pdf文挡
		Document document = new Document(new Rectangle(1500, 2000), 10, 10, 10,
				10);
		try {
			PdfWriter.getInstance(document, new FileOutputStream(
					"d:\\世界五百强企业名次表.pdf"));
			document.open();
			// 中文字体
			BaseFont bfChinese = BaseFont.createFont("STSong-Light",
					"UniGB-UCS2-H", BaseFont.NOT_EMBEDDED);
			Font fontChinese = new Font(bfChinese, 12, Font.HELVETICA);
			// 创建有colNumber(18)列的表格
			PdfPTable datatable = new PdfPTable(colNumber);
			int[] cellsWidth = { 8, 5, 8, 3, 3, 3, 3, 2, 6, 4, 4, 4, 4, 2, 2,
					2, 2, 2 };
			datatable.setWidths(cellsWidth);
			datatable.setWidthPercentage(100); // 表格的宽度百分比
			datatable.getDefaultCell().setPadding(padding);
			datatable.getDefaultCell().setBorderWidth(spacing);
			datatable.getDefaultCell().setBackgroundColor(Color.ORANGE);
			datatable.getDefaultCell().setHorizontalAlignment(
					Element.ALIGN_CENTER);
			// 添加表头元素
			for (int i = 0; i < colNumber; i++) {
				datatable.addCell(new Paragraph(tableHeader[i], fontChinese));
			}
			datatable.setHeaderRows(1); // 表头结束
			datatable.getDefaultCell().setBorderWidth(1);

			ResultSet rs = SheetDataSource.selectAllDataFromDB();
			int rowIndex = 1;
			while (rs.next()) {
				if (rowIndex % 2 == 1) {
					datatable.getDefaultCell().setGrayFill(0.9f);
				}
				for (int i = 1; i <= colNumber; i++)
					datatable.addCell(new Paragraph(rs.getString(i),
							fontChinese));
				if (rowIndex % 2 == 1) {
					datatable.getDefaultCell().setGrayFill(1.0f);
				}
				rowIndex++;
			}
			document.add(datatable);
		} catch (Exception e) {
			e.printStackTrace();
		}
		document.close();
	}

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

 Document document = new Document();

PDFWriter.getInstance(document, new FileOutputStream("D:\\HelloItext.PDF")); 

document.open();

document.add(new Paragraph("Hello Itext"));

document.close();

package com.javaeye.yongsky;

import java.io.FileOutputStream;

import com.lowagie.text.Document;
import com.lowagie.text.PageSize;
import com.lowagie.text.Paragraph;
import com.lowagie.text.pdf.PdfWriter;

public class HelloItext {

	public static void main(String[] args) {
		Document document = new Document(PageSize.A4.rotate(), 10, 10, 10, 10);
		try {
			PdfWriter.getInstance(document, new FileOutputStream("D:\\HelloItext.pdf"));
			document.open();
			document.add(new Paragraph("Hello Itext"));
		} catch (Exception de) {
			de.printStackTrace();
		}
		document.close();
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package com.javaeye.yongsky;

import java.sql.*;
import java.util.*;

import com.microsoft.jdbc.*;

public class SheetDataSource {

 private static Connection con ;
 
 private static final String DatabaseName = "POIDEMO";
 
 private static final String userName = "sa";
 
 private static final String password = "123";
 
 public SheetDataSource()
 {
  try {
   Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
   try {
     con = DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName="+DatabaseName,userName,password);
   } catch (SQLException e) {
    e.printStackTrace();
   }
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
 }
 
 public static ResultSet selectAllDataFromDB() throws SQLException 
 { 
   new SheetDataSource();
   Statement stmt = con.createStatement();
   return stmt.executeQuery("select * from COMPANY");
 }
 
}

package com.javaeye.yongsky;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;

import javax.swing.JOptionPane;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFooter;
import org.apache.poi.hssf.usermodel.HSSFHeader;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

public class PoiDemo {

	//表头
	public static final String[] tableHeader = {"企业中文名","所属国家","企业英文名","2003年排名","2004年排名","2005年排名",
		"2006年排名","2007年排名","主要业务","2003年营业额","2004年营业额","2005年营业额","2006年营业额","2007年营业额","企业编号","名次升降",
		"图片","状况"};
	//创建工作本
	public static HSSFWorkbook demoWorkBook = new HSSFWorkbook();
	//创建表
	public static HSSFSheet demoSheet = demoWorkBook.createSheet("The World's 500 Enterprises");
	//表头的单元格个数目
	public static final short cellNumber = (short)tableHeader.length;
	//数据库表的列数
	public static final int columNumber = 18;
	/**
	 * 创建表头
	 * @return
	 */
	public static void createTableHeader()
	{
		HSSFHeader header = demoSheet.getHeader();
		header.setCenter("世界五百强企业名次表");
		HSSFRow headerRow = demoSheet.createRow((short) 0);
		for(int i = 0;i < cellNumber;i++)
		{
			HSSFCell headerCell = headerRow.createCell((short) i);
			headerCell.setEncoding(HSSFCell.ENCODING_UTF_16);
			headerCell.setCellValue(tableHeader[i]);
		}
	}
	/**
	 * 创建行
	 * @param cells
	 * @param rowIndex
	 */
	public static void createTableRow(List<String> cells,short rowIndex)
	{
		//创建第rowIndex行
		HSSFRow row = demoSheet.createRow((short) rowIndex);
		for(short i = 0;i < cells.size();i++)
		{
			//创建第i个单元格
			HSSFCell cell = row.createCell((short) i);
			cell.setEncoding(HSSFCell.ENCODING_UTF_16);
	        cell.setCellValue(cells.get(i));
		}
	}
	
	/**
	 * 创建整个Excel表
	 * @throws SQLException 
	 *
	 */
	public static void createExcelSheeet() throws SQLException
	{
		createTableHeader();
		ResultSet rs = SheetDataSource.selectAllDataFromDB();
		int rowIndex = 1;
		while(rs.next())
		{
			List<String> list = new ArrayList<String>();
			for(int i = 1;i <= columNumber;i++)
			{
				list.add(rs.getString(i));
			}
			createTableRow(list,(short)rowIndex);
			rowIndex++;
		}
	}
	/**
	 * 导出表格
	 * @param sheet
	 * @param os
	 * @throws IOException
	 */
	public void exportExcel(HSSFSheet sheet,OutputStream os) throws IOException
	{
		sheet.setGridsPrinted(true);
        HSSFFooter footer = sheet.getFooter();
        footer.setRight("Page " + HSSFFooter.page() + " of " +
        HSSFFooter.numPages());
        demoWorkBook.write(os);
	}
	
	public static void main(String[] args) {
		String fileName = "D:\\世界五百强企业名次表.xls";
		 FileOutputStream fos = null;
	        try {
	        	PoiDemo pd = new PoiDemo();
	        	pd.createExcelSheeet();
	            fos = new FileOutputStream(fileName);
	            pd.exportExcel(demoSheet,fos);
	            JOptionPane.showMessageDialog(null, "表格已成功导出到 : "+fileName);
	        } catch (Exception e) {
	        	JOptionPane.showMessageDialog(null, "表格导出出错，错误信息 ："+e+"\n错误原因可能是表格已经打开。");
	        	e.printStackTrace();
	        } finally {
	            try {
	                fos.close();
	            } catch (Exception e) {
	                e.printStackTrace();
	            }
	        }
	}
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

What is the most valuable contribution employees make to their companies,knowledge or judgment?I say judgment .Knowledge ,no matter how broad ,is useless until it is applied.And application takes judgment,which involves something of a sixth sense -a high performance of the mind. 

             This raises interesting questions about the best training for today's business people.As Daniel Goleman suggests in his new book,Emotional Intelligence,the latest scientific findings seem to indicate that intelligent but inflexible people don't have the right stuff in an age when the adaptive ability is the key to survival .

          In a recent cover story,Time magazine sorted through the current thinking on intelligence and reported,"New brain research suggests that emotions,not IQ may be the true measure of human intelligence."The basic significance of the emotional intelligence that Time called "EQ"was suggested by management expert Karen Boylston;"Customers are telling busimesses,'I don't care if every member of your staff graduated from Harvard.I will take my business and go where I am understood and treated with respect.'''

            If the evolutionary pressures of the marketplace are making EQ,not IQ,the hot ticket for business success,it seems likely that individuals will want to know how to cultivate it ,I have a modest proposal :Embrace a highly personal practice aimed at improving these four adaptive skilla;

            Raising consciorsness.I think of this as thinking differently on purpose .It's about noticing what you are feeling and thinking and escaping the conditioned confines of your past.Raise your comsciousness by catching yourself in the act of thinking as often as possible .Routinely take note of your emotions and ask if you're facing facts or avoiding them.

         Using imagery.This is what you see Olympic ski racers doing before entering the starting gate .With their eyes cloed and bodies swaying,they run the course in their minds first,which improves their performance.You can do the same by setting aside time each day to dream with passion about what you want to achieve.

                 Considering and reconsidering events to choose the most creative response to them.When a Greek philosopher said 2,000 years ago that it isn't events that matter but our opinon of them .this is what he was thalking about.Every time something important happens ,assign as many interpretations to it as possible ,even carzy ones.Then go with the interpretation most supportive of your dreams.

                Integrating the perspectives of others.Brain research shows that our view of the world is limited by our genes and the experiences we 've had.Learning to incorporate the useful perspectives of others is nothing less that a form of enlarging your senes.The next time someone interprets something differently from you -say.a controversial political event-pause to reflect on the role of life experience and consider it a gift of perception.

          The force of       habit -literally the established wiring of your brain -will pull you away from practicing these skills .Keep at it ,however ,because they are based on what we're learning about the mechanisms of the mind.

               Within the first six months of life hte human brain doubles in capacity;it doubles again by age four and then grows rapidly until we sexual maturity.The body has about a hundred billion nerve cells,and every experience triggers a brain response that literally shapes our senses .The mind ,we now know .is not comfined to the brain but is distributed throughout the body's universe of cells.Yes,we do think with our hearts .brains. muscles, blood and bones.

            During a single crucial three-week period during our teenage years. chemical activity in the brain is cut in half .That done , we are "biologically wired"with what one of the nation;s leading brain researchers calls our own"world view ".He says it is impossible for any two people to see the world exactly alike .So unique is the personal experience that people would understand the world differently .

             However,it is not only plssible to change your world view ,he says,it's actually easier than overcoming a drug habit .But you need a discipline for doing it .Hence,the methos recommmended here.

           No,it's not a curriculum in the sense that an MBA is .But the latest research seems to imply that without the software of emotional maturity and self-knowledge ,the hardware of academic training alone is worth less and less.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师