遍历：遍历所有元素并进行打印。
插入：将一个或多个元素插入数组。
删除：从数组中删除元素
搜索：在数组中搜索元素。您可以按元素的值或索引搜索元素
更新：在给定索引处更新现有元素的值

用作构建其他数据结构的基础，例如数组列表，堆，哈希表，向量和矩阵。
用于不同的排序算法，例如插入排序，快速排序，冒泡排序和合并排序。

单链列表—只能沿正向遍历项目。
双链表-可以在前进和后退方向上遍历项目。节点由一个称为上一个的附加指针组成，指向上一个节点。
循环链接列表—链接列表，其中头的上一个指针指向尾部，尾号的下一个指针指向头。

搜索：通过简单的线性搜索在给定的链表中找到键为k的第一个元素，并返回指向该元素的指针
插入：在链接列表中插入一个密钥。插入可以通过3种不同的方式完成；在列表的开头插入，在列表的末尾插入，然后在列表的中间插入。
删除：从给定的链表中删除元素x。您不能单步删除节点。删除可以通过3种不同方式完成；从列表的开头删除，从列表的末尾删除，然后从列表的中间删除。

用于编译器设计中的符号表管理。
用于在使用Alt Tab（使用循环链表实现）的程序之间进行切换。

Push 推送：在堆栈顶部插入一个元素。
Pop 弹出：删除最上面的元素并返回。

Peek 窥视：返回堆栈的顶部元素而不删除它。
isEmpty：检查堆栈是否为空。
isFull：检查堆栈是否已满。

用于表达式评估（例如：用于解析和评估数学表达式的调车场算法）。
用于在递归编程中实现函数调用。

进队：将元素插入队列的末尾。
出队：从队列的开头删除元素。

用于管理多线程中的线程。
用于实施排队系统（例如：优先级队列）。

h：哈希函数
k：应确定其哈希值的键
m：哈希表的大小（可用插槽数）。一个不接近2的精确乘方的素数是m的一个不错的选择。

用于实现数据库索引。
用于实现关联数组。
用于实现"设置"数据结构。

key：存储在节点中的值。
left：指向左孩子的指针。
right：指向正确孩子的指针。
p：指向父节点的指针。

令x为二叉搜索树中的一个节点。 
如果y是x左子树中的一个节点，则y.key≤x.key 
如果y是x的右子树中的节点，则y.key≥x.key

二叉树：用于实现表达式解析器和表达式求解器。
二进制搜索树：用于许多不断输入和输出数据的搜索应用程序中。
堆：由JVM（Java虚拟机）用来存储Java对象。
Trap：用于无线网络。

最小堆-父项的密钥小于或等于子项的密钥。这称为min-heap属性。根将包含堆的最小值。
最大堆数-父项的密钥大于或等于子项的密钥。这称为max-heap属性。根将包含堆的最大值。

用于实现优先级队列，因为可以根据堆属性对优先级值进行排序。
可以在O（log n）时间内使用堆来实现队列功能。
用于查找给定数组中k个最小（或最大）的值。
用于堆排序算法。

用于表示社交媒体网络。每个用户都是一个顶点，并且在用户连接时会创建一条边。
用于表示搜索引擎的网页和链接。互联网上的网页通过超链接相互链接。每页是一个顶点，两页之间的超链接是一条边。用于Google中的页面排名。
用于表示GPS中的位置和路线。位置是顶点，连接位置的路线是边。用于计算两个位置之间的最短路径。

public void insertSort(int[] a){  
    int length=a.length;//数组长度，将这个提取出来是为了提高速度。  
    int insertNum;//要插入的数  
    for(int i=1;i<length;i++){//插入的次数  
        insertNum=a[i];//要插入的数  
        int j=i-1;//已经排序好的末尾元素的序列  
        while(j>=0&&a[j]>insertNum){//序列从后到前循环，将大于insertNum的数向后移动一格  
            a[j+1]=a[j];//元素移动一格  
            j--;  
        }  
        a[j+1]=insertNum;//将需要插入的数放在要插入的位置。  
    }  
}

