public class QuickSort {
 /**
  * 快速排序
  *
  * @param arr
  * @param left
  * @param right
  */
 public void quickSort(int[] arr, int left, int right) {
  int middle, temp;
  int i, j;
  i = left;
  j = right;
  middle = arr[(i + j) / 2];
  do {
   // 找出左边比中间值大的数
   while (arr[i] < middle && i < right)
    i++;
   // 找出右边比中间值小的数
   while (arr[j] > middle && j > left)
    j--;
   // 将左边大的数和右边小的数进行替换
   if (i <= j) {
    temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    i++;
    j--;
   }
  } while (i <= j); // 当两者交错时停止

  if (i < right) {
   quickSort(arr, i, right);// 从右边进行递归
  }
  if (j > left) {
   quickSort(arr, left, j);// 从左边进行递归
  }
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  int[] arr = { 11, 66, 22, 0, 55, 22, 0, 32 };
  QuickSort sort = new QuickSort();
  sort.quickSort(arr, 0, arr.length - 1);
  for (int i = 0; i < arr.length; i++) {
   System.out.print(arr[i] + " ");
  }
 }
}

import java.text.NumberFormat;
import java.util.HashMap;

public class SimpleMoneyFormat {
 public static final String EMPTY = "";

 public static final String ZERO = "零";

 public static final String ONE = "壹";

 public static final String TWO = "贰";

 public static final String THREE = "叁";

 public static final String FOUR = "肆";

 public static final String FIVE = "伍";

 public static final String SIX = "陆";

 public static final String SEVEN = "柒";

 public static final String EIGHT = "捌";

 public static final String NINE = "玖";

 public static final String TEN = "拾";

 public static final String HUNDRED = "佰";

 public static final String THOUSAND = "仟";

 public static final String TEN_THOUSAND = "万";

 public static final String HUNDRED_MILLION = "亿";

 public static final String YUAN = "元";

 public static final String JIAO = "角";

 public static final String FEN = "分";

 public static final String DOT = ".";

 private static SimpleMoneyFormat formatter = null;

 private HashMap chineseNumberMap = new HashMap();

 private HashMap chineseMoneyPattern = new HashMap();

 private NumberFormat numberFormat = NumberFormat.getInstance();

 private SimpleMoneyFormat() {
  numberFormat.setMaximumFractionDigits(4);
  numberFormat.setMinimumFractionDigits(2);
  numberFormat.setGroupingUsed(false);
  chineseNumberMap.put("0", ZERO);
  chineseNumberMap.put("1", ONE);
  chineseNumberMap.put("2", TWO);
  chineseNumberMap.put("3", THREE);
  chineseNumberMap.put("4", FOUR);
  chineseNumberMap.put("5", FIVE);
  chineseNumberMap.put("6", SIX);
  chineseNumberMap.put("7", SEVEN);
  chineseNumberMap.put("8", EIGHT);
  chineseNumberMap.put("9", NINE);
  chineseNumberMap.put(DOT, DOT);
  chineseMoneyPattern.put("1", TEN);
  chineseMoneyPattern.put("2", HUNDRED);
  chineseMoneyPattern.put("3", THOUSAND);
  chineseMoneyPattern.put("4", TEN_THOUSAND);
  chineseMoneyPattern.put("5", TEN);
  chineseMoneyPattern.put("6", HUNDRED);
  chineseMoneyPattern.put("7", THOUSAND);
  chineseMoneyPattern.put("8", HUNDRED_MILLION);
 }

 public static SimpleMoneyFormat getInstance() {
  if (formatter == null)
   formatter = new SimpleMoneyFormat();
  return formatter;
 }

 public String format(String moneyStr) {
  checkPrecision(moneyStr);
  String result = null;
  result = convertToChineseNumber(moneyStr);
  result = addUnitsToChineseMoneyString(result);
  return result;
 }

 public String format(double moneyDouble) {
  return format(numberFormat.format(moneyDouble));
 }

