任何试图更改生物钟的行为，都将给身体留下莫名其妙的疾病，
20、30年之后再后悔，已经来不及了。　　
一、晚上9-11点为免疫系统（淋巴）排毒时间，此段时间应安静或听音乐。　　
二、晚间11-凌晨1点，肝的排毒，需在熟睡中进行。　　
三、凌晨1-3点，胆的排毒，亦同。　　
四、凌晨3-5点，肺的排毒。此即为何咳嗽的人在这段时间咳得最剧烈，因排毒动作已走到肺；不应用止咳药，以免抑制废积物的排除。　　
五、凌晨5-7点，大肠的排毒，应上厕所排便。
六、凌晨7-9点，小肠大量吸收营养的时段，应吃早餐。疗病者最好早吃，在６点半前，养生者在７点半前，不吃早餐者应改变习惯，即使拖到９、10点吃都比不吃好。　　
七、半夜至凌晨4点为脊椎造血时段，必须熟睡，不宜熬夜

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

最近在学校工作室做项目时碰到一个Hibernate复合主键的问题，也就是多对多映射的时候中间表不使用代理主键的话会用到复合主键，如果使用代理主键的话，那么中间表的外键肯定是many-to-one的，这样的话跟业务要求不合（即两端的主键合成的中间表外键必须是唯一的，而这样能做到不唯一）。物理模型见附件。

大概描述：

收邮件

用户表-n----m-用户_邮件表-p----n-邮件表

发邮件

用户表-n-----1-邮件表

中间表的映射：

<composite-id name="id" class="cn.magicoa.skstudio.domain.UserMailId" >
            <key-many-to-one name="mailChit" class="cn.magicoa.skstudio.domain.MailChit">
                <column name="MailId" />
            </key-many-to-one>
            <key-many-to-one name="oaUser" class="cn.magicoa.skstudio.domain.OaUser" lazy="false">
                <column name="Uid" />
            </key-many-to-one>
</composite-id>

	private MailChit mailChit;
	private OaUser oaUser;

这样的话发邮件的用户获取该邮件的接收者列表将非常吃力，默认的这个复合主键的lazy=true，而如果改为false的话效率会非常底，因为如果用户要获取发邮件列表的话不需要收邮件人列表，所以只能在hql查询中使用fetch抓取的方式。请问大家有没有其他的解决方案。

中间表POJO类UserMail：

	private UserMailId id;
	private Short type;
	private Short isNew;

这样的话需要生成一个UserMailId复合主键POJO类：

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师

 前段时间搞了一个简单的单用户登陆实现例子,虽然不能实现敏捷反应，但是对安全相对要求底的系统还是可以考虑的。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

   以前碰到一个延迟加载问题,就是lazy=true的时候出现session close后读取不到数据,出现错误,现在这里总结一下经验:

一:lazy=false,这种方式效率底,不合适.

二:fetch=join,这种方式和上一种差不多.

三:使用OpensessionInView,这种方式事务管理有很多不稳定性(主要存在事务边界的不确定性),此时lazy=true.

四:就是在DAO层把数据read出来,lazy=true,这样不符合ORM关联查询思想.

五:个人认为最佳方案,就是使用动态外连接查询,此时lazy=true.

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

由于为了看到效果，这里使用一个公共的输出类只控制输出：

package test;

public class Print{
	
	public static void println(Object o){
		
		System.out.println(o);
	}
	
	public static void print(Object o){
		
		System.out.print(o);
	}
}

package test;

import java.util.regex.Pattern;
import java.util.regex.Matcher;
import static test.Print.*;

/*
 *认识正则表达式的概念
 *用途:
 *1、字符串匹配；
 *2、字符串查找；
 *3、字符串替换。
 */
public class Test{
	
	public static void main(String[] args){
		
		println("abc".matches("..."));
		println("abc9796fa56j".replaceAll("\\d","_")); //把所有数字替换成下划线
		
		Pattern ptn = Pattern.compile("[a-z]{3}");  //匹配任意三个连续的英文字符
		Matcher mt = ptn.matcher("bey");
		println(mt.matches());
		
		//上面的三句话可以用一句来表达
		println("bey".matches("[a-z]{3}"));
		
		
	}
}