public void sheelSort(int[] a){  
    int d  = a.length;  
    while (d!=0) {  
        d=d/2;  
        for (int x = 0; x < d; x++) {//分的组数  
            for (int i = x + d; i < a.length; i += d) {//组中的元素，从第二个数开始  
                // 以下为直接插入排序
                int j = i - d;//j为有序序列最后一位的位数  
                int temp = a[i];//要插入的元素  
                for (; j >= 0 && temp < a[j]; j -= d) {//从后往前遍历。  
                    a[j + d] = a[j];//向后移动d位  
                }  
                a[j + d] = temp;  
            }  
        }  
    }  
}  

public void selectSort(int[] a) {  
    int length = a.length;  
    for (int i = 0; i < length; i++) {//循环次数
        // 下面两个值每轮循环保存该轮最小值及位置
        int key = a[i];  
        int position=i;  
        for (int j = i + 1; j < length; j++) {//选出最小的值和位置  
            if (a[j] < key) {  
                key = a[j];  
                position = j;  
            }  
        }
        //交换位置
        a[position]=a[i];  
        a[i]=key;  
    }  
}

public  void heapSort(int[] a){  
    System.out.println("开始排序");  
    int arrayLength=a.length;  
    //循环建堆    
    for(int i=0;i<arrayLength-1;i++){  
        //建堆    
        buildMaxHeap(a,arrayLength-1-i);  
        //交换堆顶和最后一个元素    
        swap(a,0,arrayLength-1-i);  
        System.out.println(Arrays.toString(a));  
    }  
}  
private  void swap(int[] data, int i, int j) {  
    // TODO Auto-generated method stub    
    int tmp=data[i];  
    data[i]=data[j];  
    data[j]=tmp;  
}  
//对data数组从0到lastIndex建大顶堆    
private void buildMaxHeap(int[] data, int lastIndex) {  
    // TODO Auto-generated method stub    
    //从lastIndex处节点（最后一个节点）的父节点开始    
    for(int i=(lastIndex-1)/2;i>=0;i--){  
        //k保存正在判断的节点    
        int k=i;  
        //如果当前k节点的子节点存在    
        while(k*2+1<=lastIndex){  
            //k节点的左子节点的索引    
            int biggerIndex=2*k+1;  
            //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在    
            if(biggerIndex<lastIndex){  
                // 如果右子节点的值较大    
                if(data[biggerIndex]<data[biggerIndex+1]){  
                    //biggerIndex总是记录较大子节点的索引    
                    biggerIndex++;  
                }  
            }  
            //如果k节点的值小于其较大的子节点的值    
            if(data[k]<data[biggerIndex]){  
                //交换他们    
                swap(data,k,biggerIndex);  
                //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值    
                k=biggerIndex;  
            }else{  
                break;  
            }  
        }  
    }  
} 

public void bubbleSort(int[] a){  
    int length=a.length;  
    int temp;  
    for(int i=0;i<a.length;i++){  
        for(int j=0;j<a.length-i-1;j++){  
            if(a[j]>a[j+1]){  
                temp=a[j];  
                a[j]=a[j+1];  
                a[j+1]=temp;  
            }  
        }  
    }  
}

public static void quickSort(int[] numbers, int start, int end) {     
    if (start < end) {     
        int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）     
        int temp; // 记录临时中间值     
        int i = start, j = end;     
        do {     
            while ((numbers[i] < base) && (i < end))     
                i++;     
            while ((numbers[j] > base) && (j > start))     
                j--;     
            if (i <= j) {     
                temp = numbers[i];  
                numbers[i] = numbers[j];     
                numbers[j] = temp;  
                i++;     
                j--;     
            }     
        } while (i <= j);
        if (start < j)     
            quickSort(numbers, start, j);     
        if (end > i)     
            quickSort(numbers, i, end);     
    }
}