 public String format(int moneyInt) {
  return format(numberFormat.format(moneyInt));
 }

 public String format(long moneyLong) {
  return format(numberFormat.format(moneyLong));
 }

 public String format(Number moneyNum) {
  return format(numberFormat.format(moneyNum));
 }

 private void checkPrecision(String moneyStr) {
  int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;
  if (fractionDigits > 2)
   throw new RuntimeException("金额" + moneyStr + "的小数位多于两位。"); // 精度不能比分低
 }

 private String convertToChineseNumber(String moneyStr) {
  String result;
  StringBuffer cMoneyStringBuffer = new StringBuffer();
  for (int i = 0; i < moneyStr.length(); i++) {
   cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(
     i, i + 1)));
  }
  // 拾佰仟万亿等都是汉字里面才有的单位，加上它们
  int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
  int moneyPatternCursor = 1;
  for (int i = indexOfDot - 1; i > 0; i--) {
   cMoneyStringBuffer.insert(i, chineseMoneyPattern.get(EMPTY
     + moneyPatternCursor));
   moneyPatternCursor = moneyPatternCursor == 8 ? 1
     : moneyPatternCursor + 1;
  }
  String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer
    .indexOf("."));
  cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("."),
    cMoneyStringBuffer.length());

  replace(cMoneyStringBuffer, "零拾", ZERO);
  replace(cMoneyStringBuffer, "零佰", ZERO);
  replace(cMoneyStringBuffer, "零仟", ZERO);
  replace(cMoneyStringBuffer, "零万", TEN_THOUSAND);
  replace(cMoneyStringBuffer, "零亿", HUNDRED_MILLION);
  replace(cMoneyStringBuffer, "零零", ZERO);

  if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)
   cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1,
     cMoneyStringBuffer.length());
  cMoneyStringBuffer.append(fractionPart);
  result = cMoneyStringBuffer.toString();
  return result;
 }

 private String addUnitsToChineseMoneyString(String moneyStr) {
  String result;
  StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);
  int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
  cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);
  cMoneyStringBuffer.insert(cMoneyStringBuffer.length() - 1, JIAO);
  cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN);
  if (cMoneyStringBuffer.indexOf("零角零分") != -1)// 没有零头，加整
   cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"),
     cMoneyStringBuffer.length(), "整");
  else if (cMoneyStringBuffer.indexOf("零分") != -1)// 没有零分，加整
   cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"),
     cMoneyStringBuffer.length(), "整");
  else {
   if (cMoneyStringBuffer.indexOf("零角") != -1)
    cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),
      cMoneyStringBuffer.indexOf("零角") + 2);
  }
  result = cMoneyStringBuffer.toString();
  return result;
 }

 private void replace(StringBuffer pValue, String pSource, String pDest) {
  if (pValue == null || pSource == null || pDest == null)
   return;
  /** 记录pSource在pValue中的位置 */
  int intPos = 0;
  do {
   intPos = pValue.toString().indexOf(pSource);
   /** 没有找到pSource */
   if (intPos == -1)
    break;
   pValue.delete(intPos, intPos + pSource.length());
   pValue.insert(intPos, pDest);
  } while (true);
 }

 public static void main(String args[]) {
  System.out.println(getInstance().format(new Double(100110010001.01)));
 }
}

import java.util.Random;

public class Poker {
 public static void main(String[] args) {
  int[] pokers = new int[54];
  for (int i = 0; i < pokers.length; i++)
   pokers[i] = i;
  int j = 0, temp = 0;
  for (int i = 0; i < pokers.length; i++) {
   Random r = new Random();
   j = r.nextInt(54);
   temp = pokers[i];
   pokers[i] = pokers[j];
   pokers[j] = temp;
  }
  for (int i = 0; i < pokers.length; i++) {
   System.out.print(pokers[i] + " ");
   if ((i + 1) % 10 == 0)
    System.out.println();
  }
 }
}

class BinaryNode {
 Comparable element;

 BinaryNode left;

 BinaryNode right;