package test;

import java.util.regex.*;
import static test.Print.*;

/*
 * 预定义字符类 
 * \\\\表示\斜杠
 * . 任何字符（与行结束符可能匹配也可能不匹配） 
 * \d 数字：[0-9] 
 * \D 非数字： [^0-9] 
 * \s 空白字符：[\t\n\x0B\f\r] 
 * \S 非空白字符：[^\s]
 * \w 单词字符：[a-zA-Z_0-9] 
 * \W 非单词字符：[^\w] 
 * 注意：\s匹配\r,\n,\r，\f和空格
 */
public class Demo1{
	
	
	public static void main(String[] args){
		
		//判断斜杠
		println("0:" + "\\".matches("\\\\"));
		
		//判断任意字符
		println("1:" + "a".matches("."));   //返回true
		
		//判断数字字符
		println("2:" + "8".matches("\\d"));  //判断是否是数字,返回true
		println("3:" + "89".matches("\\d")); //只能用于判断一个数字,返回false
		println("4:" + "7".matches("\\D"));  //由于7是数字字符,所以返回false
		println("5:" + "&".matches("\\D"));  //返回true
		
		//空白字符
		println("6:" + " ".matches("\\s"));   //返回true
		println("7:" + "7".matches("\\s"));   //返回false
		println("8:" + " ".matches("\\S"));   //返回false
		
		//单词字符
		println("9:" + "+".matches("\\w"));   //返回false
		println("10:" + "7".matches("\\w"));   //返回true
		println("11:" + "_".matches("\\W"));   //返回false
		println("12:" + "b".matches("\\w"));   //返回true
		
		//特殊字符
		println("13:" + "\n".matches("\\s"));  //返回true
				
	}
	
	
}

package test;

import java.util.regex.*;
import static test.Print.*;

/*
 * Greedy 数量词
 * X? X，一次或一次也没有 
 * X* X，零次或多次 
 * X+ X，一次或多次 
 * X{n} X，恰好 n 次 
 * X{n,} X，至少 n 次 
 * X{n,m} X，至少 n 次，但是不超过 m 次 
 *
 */
public class Demo2{
	