public static void sort(int []arr){
  int []temp = new int[arr.length];
  //在排序前，先建好一个长度等于原数组长度的临时数组，
  //避免递归中频繁开辟空间
  sort(arr,0,arr.length-1,temp);
}
private static void sort(int[] arr,int left,int right,int []temp){
  if(left<right){
      int mid = (left+right)/2;
      sort(arr,left,mid,temp);
      //左边归并排序，使得左子序列有序
      sort(arr,mid+1,right,temp);
      //右边归并排序，使得右子序列有序
      merge(arr,left,mid,right,temp);
      //将两个有序子数组合并操作
  }
}
private static void merge(int[] arr,int left,int mid,int right,int[] temp){
  int i = left;//左序列指针
  int j = mid+1;//右序列指针
  int t = 0;//临时数组指针
  while (i<=mid && j<=right){
      if(arr[i]<=arr[j]){
          temp[t++] = arr[i++];
      }else {
          temp[t++] = arr[j++];
      }
  }
  while(i<=mid){//将左边剩余元素填充进temp中
      temp[t++] = arr[i++];
  }
  while(j<=right){//将右序列剩余元素填充进temp中
      temp[t++] = arr[j++];
  }
  t = 0;
  //将temp中的元素全部拷贝到原数组中
  while(left <= right){
      arr[left++] = temp[t++];
  }
}

public void sort(int[] array) {  
    //首先确定排序的趟数;       
    int max = array[0];  
    for (int i = 1; i < array.length; i++) {  
        if (array[i] > max) {  
            max = array[i];  
        }  
    }  
    int time = 0;  
    //判断位数;       
    while (max > 0) {  
        max /= 10;  
        time++;  
    }  
    //建立10个队列;       
    List<ArrayList> queue = new ArrayList<ArrayList>();  
    for (int i = 0; i < 10; i++) {  
        ArrayList<Integer> queue1 = new ArrayList<Integer>();  
        queue.add(queue1);  
    }  
    //进行time次分配和收集;       
    for (int i = 0; i < time; i++) {  
        //分配数组元素;       
        for (int j = 0; j < array.length; j++) {  
            //得到数字的第time+1位数;     
            int x = array[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);  
            ArrayList<Integer> queue2 = queue.get(x);  
            queue2.add(array[j]);  
            queue.set(x, queue2);  
        }  
        int count = 0;//元素计数器;       
        //收集队列元素;       
        for (int k = 0; k < 10; k++) {  
            while (queue.get(k).size() > 0) {  
                ArrayList<Integer> queue3 = queue.get(k);  
                array[count] = queue3.get(0);  
                queue3.remove(0);  
                count++;  
            }  
        }  
    }  
} N.参考

public int[] searchRange(int[] nums, int target) {
    int len = nums.length;
    int left = 0,right = len-1;
    int[] ret = {-1,-1};
    if((len==0) || (target<nums[0]) || (target> nums[right])){
        return ret;
    }
    else if(len==1){
        if(target==nums[0]){
            ret[0] = 0;
            ret[1] = 0;
        }
        return ret;
    }
    else{
        while(left<right){
            int middle = (left+right)/2;
            if(nums[middle]<target){
                left=middle+1;
            }
            else{
                right=middle;
            }
        }
        if(nums[left]!=target){
            return ret;
        }
        else{
            ret[0] = left;
        }
        left=0;
        right=len-1;
        while(left<right){
            int middle = (left+right+1)/2;
            if(nums[middle]>target){
                right=middle-1;
            }
            else{
                left=middle;
            }
        }
        ret[1] = right;
        return ret;
    }
}