 BinaryNode(Comparable element) {
  this(element, null, null);
 }

 BinaryNode(Comparable element, BinaryNode left, BinaryNode right) {
  this.element = element;
  this.left = left;
  this.right = right;
 }
}

public class BinarySearchTree {
 private BinaryNode root;

 public BinarySearchTree() {
  root = null;
 }

 public void makeEmpty() {
  root = null;
 }

 public boolean isEmpty() {
  return root == null;
 }

 public Comparable find(Comparable x) {
  return elementAt(find(x, root));
 }

 public Comparable findMin() {
  return elementAt(findMin(root));
 }

 public Comparable findMax() {
  return elementAt(findMax(root));
 }

 public void insert(Comparable x) {
  root = insert(x, root);
 }

 public void remove(Comparable x) {
  root = remove(x, root);
 }

 public void printTree() {
  if (isEmpty())
   System.out.println("Empty Tree");
  else
   printTree(root);
 }

 private Comparable elementAt(BinaryNode t) {
  return t == null ? null : t.element;
 }

 private BinaryNode find(Comparable x, BinaryNode t) {
  if (t == null)
   return null;
  if (x.compareTo(t.element) < 0)
   return find(x, t.left);
  else if (x.compareTo(t.element) > 0)
   return find(x, t.right);
  else
   return t;
 }

 private BinaryNode findMin(BinaryNode t) {
  if (t == null)
   return null;
  else if (t.left == null)
   return t;
  return findMin(t.left);
 }

 private BinaryNode findMax(BinaryNode t) {
  if (t != null) {
   while (t.right != null)
    t = t.right;
  }
  return t;
 }

 private BinaryNode insert(Comparable x, BinaryNode t) {
  if (t == null)
   t = new BinaryNode(x);
  else if (x.compareTo(t.element) < 0)
   t.left = insert(x, t.left);
  else if (x.compareTo(t.element) > 0)
   t.right = insert(x, t.right);
  else
   ;
  return t;
 }

 private BinaryNode remove(Comparable x, BinaryNode t) {
  if (t == null)
   return t;
  if (x.compareTo(t.element) < 0)
   t.left = remove(x, t.left);
  else if (x.compareTo(t.element) > 0)
   t.right = remove(x, t.right);
  else if (t.left != null && t.right != null) {
   t.element = findMin(t.right).element;
   t.right = remove(x, t.right);
  } else
   t = (t.left != null) ? t.left : t.right;
  return t;
 }

 private void printTree(BinaryNode t) {
  if (t != null) {
   printTree(t.left);
   System.out.print(t.element);
   printTree(t.right);
  }
 }

 public static void main(String[] args) {
  BinarySearchTree bst = new BinarySearchTree();
  bst.insert(new Integer(1));
  bst.insert(new Integer(2));
  bst.insert(new Integer(3));
  bst.insert(new Integer(4));
  bst.insert(new Integer(5));
  bst.insert(new Integer(6));
  Comparable c = bst.find(new Integer(6));
  if (c != null)
   System.out.print(c);
  else
   System.out.println("not exist");
 }
}

import java.util.StringTokenizer;

public class ReverseWords {
 public static String reverseWords(String str) {
  if (str == null || str.trim().equals(""))
   return null;
  StringTokenizer spaceToker = new StringTokenizer(str);
  String[] result = new String[spaceToker.countTokens()];
  int index = 0;
  while (spaceToker.hasMoreTokens()) {
   result[index] = spaceToker.nextToken();
   index++;
  }
  StringBuffer sb = new StringBuffer();
  for (int i = result.length - 1; i >= 0; i--)
   sb.append(result[i]+" ");
  return sb.toString();
 }

 public static void main(String[] args) {
  String str = "Do or do not, there is no try.";
  System.out.print(reverseWords(str));
 }
}

package test;

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

public class Server
{
 private ServerSocket ss;
 private Socket socket;
 private BufferedReader in;
 private PrintWriter out;
 
