这个算法简单,而且效率高,每次可以操作8个字节的数据,加密解密的KEY为16字节,即包含4个int数据的int型数组,加密轮数应为8的倍数,一般比较常用的轮数为64,32,16,推荐用64轮.
源代码如下:
/** *//**
* Tea算法
* 每次操作可以处理8个字节数据
* KEY为16字节,应为包含4个int型数的int[]，一个int为4个字节
* 加密解密轮数应为8的倍数，推荐加密轮数为64轮
* */
public class Tea {
//加密
public byte[] encrypt(byte[] content, int offset, int[] key, int times){//times为加密轮数
int[] tempInt = byteToInt(content, offset);
int y = tempInt[0], z = tempInt[1], sum = 0, i;
int delta=0x9e3779b9; //这是算法标准给的值
int a = key[0], b = key[1], c = key[2], d = key[3];
for (i = 0; i ＜ times; i++) {
sum += delta;
y += ((z＜＜4) + a) ^ (z + sum) ^ ((z＞＞5) + b);
z += ((y＜＜4) + c) ^ (y + sum) ^ ((y＞＞5) + d);
}
tempInt[0]=y;
tempInt[1]=z;
return intToByte(tempInt, 0);
}
//解密
public byte[] decrypt(byte[] encryptContent, int offset, int[] key, int times){
int[] tempInt = byteToInt(encryptCo ......

package com.tiantian;
import java.util.*;
public class JAVAContainer {
public static void main(String[] args) throws Exception {
// ArrayList
{
ArrayList arraylist = new ArrayList();
arraylist.add(0, "end");//指定索引加入值
// 需注意的是，如果现有2个值，我尤胨饕?的那么就会出现异常
for (int i = 0; i < 2; i++) {
arraylist.add(i, String.valueOf(i));
}
System.out.println("ArrayList:");
for (int i = 0; i < arraylist.size(); i++) {
System.out.print(arraylist.get(i) + ";");
}
arraylist.add("0");//直接加入值到ArrayList的最后
arraylist.add("0");
System.out.print(" ArrayList's lastIndexOf("0") is "
+ arraylist.lastIndexOf("0"));
}
// Arrays
{
String[] array = new String[] { "a", "b", "c" };
List list = Arrays.asList(array);
System.out.println(" Arrays:");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ";");
}
System.out.print(" Arrays's length is " + array.length);//打印数组的长度
}
// Collections
{
String[] array = new St ......

Read-Write Lock Pattern的参与者：
1. Reader（读取者）参与者
    Reader参与者会对SharedResource参与者进行read。
2. Writer（写入者）参与者
    Writer参与者会对SharedResource参与者进行write。
3. SharedResource（共享资源）参与者
    SharedResource参与者代表Reader与Writer所共享的资源。
    SharedResource参与者会提供不会改变内部状态的操作（read）和会改变内部状态的操作（write）。
4. ReadWriteLock（读写用锁定）参与者
    ReadWriteLock参与者提供了对SharedResource参与者进行read操作与进行write操作时需要的锁定。
    为了完成read操作，提供了readLock与readUnlock。
    为了完成write操作，提供了writeLock和writeUnlock。
------------------------------
Read-Write Lock Pattern适合读取比写入次数频繁的情况。
Read-Write Lock Pattern李永乐读取操作彼此之间不会冲突的特性，使得多个Reader参与者可以同时进行read，以提升程序的性能。
不过当写入操作频率较高时，Writer参与者会经常阻拦Reader参与者的read ......

import java.net.InetAddress;
import java.io.InputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.text.ParseException;
import java.util.StringTokenizer;
public final class NetworkInfo {
private final static String getMacAddress() throws IOException {
String os = System.getProperty("os.name");
try {
if (os.startsWith("Windows")) {
return windowsParseMacAddress(windowsRunIpConfigCommand());
} else if (os.startsWith("Linux")) {
return linuxParseMacAddress(linuxRunIfConfigCommand());
} else {
throw new IOException("unknown operating system: " + os);
}
} catch (ParseException ex) {
ex.printStackTrace();
throw new IOException(ex.getMessage());
}
}
/*
* Linux stuff
*/
private final static String linuxParseMacAddress(String ipConfigResponse)
throws ParseException {
String localHost = null;
try {
localHost = InetAddress.getLocalHost().getHostAddress();
} catch (java.net.UnknownHostException ex) {
ex.printStackTrace();
throw new ......

如果对数据库进行多次操作,每一次的执行或步骤都是一个事务.如果数据库操作在某一步没有执行或出现异常而导致事务失败,这样有的事务被执行有的就没有被执行,从而就有了事务的回滚,取消先前的操作.....
JavaBean中使用JDBC方式进行事务处理
public int delete(int sID) {
　dbc = new DataBaseConnection();
　Connection con = dbc.getConnection();
　try {
　　con.setAutoCommit(false);// 更改JDBC事务的默认提交方式
　　dbc.executeUpdate("delete from xiao where ID=" + sID);
　　dbc.executeUpdate("delete from xiao_content where ID=" + sID);
　　dbc.executeUpdate("delete from xiao_affix where bylawid=" + sID);
　　con.commit();//提交JDBC事务
　　con.setAutoCommit(true);// 恢复JDBC事务的默认提交方式
　　dbc.close();
　　return 1;
　}
　catch (Exception exc) {
　　con.rollBack();//回滚JDBC事务
　　exc.printStackTrace();
　　dbc.close();
　　return -1;
　}
}
在数据库操作中，一项事务是指由一条或多条对数据库更新的sql语句所组成的一个不可分割的工作单元。只有当事务中的所有操作都正常完成了，整个事务才 ......

数组最常用的应该就是.length 数组长度，数组所能容纳个的元素个数！而不是应用的数组元素个数，比如new了个20个给这个数组对象，但是用了10个.length的值为20。
foreach语法(仅当jdk为5.0时可用)：
一维：
int shuzu = {1,1,1,1,1,1};
for（int element : shuzu）{
System.out.print(enement+"\t");
}
二维：
int shuzu = {{1,2,3,4,5},{1,2,3,4,5}};
for(int[] row : shuzu){
int i=0;
for(int element : row){
System.out.print(element+"\t");
if(++i==(row.length));
System.out.println();
}
}
还有就是java.util中Arrays类数组的方法：
按照升序方式排序：Arrays.sort(数组对象)；
查找数据：Arrays.binarySearch(数组对象，"要查的")；
复制数据：Arrays.copyOf();
               Arrays.copyOfRangs();
转换字符串：Arrays.toString();
                 Arrays.deepToString();
比较相等性：Arrays.equals();
         &nb ......