public int search(int[] nums, int target) {
    int left = 0;
    int right = nums.length-1;
    int mid;
    while(left<right){
        mid = (left+right+1)/2;
        if(target == nums[mid]){
            return mid;
        }
        if(nums[mid]>nums[right]){
            if(target<nums[mid] && target>=nums[left]){
                right = mid;
            }
            else{
                left = mid;
            }
        }
        else if(nums[mid]<nums[right]){
            if(target<=nums[right] && target>nums[mid]){
                left = mid;
            }
            else{
                right = mid;
            }
        }
        else{
            right--;
        }
    }
    if(left==right && nums[left]==target){
        return left;
    }
    else{
        return -1;
    }
}

public ListNode reverseList(ListNode head) {
    if(head == null){
        return null;
    }
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null){
        ListNode nextNode = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextNode;
    }
    return prev;
}

public ListNode reverseBetween(ListNode head, int m, int n) {
    if(head == null){
        return null;
    }
    ListNode fakeHead = new ListNode(0);
    fakeHead.next = head;
    ListNode curr = fakeHead;
    for(int i = 0;i<m-1;i++){
        curr = curr.next;
    }
    ListNode beforeHead = curr;
    curr = fakeHead;
    for(int i = 0;i<n+1;i++){
        curr = curr.next;
    }
    ListNode afterTail = curr;
    beforeHead.next = reverseAll(beforeHead.next,n - m + 1);
    curr = fakeHead;
    while (curr.next!= null){
        curr = curr.next;
    }
    curr.next = afterTail;
    return fakeHead.next;
}

public ListNode reverseAll(ListNode head,int num){
    if(head == null){
        return null;
    }
    ListNode prev = null;
    ListNode curr = head;
    for(int i = 0;i<num;i++){
        ListNode nextNode = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextNode;
    }
    return prev;
}

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if(headA == null || headB == null){
        return null;
    }
    int len1 = getListLen(headA);
    int len2 = getListLen(headB);
    ListNode pointerA = headA;
    ListNode pointerB = headB;
    //补足长度差别
    int gap = Math.abs(len1 - len2);
    for(int i=0;i<gap;i++){
        if(len1 > len2){
            pointerA = pointerA.next;
        }
        else{
            pointerB = pointerB.next;
        }
    }
    //不同向后移动，直到找到同一个
    while(pointerA != null && pointerB != null && pointerA != pointerB){
        pointerA = pointerA.next;
        pointerB = pointerB.next;
    }
    return pointerA;
}

public int getListLen(ListNode head){
    if(head == null){
        return 0;
    }
    int len1 = 0;
    int i = 0;
    ListNode pointerA = head;
    while(pointerA != null){
        pointerA = pointerA.next;
        i++;
    }
    return i;
} }

public ListNode detectCycle(ListNode head) {
    if (head == null || head.next == null){
        return null;
    }
    ListNode fast = head;
    ListNode slow = head;
    while (slow.next != null && fast.next != null && fast.next.next != null){
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast){
            slow = head;
            while (slow != fast){
                fast = fast.next;
                slow = slow.next;
            }
            return fast;
        }
    }
    return null;
}

public ListNode partition(ListNode head, int x) {
    ListNode fakeHeadLeft = new ListNode(0);
    ListNode fakeHeadRight = new ListNode(0);
    ListNode left = fakeHeadLeft;
    ListNode right = fakeHeadRight;
    partitionEach(left,right,head,x);
    left = fakeHeadLeft;
    while (left.next!= null){
        left = left.next;
    }
    left.next = fakeHeadRight.next;
    return fakeHeadLeft.next;
}

public void partitionEach(ListNode left,ListNode right,ListNode remain,int x){
    if(remain != null){
        ListNode nextNode = remain.next;
        if(remain.val < x){
            left.next = remain;
            left = left.next;
        }
        else{
            right.next = remain;
            right = right.next;
        }
        partitionEach(left,right,nextNode,x);
    }
    else{
        left.next = null;
        right.next = null;
    }
}

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if(l1 == null){
        return l2;
    }
    if(l2 == null){
        return l1;
    }
    if(l1.val < l2.val){
        ListNode nextNode = l1.next;
        l1.next = mergeTwoLists(nextNode,l2);
        return l1;
    }
    else {
        ListNode nextNode = l2.next;
        l2.next = mergeTwoLists(l1,nextNode);
        return l2;
    }
}