 public Server()
 {
  try
  {
   ss=new ServerSocket(10000);
   while(true)
   {
    socket = ss.accept();
    String RemoteIP = socket.getInetAddress().getHostAddress();
    String RemotePort = ":"+socket.getLocalPort();
    System.out.println("A client come in!IP:"+RemoteIP+RemotePort);
    in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    String line = in.readLine();
    /*if (line.equals("END"))
     break;*/
    System.out.println("Cleint send is :" + line);
    out = new PrintWriter(socket.getOutputStream(),true);
    out.println("Your Message Received!");
    out.close();
    in.close();
    socket.close();
   }
  }
  catch (IOException e)
  {
   out.println("wrong");
  }
 }

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

Client端程序:

package test;

import java.io.*;
import java.net.*;
 
public class Client
{
 private Socket socket;
 private BufferedReader in;
 private PrintWriter out;
 
 public Client()
 {
  try
  {
   System.out.println("Try to Connect to 127.0.0.1:10000");
   socket = new Socket("127.0.0.1",10000);
   System.out.println("The Server Connected!");
   System.out.println("Please enter some Character:");
   BufferedReader line = new BufferedReader(new InputStreamReader(System.in));
   out = new PrintWriter(socket.getOutputStream(),true);
   in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
   System.out.println(in.readLine());
   out.close();
   in.close();
   socket.close();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  }
  catch(IOException e)
  {
   out.println("Wrong");
  }
 }

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

 public void displayNode()
 {
  // (see Listing 8.1 for method body)
  System.out.print("{" + iData + ", " + dData + "} ");
 }
}

class Tree
{
 private Node root; // the only data field in Tree

 public Node find(int key) // find Node with given key
 { // (assumes non-empty tree)
  Node current = root; // start at root
  while(current.iData != key) // while no match,
  {
   if(key < current.iData) // go left?
    current = current.leftChild;
   else
    current = current.rightChild; // or go right?
   if(current == null) // if no child,
    return null; // didn't find it
  } 
  return current; // found it
 }

 public Node minimum() // returns Node with minimum key value
 {
  Node current, last=null;
  current = root; // start at root
  while(current != null) // until the bottom,
  {
   last = current; // remember Node
   current = current.leftChild; // go to left child
  }
  return last;
 }

 public void insert(int id, double dd)
 {
  Node newNode = new Node(); // make new Node
  newNode.iData = id; // insert data
  newNode.dData = dd;
  if(root==null) // no Node in root
   root = newNode;
  else // root occupied
  {
   Node current = root; // start at root
   Node parent;
   while(true) // (exits internally)
   {
    parent = current;
    if(id < current.iData) // go left?
    {
     current = current.leftChild;
     if(current == null) // if end of the line,
     { // insert on left
      parent.leftChild = newNode;
      return;
     }
    } // end if go left
    else // or go right?
    {
     current = current.rightChild;
     if(current == null) // if end of the line
     { // insert on right
      parent.rightChild = newNode;
      return;
     }
    } // end else go right
   } // end while
  } // end else not root
 } // end insert()