	public static void main(String[] args){
		
		println("1: " + "ab".matches("ab"));  //精确匹配
		
		println("2: " + "a".matches("a?"));   //a可以出现一次,也可以没有
		println("3: " + "b".matches("a?"));
		
		
		println("4: " + "".matches("a*"));   //a可以出现零次或多次
		println("5: " + "aa".matches("a*"));
		
		println("6: " + "".matches("a+"));   //a必须出现一次或多次
		println("7: " + "aaa".matches("a+"));
		
		println("8: " + "a".matches("a{3}"));   //a必须出现恰好n次
		println("9: " + "aaa".matches("a{3}"));

		println("10: " + "a".matches("a{3,7}"));   //a必须出现最少n次,最多m次
		println("11: " + "aaaa".matches("a{3,7}"));
		
		//下面是自我提高练习
		println("基本判断一个ip:");
		print("判断192.168.10.8是不是ip地址:");
		println("192.168.10.8".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
		print("判断192.168.baby.8是不是ip地址:");
		println("192.168.baby.8".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
		
		//上面的也可以使用Pattern来判断
		println("使用Pattern来实现");
		Pattern pt = Pattern.compile("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}");
		print("判断192.168.10.8是不是ip地址:");
		println(pt.matcher("192.168.10.8").matches());
		
		//判断EMAIL地址
		println("EMAIL判断");
		pt = Pattern.compile("[a-zA-Z0-9|_|-]{3,}@[a-zA-Z0-9]{3,}\\.[a-zA-Z0-9]{2,}");
		print("判断beyondqinghua@gmail.com是否是Eamil地址:");
		println(pt.matcher("beyondqinghua@gmail.com").matches());
		
		print("判断116203610beyond@gmail.com是否是Eamil地址:");
		println(pt.matcher("116203610beyond@gmail.com").matches());
		
		print("判断116203610_beyond-life@gmail.com是否是Eamil地址:");
		println(pt.matcher("116203610_beyond-life@gmail.com").matches());
		
		print("判断116203610*beyond-life@gmail.com是否是Eamil地址:");
		println(pt.matcher("116203610*beyond-life@gmail.com").matches());
	}
}

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package com.beyondlife.demo2;


/*
 * 这个类拥有三个静态方法用于数组排序
 * 
 */
public class NumberSort {

	public static final int ASC = 1; //升序排列
	public static final int DES = 2; //降序排列
	
	/*冒泡排序
	 * 算法设计:此算法利用前后的元素大小进行比较,交换位置;
	 * 要实现整个数组的排序需要使用外循环来控制遍历次数;
	 * 内循环来控制前后两元素的比较次数,一次内循环之后可以找出最大的或最小的放在右边.
	 * 
	 */
	public static  void bubbleSort(int list[],int type){
		
		int length = list.length;//数组的数据个数
		int flag = 1;            //标志位,判断此数组本身是否已经有序
		int temp = 0;            //中间数据,用于位置替换
		int i = 0;               //用于循环次数
		int j = 0;               //用于比较次数
		
		if(type == ASC){         //升序排序
			flag = 1;
			
			for(i = 1;i < length && flag == 1;i++){              //控制循环次数
				
				flag = 0;
				for(j = 0;j < length - i;j++){  //控制比较次数
					if(list[j] > list[j+1]){
						temp = list[j];
						list[j] = list[j + 1];
						list[j + 1] = temp;
						flag = 1;                   //修改标志位
					}//end if
				}//end inner for
			}//end outter for
			
		}else if(type == DES){     //降序排序
			
			flag = 1;
			
			for(i = 1;i < length && flag == 1;i++){              //控制循环次数
				
				for(j = i + 1;j < length - i;j++){  //控制比较次数
					if(list[j] < list[j+1]){
						temp = list[j];
						list[j] = list[j + 1];
						list[j + 1] = temp;
						flag = 1;                   //修改标志位
					}//end if
				}//end inner for
			}//end outter for
		}
	}
	
	/*选择排序
	 * 算法设计:选择排序不需要每比较两个元素就交换两其位置,
	 * 而是每次扫描一遍数据找出最大或最小的元素把其与左边排好序的元素的下一元素交换位置
	 * 
	 */
	public static void selectSort(int list[],int type){
		
		int length = list.length;        //数组的元素个数
		int pos = 0;                     //最大或最小元素的位置
		int i = 0;                       //控制循环的次数
		int j = 0;                       //用于查找元素的位置
		int temp = 0;                    //用于临时交换位置的元素
		
		if(type == ASC){//升序排序
			
			for(i = 0;i < length ;i++){
				pos = i;
				for(j = i + 1;j < length;j++){
					if(list[j] < list[pos])//查找未排序部分的最小元素
						pos = j;
				}//end inner for
				
				if(pos != i){            
					temp = list[i];
					list[i] = list[pos];
					list[pos] = temp;
				}
			}//end outer for
		}else if(type == DES){//降序排序
			
			for(i = 0;i < length ;i++){
				pos = i;
				for(j = i + 1;j < length;j++){
					if(list[j] > list[pos])//查找未排序部分的最大元素
						pos = j;
				}//end inner for
				
				if(pos != i){            
					temp = list[i];
					list[i] = list[pos];
					list[pos] = temp;
				}
			}//end outer for
		}
		
	}
	
	/*插入排序
	 *算法设计:此算法也是局部有序的,这里假设左边有序,
	 *那么现在需要把有序的下一个元素插入到有序的一端,
	 *这样需要移动有序的一端使空出合适的位置给插入原素
	 */
	public static void insertSort(int list[],int type){
		
		int length = list.length;        //数组的元素个数
		int i = 0;                       //控制循环的次数
		int j = 0;                       //用于定位元素
		int temp = 0;                    //用于临时交换位置的元素
		if(type == ASC){//升序排序
			
			for(i = 1;i < length;i++){             //控制循环次数
				j = i;
				temp = list[i];
				while(j > 0 && list[j - 1] > temp){//找到插入的位置
					list[j] = list[j-1];           //比插入元素大的元素须向后移动
					j--;
				}
				list[j] = temp;                    //插入元素
			}//end for
		}else if(type == DES){
			
			for(i = 1;i < length;i++){             //控制循环次数
				j = i;
				temp = list[i];
				while(j > 0 && list[j - 1] < temp){//找到插入的位置
					list[j] = list[j-1];           //比插入元素小的元素须向后移动
					j--;
				}
				list[j] = temp;                    //插入元素
			}//end for
		}
		
	}

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

import java.util.LinkedList;

/*
 *利用LinkedList来实现堆栈
 *LinkedList容器具有有续性,以及插入删除方便的特征
 *
 */
public class Stack<T>{
	
	//建立一个链表保存数据
	private LinkedList<T> stack;
	
	public Stack(){
		
		stack = new LinkedList<T>();
	}
	
	//入栈操作
	public void push(T obj){
		
		stack.addFirst(obj);
	}
	
	//获取栈顶元素
	public T peek(){
		
		//判断栈是否为空
		if(!isEmpty()){
			
			return stack.getFirst();
			
		}else{
			
			return null;
		}
		
	}
	
	//出栈操作
	public T pop(){
		
		//判断栈是否为空
		if(!isEmpty()){
			
			return stack.removeFirst();
			
		}else{
			
			return null;
		}
		
	}
	
	//判断栈是否为空
	public boolean isEmpty(){
		
		return stack.isEmpty();
	}
	
	//测试堆栈
	public static void main(String[] args){
		
		String[] list = "my name is beyondlife".split(" ");
		
		Stack<String> stack = new Stack<String>();
		
		for(String obj : list){
			
			stack.push(obj);
		}
		
		while(stack.peek() != null){
			
			System.out.print(stack.pop() + " ");
		}
	}
}

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

下面是为实现一个高质量equals方法的处方：

1、  使用==操作符检查“实参是否为指向对象的一个引用”。

2、  使用instanceof操作符检查“实参是否为正确的类型”。

3、  把实参转换到正确的类型。

4、  对于该类中的每一个“关键”域，检查实参中的域是否与当前对象中对应的域值匹配。数值可以直接使用==比较，实例可以使用field==null?o.field==null:field.equals(o.field)。

5、  当你编写完equals方法之后，应该问自己三个问题：他是否是对称的、传递的、一致的？

一些告戒：

1、  当你改写equals的时候，总要改写hashCode。

2、  不要企求你的equals方法过于繁杂（周全）。

3、  不要使equals方法依赖于不稳定的资源，比如transient类型。

• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1、  把某个非零常数值，比如17，保存在一个叫result的int类型的变量中。

2、  对于对象中的关键域f(指equals方法中考虑的每一个域)，完成以下步骤：

A、为该域计算int类型的散列码c:

I、               如果该域是boolean类型，则计算(f ? 0 : 1)。

II、            如果该域是byte、char、short或者int类型，则计算(int)f。

III、          如果该域是long类型，则计算(int)(f ^ f ( f >> 32 ) )。

IV、          如果该域是float类型，则计算Float.floatToInitBits( f )。

V、            如果该域是double类型，则计算Double.doubleToLongBits( f )得到一个long类型的值，再执行步骤III。

VI、          如果该域是一个对象引用，并且该类的equals方法通过递归调用equals的方式来比较这个域，则同样对这个递归调用hashCode。如果要求一个更为复杂的比较，则为这个域计算一个规范表示，然后针对这个范式表示调用hashCode。如果这个域为NULL，则返回0或者其他常数。

VII、       如果该域是一个数组，则把每个元素当作单独的域来处理。也就是说，递归地应用上述规则，对每个重要的元素计算一个散列码，然后根据步骤B中的做法把这些散列码组合起来。

B、 按照下面的公式，把上面步骤的C组合到result中：

result = 17 * result + c;

3、  返回result。

4、  写完后测试是否相等的实例具有相同的散列码。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师