// 递归
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> ret = new LinkedList<>();
    if (root == null){
        return ret;
    }
    ret.add(root.val);
    List<Integer> left = preorderTraversal(root.left);
    List<Integer> right = preorderTraversal(root.right);
    ret.addAll(left);
    ret.addAll(right);
    return ret;
}

// 非递归
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> ret = new LinkedList<>();
    if (root == null){
        return ret;
    }
    Deque<TreeNode> stack = new LinkedList<>();
    stack.push(root);
    while (stack.size() > 0){
        TreeNode node = stack.pop();
        ret.add(node.val);
        if (node.right != null){
            stack.push(node.right);
        }
        if (node.left != null){
            stack.push(node.left);
        }
    }
    return ret;
}

// 递归
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> list = new LinkedList<>();
    if(root == null){
        return list;
    }
    List<Integer> left = inorderTraversal(root.left);
    ret.addAll(left);
    ret.add(root.val);
    List<Integer> right = inorderTraversal(root.right);
    ret.addAll(right);
    return list;
}

// 非递归
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> list = new LinkedList<>();
    if(root == null){
        return list;
    }
    Deque<TreeNode> stack = new LinkedList<>();
    TreeNode curr = root;
    while (curr != null || stack.size() != 0){
        while (curr != null){
            stack.push(curr);
            curr = curr.left;
        }
        TreeNode tempNode = stack.pop();
        list.add(tempNode.val);
        curr = tempNode.right;
    }
    return list;
}

public List<Integer> postorderTraversal(TreeNode root) {
    Deque<TreeNode> stack = new LinkedList<>();
    List<Integer> result = new LinkedList<>();
    if (root == null){
        return result;
    }
    stack.push(root);
    while (stack.size() > 0){
        TreeNode node = stack.pop();
        result.add(node.val);
        if (node.left != null){
            stack.push(node.left);
        }
        if (node.right != null){
            stack.push(node.right);
        }
    }
    Collections.reverse(result);
    return result;
}

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> lists = new LinkedList<>();
    if(root == null){
        return lists;
    }
    List<TreeNode> prev = new LinkedList<>();
    prev.add(root);
    while (prev.size() > 0){
        List<TreeNode> next = new LinkedList<>();
        List<Integer> addList = new LinkedList<>();
        int size = prev.size();
        for(int i = 0;i<size;i++){
            TreeNode node = prev.get(i);
            addList.add(node.val);
            if(node.left != null){
                next.add(node.left);
            }
            if(node.right != null){
                next.add(node.right);
            }
        }
        lists.add(addList);
        prev = next;
    }
    return lists;
}

package cn.zhanghao90.test;