 public boolean delete(int key) // delete Node with given key
 { // (assumes non-empty list)
  Node current = root;
  Node parent = root;
  boolean isLeftChild = true;
  while(current.iData != key) // search for Node
  {
   parent = current;
   if(key < current.iData) // go left?
   {
    isLeftChild = true;
    current = current.leftChild;
   }
   else // or go right?
   {
    isLeftChild = false;
    current = current.rightChild;
   }
   if(current == null) // end of the line,
    return false; // didn't find it
  } // end while
  // found Node to delete
  // continues...
 
  // delete() continued...
  // if no children, simply delete it
  if(current.leftChild==null && current.rightChild==null)
  {
   if(current == root) // if root,
    root = null; // tree is empty
   else if(isLeftChild)
    parent.leftChild = null; // disconnect
   else // from parent
    parent.rightChild = null;
  }
  // continues...

  // delete() continued...
  // if no right child, replace with left subtree
  else if(current.rightChild==null)
   if(current == root)
    root = current.leftChild;
   else if(isLeftChild) // left child of parent
    parent.leftChild = current.leftChild;
   else // right child of parent
    parent.rightChild = current.leftChild;
  // if no left child, replace with right subtree
  else if(current.leftChild==null)
   if(current == root)
    root = current.rightChild;
   else if(isLeftChild) // left child of parent
    parent.leftChild = current.rightChild;
   else // right child of parent
    parent.rightChild = current.rightChild;
  // continued...

  // delete() continued
  else // two children, so replace with inorder successor
  {
   // get successor of Node to delete (current)
   Node successor = getSuccessor(current);
   // connect parent of current to successor instead
   if(current == root)
    root = successor;
   else if(isLeftChild)
    parent.leftChild = successor;
   else
    parent.rightChild = successor;
    // connect successor to current's left child
   successor.leftChild = current.leftChild;
  } // end else two children
  // (successor cannot have a left child)
  return true;
 } // end delete()
 
 public void printTree(){
  System.out.print("前序遍历：");
  preOrder(root);
  System.out.println();
  System.out.print("中序遍历：");
  inOrder(root);
  System.out.println();
  System.out.print("后序遍历：");
  postOrder(root);
  System.out.println();
 }
  
 // returns Node with next-highest value after delNode
 // goes to right child, then right child's left descendants
 private Node getSuccessor(Node delNode)
 {
  Node successorParent = delNode;
  Node successor = delNode;
  Node current = delNode.rightChild; // go to right child
  while(current != null) // until no more
  { // left children,
   successorParent = successor;
   successor = current;
   current = current.leftChild; // go to left child
  }
  // if successor not
  if(successor != delNode.rightChild) // right child,
  { // make connections
   successorParent.leftChild = successor.rightChild;
   successor.rightChild = delNode.rightChild;//?
  }
  return successor;
 }

 private void preOrder(Node localRoot)
 {
  if(localRoot !=null)
  {
   localRoot.displayNode();
   preOrder(localRoot.leftChild);
   preOrder(localRoot.rightChild);
  }
 }

 private void inOrder(Node localRoot)
 {
  if(localRoot != null)
  {
   inOrder(localRoot.leftChild);
   localRoot.displayNode();
   inOrder(localRoot.rightChild);
  }
 }

 private void postOrder(Node localRoot)
 {
  if(localRoot !=null)
  {
   postOrder(localRoot.leftChild);
   postOrder(localRoot.rightChild);
   localRoot.displayNode();
  }
 }
} // end class Tree

public class TreeApp
{
 public static void main(String[] args)
 {
  Tree theTree = new Tree(); // make a tree
  theTree.insert(50, 1.5); // insert 3 Nodes
  theTree.insert(25, 1.7);
  theTree.insert(75, 1.9);
  Node found = theTree.find(25); // find Node with key 25
  if(found != null)
   System.out.println("Found the Node with key 25");
  else
   System.out.println("Could not find node with key 25");
  //theTree.minimum().displayNode();
  theTree.printTree();
  System.out.println("删除后...");
  theTree.delete(25);
  theTree.printTree();
 } // end main()
} // end class TreeApp

public class BigInteger//定义长整型的类
{
    private static final int add1Max=100;//可计算最长位数
    private static final int add2Max=100;//同上
    private char[] add1 = new char[add1Max];
    private char[] add2 = new char[add1Max];
    private int len1;
    private int len2;

    public void setAdd1() throws IOException
    {
        int i=0;
        String sLine1;
        System.out.print("Please input add1 : ");//输入第一个长整数
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        sLine1=in.readLine();
        for(;i<sLine1.length();i++)
            add1[i]=sLine1.charAt(i);
       
        for(i=0;i<add1Max;i++)//len1=add1.length()
        {
            if(add1[i]!='\0')
                len1++;
        }
    }