import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class SymmetricUtil {
	public static String encrypt3DES(String value, String key) throws Exception {
		if (null == value || "".equals(value)) {
			return "";
		}

		byte[] valueByte = value.getBytes();
		byte[] sl = encrypt3DES(valueByte, BytesUtil.hexToBytes(key));
		String result = Base64.encodeBase64String(sl);

		return result;
	}

	public static byte[] encrypt3DES(byte[] input, byte[] key) throws Exception {
		Cipher c = Cipher.getInstance("DESede/ECB/PKCS5Padding");
		c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "DESede"));
		return c.doFinal(input);
	}

	public static String decrypt3DES(String value, String key) throws Exception {
		if (null == value || "".equals(value)) {
			return "";
		}

		byte[] valueByte = Base64.decodeBase64(value);
		byte[] sl = decrypt3DES(valueByte, BytesUtil.hexToBytes(key));
		String result = new String(sl);
		return result;
	}

	public static byte[] decrypt3DES(byte[] input, byte[] key) throws Exception {
		Cipher c = Cipher.getInstance("DESede/ECB/PKCS5Padding");
		c.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "DESede"));
		return c.doFinal(input);
	}

	public static String encryptAES(String value, String key) throws Exception {
		if (null == value || "".equals(value)) {
			return "";
		}

		byte[] valueByte = value.getBytes();
		byte[] sl = encryptAES(valueByte, BytesUtil.hexToBytes(key));
		String result = Base64.encodeBase64String(sl);

		return result;
	}

	public static byte[] encryptAES(byte[] input, byte[] key) throws Exception {
		Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
		c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"));
		return c.doFinal(input);
	}

	public static String decryptAES(String value, String key) throws Exception {
		if (null == value || "".equals(value)) {
			return "";
		}

		byte[] valueByte = Base64.decodeBase64(value);
		byte[] sl = decryptAES(valueByte, BytesUtil.hexToBytes(key));
		String result = new String(sl);
		return result;
	}

	public static byte[] decryptAES(byte[] input, byte[] key) throws Exception {
		Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
		c.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"));
		return c.doFinal(input);
	}
	
}

package cn.zhanghao90.test;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSAUtils {

    /**
     * 加密算法RSA
     */
    public static final String RSA_ALGORITHM = "RSA";
    public static final String RSA_ECB_OAEP_PADDING = "RSA/ECB/OAEPPadding";
    public static final String BC_PROVIDER = "BC";

    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /**
     * 获取公钥的key
     */
    public static final String PUBLIC_KEY = "RSAPublicKey";
    /**
     * 获取私钥的key
     */
    public static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 签名长度
     */
    private static final int KEY_SIZE = 2048;
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 245;
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 256;

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * <P>
     * 私钥解密2048
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param privateKey    私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey2048(byte[] encryptedData,
                                                 String privateKey) throws Exception {
        byte[] keyBytes = decode64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM,
                BC_PROVIDER);
        RSAPrivateKey privateK = (RSAPrivateKey) keyFactory
                .generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(RSA_ECB_OAEP_PADDING, BC_PROVIDER);
        cipher.init(Cipher.DECRYPT_MODE, privateK);

        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        for (int i = 0; i < inputLen - offSet; offSet = i * MAX_DECRYPT_BLOCK) {
            byte[] cache;
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher
                        .doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher
                        .doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            ++i;
        }

        byte[] output = out.toByteArray();
        out.close();
        return output;
    }

    /**
     * <p>
     * 公钥解密2048
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param publicKey     公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey2048(byte[] encryptedData,
                                                String publicKey) throws Exception {
        byte[] keyBytes = decode64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM,
                BC_PROVIDER);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(RSA_ECB_OAEP_PADDING, BC_PROVIDER);
        cipher.init(Cipher.DECRYPT_MODE, publicK);

        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher
                        .doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher
                        .doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * <p>
     * 私钥加密2048
     * </p>
     *
     * @param data       源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey2048(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = decode64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM,
                BC_PROVIDER);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(RSA_ECB_OAEP_PADDING, BC_PROVIDER);
        cipher.init(Cipher.ENCRYPT_MODE, privateK);

        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * <p>
     * 公钥加密2048
     * </p>
     *
     * @param data      源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey2048(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = decode64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM,
                BC_PROVIDER);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(RSA_ECB_OAEP_PADDING, BC_PROVIDER);
        cipher.init(Cipher.ENCRYPT_MODE, publicK);

        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     *
     * @param data       已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = decode64(privateKey);

        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM,
                BC_PROVIDER);

        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM,
                BC_PROVIDER);
        signature.initSign(privateK);
        signature.update(data);
        return encode64(signature.sign());
    }

    /**
     * <p>
     * 校验数字签名
     * </p>
     *
     * @param data      已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign      数字签名
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = decode64(publicKey);

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM,
                BC_PROVIDER);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM,
                BC_PROVIDER);

        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(decode64(sign));
    }

    /**
     * Created on 2013-5-31
     * <p>
     * Discription:编码
     * </p>
     *
     * @return String
     */
    public static String encode64(byte[] b) {
        return Base64.encodeBase64String(b);
    }

    /**
     * Created on 2013-5-31
     * <p>
     * Discription:解码
     * </p>
     *
     * @return byte[]
     */
    public static byte[] decode64(String s) {
        return Base64.decodeBase64(s);
    }

    /**
     * <p>
     * 获取私钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return encode64(key.getEncoded());
    }

    /**
     * <p>
     * 获取公钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return encode64(key.getEncoded());
    }

    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator
                .getInstance(RSA_ALGORITHM);
        keyPairGen.initialize(KEY_SIZE);

        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    public static void main(String[] args) throws UnsupportedEncodingException {
        Map<String, Object> keyPair;
        try {
            keyPair = genKeyPair();
            String publicStr = RSAUtils.getPublicKey(keyPair);
            String privateStr = RSAUtils.getPrivateKey(keyPair);

            System.out.println("pub: " + publicStr);
            System.out.println("pri: " + privateStr);

            String text = "aaa";
            byte[] encryped = RSAUtils.encryptByPublicKey2048(text.getBytes(),
                    publicStr);
            byte[] decryped = RSAUtils.decryptByPrivateKey2048(encryped,
                    privateStr);
            System.out.println("text: " + text + ", decry: "
                    + new String(decryped));

            String text2 = "bbb";
            byte[] encryped2 = RSAUtils.encryptByPrivateKey2048(
                    text2.getBytes(), privateStr);
            byte[] decryped2 = RSAUtils.decryptByPublicKey2048(encryped2,
                    publicStr);
            System.out.println("text: " + text2 + ", decry: "
                    + new String(decryped2));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

A有p和g两个参数，A还有一个属于自己的私有参数x；
B有p和g两个参数，A还有一个属于自己的私有参数y；
A和B均使用相同的加密算法计算其对应的值：value_A=p^(x%g)，value_B=p^(y%g)
随后双方交换计算后的值，然后再分别使用自己的私有参数对去求次方，如：
A拿到value_B值后，对其求x平方得value_B^x=p^(xy%g)；
B拿到value_A值后，对其求y平方得value_A^y=p^(xy%g)；
最终得到的结果是一致的。在整个过程中，第三方人员只能获取p、g两个值，AB双方交换的是计算后的结果，因此这种方式是很安全的。

平衡性(Balance)：平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去，这样可以使得所有的缓冲空间都得到利用。很多哈希算法都能够满足这一条件。
单调性(Monotonicity)：单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲区加入到系统中，那么哈希的结果应能够保证原有已分配的内容可以被映射到新的缓冲区中去，而不会被映射到旧的缓冲集合中的其他缓冲区。
分散性(Spread)：在分布式环境中，终端有可能看不到所有的缓冲，而是只能看到其中的一部分。当终端希望通过哈希过程将内容映射到缓冲上时，由于不同终端所见的缓冲范围有可能不同，从而导致哈希的结果不一致，最终的结果是相同的内容被不同的终端映射到不同的缓冲区中。这种情况显然是应该避免的，因为它导致相同内容被存储到不同缓冲中去，降低了系统存储的效率。分散性的定义就是上述情况发生的严重程度。好的哈希算法应能够尽量避免不一致的情况发生，也就是尽量降低分散性。
负载(Load)：负载问题实际上是从另一个角度看待分散性问题。既然不同的终端可能将相同的内容映射到不同的缓冲区中，那么对于一个特定的缓冲区而言，也可能被不同的用户映射为不同的内容。与分散性一样，这种情况也是应当避免的，因此好的哈希算法应能够尽量降低缓冲的负荷。
平滑性(Smoothness)：平滑性是指缓存服务器的数目平滑改变和缓存对象的平滑改变是一致的。