    public void setAdd2() throws IOException
    {
        int i=0;
        String sLine2;
        System.out.print("Please input add2 : ");//输入第二个长整数
        BufferedReader in2 = new BufferedReader(new InputStreamReader(System.in));
        sLine2 = in2.readLine();
        for(i=0;i<sLine2.length();i++)
            add2[i]=sLine2.charAt(i);
       
        for(i=0;i<add2Max;i++)//len2=add2.length()
        {
            if(add2[i]!='\0')
                len2++;
        }
    }

    public char[] getAdd1()
    {
        return add1;
    }

    public char[] getAdd2()
    {
        return add2;
    }

    public int getLen1()
    {
        return len1;
    }

    public int getLen2()
    {
        return len2;
    }

    public void add(char[] add1,char[] add2)//BigInteger相加方法
    {
        int len = Math.max(len1,len2);
        int i;
        char[] temp1 = new char[len];
        char[] temp2 = new char[len];
        char[] result = new char[len+1];
               
        for(i=0;i<len1;i++)
            temp1[len-1-i]=add1[len1-1-i];
        for(i=0;i<len2;i++)
            temp2[len-1-i]=add2[len2-1-i];
       
        int m=0;
        for(i=0;i<len;i++)//相加
        {
            if(temp1[len-1-i]!=0)
                temp1[len-1-i]-=48;
            if(temp2[len-1-i]!=0)
                temp2[len-1-i]-=48;
            m=temp1[len-1-i]+temp2[len-1-i];
            if(m>=10)
            {
                m-=10;
                result[len-i]+=m;
                result[len-1-i]+=1;
            }
            else result[len-i]+=m;
        }
       
        System.out.print("add1 + add2 = ");//输出相加结果
        i=0;
        if(result[0]==0)
            i=1;
            for(;i<len+1;i++)
                System.out.print(Integer.toString(result[i]));
    }

    public void sub(char[]sub1,char[]sub2)//BigInteger相减方法
    {
        int len = Math.max(len1,len2);
        int i;
        char[] temp1 = new char[len];
        char[] temp2 = new char[len];
        char[] result = new char[len+1];
               
        if(len1>len2)
        {
            for(i=0;i<len1;i++)
                temp1[len-1-i]=sub1[len1-1-i];
            for(i=0;i<len2;i++)
                temp2[len-1-i]=sub2[len2-1-i];
        }else//保证减数大于被减数
        {
            for(i=0;i<len1;i++)
                temp2[len-1-i]=sub1[len1-1-i];
            for(i=0;i<len2;i++)
                temp1[len-1-i]=sub2[len2-1-i];
        }
       
        int m=0;
        for(i=0;i<len;i++)//相减
        {
            if(temp1[len-1-i]!=0)
                temp1[len-1-i]-=48;
            if(temp2[len-1-i]!=0)
                temp2[len-1-i]-=48;
            m=temp1[len-1-i]-temp2[len-1-i];
            if(m<0)//如果计算的那一位的减数小于被减数那么相前一位借10
            {
                m+=10;
                result[len-i]+=m;
                temp1[len-1-i]-=1;
            }
            else result[len-i]+=m;
        }
        System.out.print("add1 - add2 = ");//输出减法结果
        i=0;
        while(result[i]==0)
            i++;
        if((len2>len1)||(len1==len2&&sub1[0]<sub2[0]))
            System.out.print("-");
            for(;i<len+1;i++)
                System.out.print(Integer.toString(result[i]));
    }

    public static void main(String[] args) throws IOException//主方法   
    {
        BigInteger big = new BigInteger();//生成一个BigInteger对象
        big.setAdd1();//得到数1
        big.setAdd2();//得到数2
        char[] num1 = big.getAdd1();//相加
        char[] num2 = big.getAdd2();//相减
        int len1 = big.getLen1();
        int len2 = big.getLen2();
        System.out.println();
        System.out.println("The length of add1 is : " + len1);
        System.out.println("The length of add2 is : " + len2);
        big.add(num1,num2);
        System.out.println();
        big.sub(num1,num2);
    }
}