第一组
　　1.烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢?

　　2.你有一桶果冻，其中有黄色、绿色、红色三种，闭上眼睛抓取同种颜色的两个。抓取多少个就可以确定你肯定有两个同一颜色的果冻?

　　3.如果你有无穷多的水，一个3公升的提捅，一个5公升的提捅，两只提捅形状上下都不均匀，问你如何才能准确称出4公升的水?

　　4.一个岔路口分别通向诚实国和说谎国。来了两个人，已知一个是诚实国的，另一个是说谎国的。诚实国永远说实话，说谎国永远说谎话。现在你要去说谎国，但不知道应该走哪条路，需要问这两个人。请问应该怎么问?

　　5.12个球一个天平，现知道只有一个和其它的重量不同，问怎样称才能用三次就找到那个球。13个呢?(注意此题并未说明那个球的重量是轻是重，所以需要仔细考虑)

　　6.在9个点上画10条直线，要求每条直线上至少有三个点?

　　7.在一天的24小时之中，时钟的时针、分针和秒针完全重合在一起的时候有几次?都分别是什么时间?你怎样算出来的?

　　8.怎么样种植4棵树木，使其中任意两棵树的距离相等?

　　第二组

　　1.为什么下水道的盖子是圆的?

　　2.中国有多少辆汽车?

　　3.将汽车钥匙插入车门，向哪个方向旋转就可以打开车锁?

　　4.如果你要去掉中国的34个省(含自治区、直辖市和港澳特区及台湾省)中的任何一个，你会去掉哪一个，为什么?

　　5.多少个加油站才能满足中国的所有汽车?

　　6.想象你站在镜子前，请问，为什么镜子中的影象可以颠倒左右，却不能颠倒上下?

　　7.为什么在任何旅馆里，你打开热水，热水都会瞬间倾泻而出?

　　8.你怎样将Excel的用法解释给你的奶奶听?

　　9.你怎样重新改进和设计一个ATM银行自动取款机?

　　10.如果你不得不重新学习一种新的计算机语言，你打算怎样着手来开始?

　　11.如果你的生涯规划中打算在5年内受到奖励，那获取该项奖励的动机是什么?观众是谁?

　　12.如果微软告诉你，我们打算投资五百万美元来启动你的投资计划，你将开始什么样商业计划?为什么?

　　13.如果你能够将全世界的电脑厂商集合在一个办公室里，然后告诉他们将被强迫做一件事，那件事将是什么?　



第三组

　　1.你让工人为你工作7天，回报是一根金条，这个金条平分成相连的7段，你必须在每天结束的时候给他们一段金条。如果只允许你两次把金条弄断，你如何给你的工人付费?

　　2.有一辆火车以每小时15公里的速度离开北京直奔广州，同时另一辆火车每小时20公里的速度从广州开往北京。如果有一只鸟，以30公里每小时的速度和两辆火车同时启动，从北京出发，碰到另一辆车后就向相反的方向返回去飞，就这样依次在两辆火车之间来回地飞，直到两辆火车相遇。请问，这只鸟共飞行了多长的距离?

　　3.你有四个装药丸的罐子，每个药丸都有一定的重量，被污染的药丸是没被污染的药丸的重量+1。只称量一次，如何判断哪个罐子的药被污染了?

　　4.门外三个开关分别对应室内三盏灯，线路良好，在门外控制开关时候不能看到室内灯的情况，现在只允许进门一次，确定开关和灯的对应关系?

　　5.人民币为什么只有1、2、5、10的面值?

　　6.你有两个罐子以及50个红色弹球和50个蓝色弹球，随机选出一个罐子， 随机选出一个弹球放入罐子，怎么给出红色弹球最大的选中机会?在你的计划里，得到红球的几率是多少?

　　7.给你两颗6面色子，可以在它们各个面上刻上0-9任意一个数字，要求能够用它们拼出任意一年中的日期数值

　　第四组

　　第一题 . 五个海盗抢到了100颗宝石，每一颗都一样大小和价值连城。他们决定这么分：

　　抽签决定自己的号码(1、2、3、4、5)

　　首先，由1号提出分配方案，然后大家表决，当且仅当超过半数的人同意时，按照他的方案

　　进行分配，否则将被扔进大海喂鲨鱼

　　如果1号死后，再由2号提出分配方案，然后剩下的4人进行表决，当且仅当超过半数的人同

　　意时，按照他的方案进行分配，否则将被扔入大海喂鲨鱼

　　依此类推

　　条件：每个海盗都是很聪明的人，都能很理智地做出判断，从而做出选择。

　　问题：第一个海盗提出怎样的分配方案才能使自己的收益最大化?

　　第二题 . 一道关于飞机加油的问题，已知：

　　每个飞机只有一个油箱，

　　飞机之间可以相互加油(注意是相互，没有加油机)

　　一箱油可供一架飞机绕地球飞半圈，

　　问题：

　　为使至少一架飞机绕地球一圈回到起飞时的飞机场，至少需要出动几架飞机?(所有飞机从同一机场起飞，而且必须安全返回机场，不允许中途降落，中间没有飞机场)第三题. 汽车加油问题

　　一辆载油500升的汽车从A开往1000公里外的B，已知汽车每公里耗油量为1升，A处有无穷多的油，其他任何地点都没有油，但该车可以在任何地点存放油以备中转，问从A到B最少需要多少油

　　第四题. 掷杯问题

　　一种杯子，若在第N层被摔破，则在任何比N高的楼层均会破，若在第M层不破，则在任何比M低的楼层均会破，给你两个这样的杯子，让你在100层高的楼层中测试，要求用最少的测试次数找出恰巧会使杯子破碎的楼层。

　　第五题. 推理游戏

　　教授选出两个从2到9的数，把它们的和告诉学生甲，把它们的积告诉学生乙，让他们轮流猜这两个数

　　甲说：“我猜不出”

　　乙说：“我猜不出”

　　甲说：“我猜到了”

　　乙说：“我也猜到了”

　　问这两个数是多少

　　第六题. 病狗问题

　　一个住宅区内有100户人家，每户人家养一条狗，每天傍晚大家都在同一个地方遛狗。已知这些狗中有一部分病狗，由于某种原因，狗的主人无法判断自己的狗是否是病狗，却能够分辨其他的狗是否有病，现在，上级传来通知，要求住户处决这些病狗，并且不允许指认他人的狗是病狗(就是只能判断自己的)，过了7天之后，所有的病狗都被处决了，问，一共有几只病狗?为什么?

　　第七题. U2合唱团在17分钟内得赶到演唱会场，途中必需跨过一座桥，四个人从桥的同一端出发，你得帮助他们到达另一端，天色很暗，而他们只有一只手电筒。一次同时最多可以有两人一起过桥，而过桥的时候必须持有手电筒，所以就得有人把手电筒带来带去，来回桥两端。手电筒是不能用丢的方式来传递的。四个人的步行速度各不同，若两人同行则以较慢者的速度为准。BONO需花1分钟过桥,EDGE需花2分钟过桥,ADAM需花5分钟过桥,LARRY需花10分钟过桥,他们要如何在17分钟内过桥呢?

　　第八题. 监狱里有100个房间，每个房间内有一囚犯。一天，监狱长说，你们狱房外有一电灯，你们在放风时可以控制这个电灯(熄或亮)。每天只能有一个人出来放风，并且防风是随机的。如果在有限时间内，你们中的某人能对我说：“我敢保证，现在每个人都已经至少放过一次风了。”我就放了你们!问囚犯们要采取什么策略才能被监狱长放掉?如果采用了这种策略，大致多久他们可以被释放?



第五组

　　1.某手机厂家由于设计失误，有可能造成电池寿命比原来设计的寿命短一半(不是冲放电时间)，解决方案就是免费更换电池或给50元购买该厂家新手机的折换券。请给所有已购买的用户写信告诉解决方案。

　　2.一高层领导在参观某博物馆时，向博物馆馆员小王要了一块明代的城砖作为纪念，按国家规定，任何人不得将博物馆收藏品变为私有。博物馆馆长需要如何写信给这位领导，将城砖取回。

　　3.营业员小姐由于工作失误，将2万元的笔记本电脑以1.2万元错卖给李先生，王小姐的经理怎么写信给李先生试图将钱要回来?

　　4.给你一款新研制的手机，如果你是测试组的组长，你会如何测试?

　　5.如何为函数int atoi(const char * pstr)编写测试向量?

　　第六组

　　1.链表和数组的区别在哪里?

　　2.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法?

　　3.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法?

　　4.请编写能直接实现char * strcpy(char * pstrDest,const char * pstrSource)函数功能的代码。

　　5.编写反转字符串的程序，要求优化速度、优化空间。

　　6.在链表里如何发现循环链接?

　　7.给出洗牌的一个算法，并将洗好的牌存储在一个整形数组里。

　　8.写一个函数，检查字符是否是整数，如果是，返回其整数值。(或者：怎样只用4行代码

　　9.给出一个函数来输出一个字符串的所有排列。

　　10.请编写实现void * malloc(int)内存分配函数功能一样的代码。

　　11.给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。

　　12.怎样编写一个程序，把一个有序整数数组放到二叉树中?

　　13.怎样从顶部开始逐层打印二叉树结点数据?请编程。

　　14.怎样把一个链表掉个顺序(也就是反序，注意链表的边界条件并考虑空链表)? --

　　15.请编写能直接实现int atoi(const char * pstr)函数功能的代码

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

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

      一般来说，对于那些处理时间比较长，需要马上响应并且做成异步后不会影响其它流程的做成异步。比如用户注册成功后发邮件给用户，这个可以在用户注册成功后马上返回，而不需要等到邮件发送成功才返回。异步有二种方式：内存异步和JMS异步。

     内存异步即把要处理的请求放到内存队列中，然后由多个线程去消费。这种方式性能比较高，但是会存在请求丢失和内存溢出的风险。比如服务器突然down机，那么队列中未处理完的请求就会丢失；如果请求处理时间太长，并且请求一直在增加，即生产者速度要大于消费者速度时，就存在内存溢出的风险。这种适合对数据丢失不敏感，并且生产者速度要小于消费者速度的场合。

    JMS异步即把要处理的请求先持久化到数据库，然后多个线程去消费。这种方式性能相对来说要慢一些，但是不会出现请求丢失和内存溢出的情况。这种适合不允许数据丢失，请求处理时间比较长的场合。

异步框架，使用元数据和AOP的方式，将内存异步和JMS异步统一起来。

package com.konceptusa.infinet.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 方法异步
 * @author Jwin
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target( {ElementType.METHOD })
@Documented
public @interface Async
{
	//异步队列名称,默认为类名.方法名
	String queueName() default "";
	//消费者线程数
	int threadCount() default 10;
	//队列报警值，仅对内存异步有效
	int warningQueueSize() default 100;
	//是否使用jms异步，默认为内存异步
	boolean jmsAsync() default false;
}

package com.konceptusa.infinet.imsupport.aop;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import javax.jms.ConnectionFactory;
import javax.jms.Queue;

import org.apache.activemq.command.ActiveMQQueue;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.listener.DefaultMessageListenerContainer;

import com.konceptusa.framework.asyn.AsynCallInfo;
import com.konceptusa.framework.asyn.jms.AsynExecuteMessageListener;
import com.konceptusa.framework.core.jmsservice.ObjectMessageSenderImpl;
import com.konceptusa.framework.core.jmsservice.SendMessageFailedException;
import com.konceptusa.infinet.annotation.Async;

/**
 * 异步AOP
 * @author Jwin
 *
 */
public class AsyncInterceptor implements DisposableBean
{
	private final static Log LOG = LogFactory.getLog(AsyncInterceptor.class);
	private Map<String, ThreadPoolExecutor> executorMap = new HashMap<String, ThreadPoolExecutor>();
	private Map<String, ObjectMessageSenderImpl> messageSenderMap = new HashMap<String, ObjectMessageSenderImpl>();
	private Map<String, DefaultMessageListenerContainer> listerContainerMap = new HashMap<String, DefaultMessageListenerContainer>();
	private ConnectionFactory connectionFactory;
	public Object async(final ProceedingJoinPoint pjp, Async async) throws Throwable
	{
		if(!async.jmsAsync())
		{
			memAsync(pjp, async);			
		}
		else
		{
			jmsAsync(pjp,async);
		}
		return null;
	}
	
	private void jmsAsync(ProceedingJoinPoint pjp, Async async)
	{
		ObjectMessageSenderImpl objectMessageSender = null;
		String queueName = getQueueName(pjp, async);
		synchronized (messageSenderMap)
		{
			objectMessageSender = messageSenderMap.get(queueName);
			if(objectMessageSender == null)
			{
				LOG.info("init jms queueName " + queueName + " thread count " + async.threadCount() );
				objectMessageSender = new ObjectMessageSenderImpl();
				Queue queue = new ActiveMQQueue(queueName);
				JmsTemplate jmsTemplate = new JmsTemplate();
				jmsTemplate.setConnectionFactory(connectionFactory);
				jmsTemplate.setDefaultDestination(queue);
				objectMessageSender.setJmsTemplate(jmsTemplate);
				messageSenderMap.put(queueName, objectMessageSender);
				DefaultMessageListenerContainer defaultMessageListenerContainer = new DefaultMessageListenerContainer();
				defaultMessageListenerContainer.setConcurrentConsumers(async.threadCount());
				defaultMessageListenerContainer.setConnectionFactory(connectionFactory);
				defaultMessageListenerContainer.setDestination(queue);
				defaultMessageListenerContainer.setCacheLevelName("CACHE_CONSUMER");
				defaultMessageListenerContainer.setMaxMessagesPerTask(20);
				AsynExecuteMessageListener messageListener = new AsynExecuteMessageListener();
				messageListener.setTarget(pjp.getTarget());
				defaultMessageListenerContainer.setMessageListener(messageListener);
				defaultMessageListenerContainer.afterPropertiesSet();
				listerContainerMap.put(queueName, defaultMessageListenerContainer);
			}			
		}
		AsynCallInfo asynCallInfo = new AsynCallInfo(pjp.getSignature().getName(),pjp.getArgs());
		objectMessageSender.asynSendMessage(asynCallInfo);
	}

	private String getQueueName(ProceedingJoinPoint pjp, Async async)
	{
		String queueName = async.queueName();
		//如果没有指定队列名，则以 类名.方法名 为队列名
		if(StringUtils.isBlank(queueName))
		{
			queueName = pjp.getTarget().getClass().getSimpleName() + "." + pjp.getSignature().getName();
		}
		return queueName;
	}
	private void memAsync(final ProceedingJoinPoint pjp, Async async)
	{
		ThreadPoolExecutor executor = null;
		final String queueName = getQueueName(pjp, async);
		synchronized (executorMap)
		{
			executor = executorMap.get(queueName);
			if(executor == null)
			{
				LOG.info("init mem queueName " + queueName + " thread count " + async.threadCount() + " warning queue size " + async.warningQueueSize());
				executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(async.threadCount());
				executorMap.put(queueName, executor);
			}
		}
		Thread thread = new Thread(){
			@Override
			public void run()
			{
				try
				{
					pjp.proceed();
				} catch (Throwable e)
				{
					LOG.error("async call fail", e);
				}
			}
		};
		executor.execute(thread);
		int size = executor.getQueue().size();
		if( size >= async.warningQueueSize())
		{
			LOG.warn("queueName " + queueName + " exceeds warning queue size " + async.warningQueueSize() + " current size " + size);
		}
	}
	public void destroy() throws Exception
	{
		for(String key : executorMap.keySet())
		{			
			LOG.info("destroy mem queue " + key);
			ThreadPoolExecutor executor = executorMap.get(key);
			executor.shutdown();
			executor.awaitTermination(2, TimeUnit.SECONDS);
		}
		for(String key : listerContainerMap.keySet())
		{			
			LOG.info("destroy jms queue " + key);
			DefaultMessageListenerContainer container = listerContainerMap.get(key);
			container.destroy();
		}
		executorMap.clear();
		listerContainerMap.clear();
	}
	public void setConnectionFactory(ConnectionFactory jmsConnectionFactory)
	{
		this.connectionFactory = jmsConnectionFactory;
	}
}

对需要异步的方法加入@Aysnc 即可实现异步

内存异步

	@Async
	public String memAsyncFind(Long userid)
	{
		System.out.println("mem asyncFind userid " + userid);
		return userid.toString();
	} 

JMS异步

	@Async(jmsAsync=true)
	public String jmsAsyncFind(Long userid)
	{
		System.out.println("jms asyncFind userid " + userid);
		return userid.toString();
	} 

AOP配置

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
   http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.0.xsd
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
   "
	default-autowire="byName">
 	<bean id="asyncInterceptor"
		class="com.konceptusa.infinet.imsupport.aop.AsyncInterceptor">
	</bean>
	
	<aop:config>
		<aop:pointcut id="asyncPointcut"
				expression="execution(* com.konceptusa.infinet.test.service..*.*(..)) and @annotation(async)" />
		<aop:aspect id="asyncAspect" ref="asyncInterceptor">
			<aop:around method="async" pointcut-ref="asyncPointcut" />
		</aop:aspect>
	</aop:config>	
	
</beans>

Activemq配置 

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:amq="http://activemq.org/config/1.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  http://activemq.org/config/1.0 http://activemq.apache.org/schema/activemq-core.xsd
  http://activemq.apache.org/camel/schema/spring http://activemq.apache.org/camel/schema/spring/camel-spring.xsd">

	<broker xmlns="http://activemq.org/config/1.0" brokerName="test"
		dataDirectory="${activemq.data}/data/test">
		<persistenceAdapter>
			<journaledJDBC journalLogFiles="10"
				dataDirectory="${activemq.data}/persistence"
				dataSource="#activemq-ds" createTablesOnStartup="true"
				useDatabaseLock="false" />
		</persistenceAdapter>

		<systemUsage>
			<systemUsage>
				<memoryUsage>
					<memoryUsage limit="100 mb"
						percentUsageMinDelta="20" />
				</memoryUsage>
				<storeUsage>
					<storeUsage limit="1 gb" />
				</storeUsage>
			</systemUsage>
		</systemUsage>
	</broker>

	<bean id="activemq-ds"
		class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${database.driverName.mq}" />
		<property name="jdbcUrl" value="${database.url.mq}" />
		<property name="user" value="${database.user.mq}" />
		<property name="password" value="${database.password.mq}" />
		<property name="initialPoolSize" value="${database.initialSize}" />
		<property name="minPoolSize" value="${database.initialSize}" />
		<property name="maxPoolSize" value="${database.maxActive}" />
		<property name="maxIdleTime" value="${database.maxIdleTime}" />
		<property name="acquireIncrement" value="${database.acquireIncrement}" />
		<property name="numHelperThreads" value="${database.numHelperThreads}" />
		<property name="automaticTestTable"
			value="${database.automaticTestTable}" />
		<property name="maxStatements" value="${database.maxStatements}" />
		<property name="maxStatementsPerConnection"
			value="${database.maxStatementsPerConnection}" />
		<property name="idleConnectionTestPeriod"
			value="${database.idleConnectionTestPeriod}" />
	</bean>

	<connectionFactory xmlns="http://activemq.org/config/1.0"
		id="jmsConnectionFactory" brokerURL="vm://test" />

	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory"
			ref="jmsConnectionFactory" />
	</bean>
</beans>
 

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

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

OracleDBConsole服务不能启动，访问“http://机器名：1158/em”不能进入EM界面，系统事件查看器里面记录“ Agent process exited abnormally during initialization. ”

网上解决Oracle服务不能启动最多的做法是修改host文件，即%ORACLE HOME%\db_1\NETWORK\ADMIN\listener.ora文件，修改其中的HOST=***，listener.ora文件中的HOST =***与 系统属性--》计算机名选项卡 中显示的“ 完整的计算机名称：dsideal-db ”保持一致，即将***更改为dsideal-db ，重启计算机，再尝试启动OralceDBConsole服务，发现服务能正常启动，故障排除。

listener.ora文件内容如下：

# listener.ora Network Configuration File: C:\oracle\product\10.2.0\db_1\network\admin\listener.ora
# Generated by Oracle configuration tools.

SID_LIST_LISTENER =
  (SID_LIST =
    (SID_DESC =
      (SID_NAME = PLSExtProc)
      (ORACLE_HOME = C:\oracle\product\10.2.0\db_1 )
      (PROGRAM = extproc)
    )
  )

LISTENER =
  (DESCRIPTION_LIST =
    (DESCRIPTION =
      (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1))
      (ADDRESS = (PROTOCOL = TCP)(HOST = dsideal-db )(PORT = 1521 ))#完整的计算机名称；端口号
    )
  )

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

x => -x

static class Program {
    static void Main( string[ ] args ) {
        Func<int, int> negateFunc = x => -x;
    }
}

internal static class Program
    [CompilerGenerated]
    private static int <Main>b__0( int x ) {
        return -x;
    }

    private static void Main( string[ ] args ) {
        Func<int, int> negateFunc = new Func<int, int>( <Main>b__0 );
    }
}

LambdaExpression
    UnaryExpression (body; negation)
        ParameterExpression ("x")
    ParameterExpression (parameter; "x")

using System;
using System.Linq.Expressions;

static class Program {
    static void Main( string[ ] args ) {
        Expression<Func<int, int>> negateExpr = x => -x;

        Func<int, int> negateFunc = negateExpr.Compile( );

        Console.WriteLine( negateFunc( 1 ) );
    }
}

using System;
using System.Linq.Expressions;

static class Program {
    static void Main( string[ ] args ) {
        ParameterExpression param = Expression.Parameter(typeof(int), "x");
        Expression<Func<int, int>> negateExpr =
            Expression.Lambda<Func<int, int>>(
                Expression.Negate( param ),
                new ParameterExpression[ ] { param } );

        Func<int, int> negateFunc = negateExpr.Compile( );

        Console.WriteLine( negateFunc( 1 ) );
    }
}

Add                : BinaryExpression
AddChecked         : BinaryExpression
And                : BinaryExpression
AndAlso            : BinaryExpression
ArrayIndex         : BinaryExpression
ArrayLength        : UnaryExpression
Call               : MethodCallExpression
Coalesce           : BinaryExpression
Condition          : ConditionalExpression
Constant           : ConstantExpression
Convert            : UnaryExpression
ConvertChecked     : UnaryExpression
Divide             : BinaryExpression
Equal              : BinaryExpression
ExclusiveOr        : BinaryExpression
Field              : MemberExpression
GreaterThan        : BinaryExpression
GreaterThanOrEqual : BinaryExpression
Invoke             : InvocationExpression
Lambda             : Expression<TDelegate>
LeftShift          : BinaryExpression
LessThan           : BinaryExpression
LessThanOrEqual    : BinaryExpression
ListInit           : ListInitExpression
MakeBinary         : BinaryExpression
MakeMemberAccess   : MemberExpression
MakeUnary          : UnaryExpression
MemberInit         : MemberInitExpression
Modulo             : BinaryExpression
Multiply           : BinaryExpression
MultiplyChecked    : BinaryExpression
Negate             : UnaryExpression
NegateChecked      : UnaryExpression
New                : NewExpression
NewArrayBounds     : NewArrayExpression
NewArrayInit       : NewArrayExpression
Not                : UnaryExpression
NotEqual           : BinaryExpression
Or                 : BinaryExpression
OrElse             : BinaryExpression
Parameter          : ParameterExpression
Power              : BinaryExpression
Property           : MemberExpression
PropertyOrField    : MemberExpression
Quote              : UnaryExpression
RightShift         : BinaryExpression
Subtract           : BinaryExpression
SubtractChecked    : BinaryExpression
TypeAs             : UnaryExpression
TypeIs             : TypeBinaryExpression
UnaryPlus          : UnaryExpression

System.Object
  System.Linq.Expressions.Expression
    System.Linq.Expressions.BinaryExpression
    System.Linq.Expressions.ConditionalExpression
    System.Linq.Expressions.ConstantExpression
    System.Linq.Expressions.InvocationExpression
    System.Linq.Expressions.LambdaExpression
      System.Linq.Expressions.Expression<TDelegate>
    System.Linq.Expressions.MemberExpression
    System.Linq.Expressions.MethodCallExpression
    System.Linq.Expressions.NewExpression
    System.Linq.Expressions.NewArrayExpression
    System.Linq.Expressions.MemberInitExpression
    System.Linq.Expressions.ListInitExpression
    System.Linq.Expressions.ParameterExpression
    System.Linq.Expressions.TypeBinaryExpression
    System.Linq.Expressions.UnaryExpression

digraph ExpressionTree {

node [fontsize=12, fontcolor=blue, font=Courier, shape=box]

 // node declarations
 lambda [label="Lambda Expression"]
 
 anoFuncSig [label="Anonymous Function\nSignature"]
 arrow [label="=>"]
 anoFuncBody [label="Anonymous Function\nBody"]
 
 impFuncSig [label="Implicit Anonymous\nFunction Signature"]
 expr [label="Expression"]
 
 impParam [label="Implicit Anonymous\nFunction Parameter"]
 uexpr1 [label="Unary Expression"]
 
 neg [label="-"]
 uexpr2 [label="Unary Expression"]
 
 id [label="Identifier:\nx"]
 
 simpName [label="Simple Name:\nx"]
 
 // relations

 lambda -> anoFuncSig
 lambda -> arrow
 lambda -> anoFuncBody
 
 {rank=same; anoFuncSig arrow anoFuncBody }
 
 anoFuncSig -> impFuncSig
 anoFuncBody -> expr
 
 {rank=same; impFuncSig expr }
 
 impFuncSig -> impParam
 expr -> uexpr1 [style=dashed]

 {rank=same; impParam uexpr1 }

 impParam -> id
 uexpr1 -> neg
 uexpr1 -> uexpr2
 
 {rank=same; id neg uexpr2 }
 
 uexpr2 -> simpName
}

digraph ExpressionTree {

node [fontsize=12, fontcolor=blue, font=Courier, shape=box]
edge [fontsize=10, fontcolor=purple]
 // node declarations
 lambda [label="Lambda Expression"]
 
 param [label="Parameter:\nx"]
 body [label="Unary Expression\n(Negation)"]
 
 param2 [label="Simple Name:\nx"]
 
 // relations

 lambda -> param [label="Signature"]
 lambda -> body [label="Body"]
 
 {rank=same; param body }
 
 body -> param2
 param -> param2 [label="(same node)", fontsize=8, style=dashed, dir=both]
}

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

    典型的J2EE项目，package的设计有成熟的套路可循，如分为domain、dao、service、action等等，职责已经分解的比较单一和 清晰，循环依赖这样的情况出现并不多。而在一般的java项目，如服务器程序、客户端程序和通用性框架的开发中，包的设计并没有套路可循，毕竟由于应用和 业务种类的不同，想得出通用性的设计套路是不大可能的。这时候遵循一些原则比之生搬硬套更为重要。在《敏捷软件开发》一书中对包的设计有深入的讨论，虽然 针对的是发布的二进制包而言，但是对于java package的设计同样有借鉴意义，如对包的内聚性、可重用性、稳定性的强调，对于依赖的探讨，这些都是比较笼统的概念，不是那么直观，需要在实际运用 中认真归纳和重构，向这些原则靠拢。
   我所想到一个比较直观的方法就是：对于一个包的描述，你是否能用一句简明扼要的话概括，也就是包的功能或者说介绍能否做到简明扼要，这是衡量一个包的设计 是否合理的最简单的方法。如果可以，显然这个包的内聚性很好，所有的类都服务于一个目的，从而带来了重用的可能(其实我对重用性并不感冒，除了工具类之外真正能重用的东西少之又少，内聚性才是需要关注的）；反之，这个包可能承担了太多的职责或者依 赖过多，仔细的重构和分离是需要做的。包的设计同样要遵循接口分离的原则，将接口与实现隔离在不同的包之中，客户程序就不会知道具体的实现，并且也保证了 实现对接口的单向依赖。当然，这时就需要引入工厂类、插件或者IOC容器来负责实例化实现类。

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

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

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

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

　　google chrome出世，亿人欢呼，惊叹赞美之词不绝于网。为了传承发扬阴阳和谐的传统，这里就不得不揭揭chrome的老底啦。

　　先看chrome这个名字，用过firefox扩展的人都知道是ff里的一个协议名。看到这个名字，就让我觉得chrome用的是ff的技术。

　　再看他的logo，有腾讯QQ的意思哟，这是最早提出的抄袭嫌疑。

　　用用chrome的地址栏，这个Omnibox实际就是Awesome Bar的翻版，用过firefox3，不会对这个Omnibox感到稀奇。

　　最委屈的是ie了，对别人那是抄袭，对ie就可说是抢劫了。你转到chrome的“高级选项”，点击“更改代理设置”，弹出来的是ie浏览器的“Internet属性”的对话框。这才知道google chrome的拿来能力之强。

　　渲染引擎是webkit，开源的，拿得理直气壮。

　　再来看看google chrome还剩下些什么？界面设计，赞一下，很不错的。v8引擎也很牛。gears也很强。再也没什么说的了。

　　可见，软件开发、搞创新重要的是敢于拿来，善于拿来 。

　　有报道说，这google chrome是十年磨一剑，我是不信的，擦鞋的永远不会少。我看到的是：google chrome东拼西凑，摩登上场。

　　注：本文纯属游戏兼炒作，google fans不要太认真了，正经点的见chrome 冲着谁。

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

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

package test.Thread;

import java.util.Date;

public class testSleep {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread1 t1 = new Thread1();
		t1.start();
		for (int i = 1; i < 5; i++) {
			System.out.println("main thread times :" + i);
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				// e.printStackTrace();
				System.out.println("main thread is interrupted");
			}
		}
		t1.interrupt();
	}
}

class Thread1 extends Thread {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			System.out.println("this is Thread1  " + new Date());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				// e.printStackTrace();
				System.out.println("Thread1 is Interrupted");
				return;
			}
		}
	}

}

 The result:

main thread times :1
this is Thread1  Fri Sep 05 20:38:25 CST 2008
this is Thread1  Fri Sep 05 20:38:27 CST 2008
this is Thread1  Fri Sep 05 20:38:28 CST 2008
this is Thread1  Fri Sep 05 20:38:29 CST 2008
this is Thread1  Fri Sep 05 20:38:30 CST 2008
main thread times :2
this is Thread1  Fri Sep 05 20:38:31 CST 2008
this is Thread1  Fri Sep 05 20:38:32 CST 2008
this is Thread1  Fri Sep 05 20:38:33 CST 2008
this is Thread1  Fri Sep 05 20:38:34 CST 2008
this is Thread1  Fri Sep 05 20:38:35 CST 2008
main thread times :3
this is Thread1  Fri Sep 05 20:38:36 CST 2008
this is Thread1  Fri Sep 05 20:38:37 CST 2008
this is Thread1  Fri Sep 05 20:38:38 CST 2008
this is Thread1  Fri Sep 05 20:38:39 CST 2008
this is Thread1  Fri Sep 05 20:38:40 CST 2008
main thread times :4
this is Thread1  Fri Sep 05 20:38:41 CST 2008
this is Thread1  Fri Sep 05 20:38:42 CST 2008
this is Thread1  Fri Sep 05 20:38:43 CST 2008
this is Thread1  Fri Sep 05 20:38:44 CST 2008
this is Thread1  Fri Sep 05 20:38:45 CST 2008
Thread1 is Interrupted

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

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

Connection conn = getConnection();
		PreparedStatement ps = null;
		try {
			conn.setAutoCommit(false);
			ps = conn.prepareStatement("insert into t_user(username, password) values(?,?)");
			Random r = new Random();
			for(int i = 0; i < 1000; i++){
				ps.setString(1, String.valueOf(r.nextInt(Integer.MAX_VALUE)));
				ps.setString(2, String.valueOf(r.nextInt()));
				ps.executeUpdate();
				conn.commit(); //每次都提交
			}
			
		} catch (SQLException e) {
			conn.rollback();
			throw e;
		}finally{
			ps.close();
			conn.close();
		}

Connection conn = getConnection();
		PreparedStatement ps = null;
		try {
			conn.setAutoCommit(false);
			ps = conn.prepareStatement("insert into t_user(username, password) values(?,?)");
			Random r = new Random();
			for(int i = 0; i < 1000; i++){
				ps.setString(1, String.valueOf(r.nextInt(Integer.MAX_VALUE)));
				ps.setString(2, String.valueOf(r.nextInt()));
				ps.executeUpdate();
				
			}
			conn.commit(); //只提交一次
		} catch (SQLException e) {
			conn.rollback();
			throw e;
		}finally{
			ps.close();
			conn.close();
		}

Connection conn = getConnection();
		PreparedStatement ps = null;
		try {
			conn.setAutoCommit(false);
			ps = conn.prepareStatement("insert into t_user(username, password) values(?,?)");
			Random r = new Random();
			for(int i = 0; i < 1000; i++){
				ps.setString(1, String.valueOf(r.nextInt(Integer.MAX_VALUE)));
				ps.setString(2, String.valueOf(r.nextInt()));
				ps.addBatch();//加入批处理
				//ps.executeUpdate();不能与addBatch（）同时用
				
			}
			int[] results = ps.executeBatch();//执行批处理
			conn.commit();
		} catch (SQLException e) {
			conn.rollback();
			throw e;
		}finally{
			ps.close();
			conn.close();
		}

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

读书这么多年,近年才开始慢慢体会到阅读技巧的重要性.也许人越是到老越珍惜时间?!我还没那么老吧.时间对每个人都是公平的,不公平的是每个人对待时间的态度.拥有一些阅读技巧也许会改变你对时间的态度.

l  选择性阅读.首先当然是要选择正确的书籍,通常一些好书中总会提到其他的一些好书,而且是呈倍数关系.这是一种简单的办法.Amazon是另一种选择,优秀的书籍总是不乏赞美的Review,尤其那些重量级人物的点评.其次是选择正确的章节阅读.一本好书,也许会有不适合阅读的章节,果断地舍弃.再经典的书籍也不一定全全部内容都值得读的,可能其中讲的部分内容你已经非常熟悉,或者其它的好书已经就此内容展开更深入的探讨.反之亦然,一本烂书也许有你需要的东西,阅读那部分有价值的章节就行了.不过,这一点慎重,尤其是现在烂书泛滥的年代.

l  关注目录.目录会告诉你作者写作本书的基本思路和线条.包括了广度和深度,同时也更容易从更高层面理解作者的意图.

l  分类阅读.也许你的阅读涉猎范围很广,分类阅读就非常重要.将阅读范围分成三到五类,对每一类有一个简单明确的定义,内容所占的比重,时间所占的比重,适合在什么场合阅读等.接下来就是把这些原则应用起来.

l  稳定的阅读量.每周都保持稳定的阅读量,使阅读成为你的终生伴侣.现在的社会,信息量太大,获取的手段太多,但是书籍的阅读是无可替代的.太多的人浮于事,造成整个行业的浮躁.书中自有黄金屋,书中自有颜如玉.

l  适度的笔记.经典的,或精彩的,或有趣的,或深刻的语句,把它们记录下来,然后一有时间就反复回味,你会受益无穷.难以理解的,或者有待商榷的也记下来,寻找适当的时间,方式,与适当的人讨论.不要试图记下整本书的标题,那没有任何意义.

l  有效利用书签.书签是个好东西,可以让你专注于阅读本身,而不是每次放下书的时候都要记住下次阅读正确开始的地方,拿起书的时候都要想想上次读到哪里了.这实在是件辛苦事,书签能很好地解决这个问题.

l  同时阅读多本书.同时读几本同一主题的书会让你更容易理解任何一本书的内容.另一方面,如果专业书籍的内容难度太大,同时阅读一些相对容易理解的书籍会让你的阅读量和阅读效率保持平衡.还有另一层原因,在不同的环境里阅读不同的主题可能会最大限度地提高阅读效率.在床上,电脑前,沙发上,旅行中,工作的间隙等等,都可以选择合适的主题来阅读.

如果你有什么好的阅读技巧,不妨与大家一起分享一下.

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

业务背景

以财政业务数据为例，财政业务数据具有多样化的纬度和度量，以便财政人员对资金的管理和监察；

纬度：功能科目－树状、经济科目－树状、机构－树状、经费类型－树状、资金来源－树状、主管岗位－普通序列、拨款时间－日期型 等；

度量：指标金额、下达金额、已拨金额、使用金额、记账金额 等； 组合树型纬度从上面的纬度来看，大部分是树状的纬度，且财政要求的分析纬度通常都是多个纬度的组合，一般的分析工具要解决这个问题通常会在数据抽取阶段组合出用户所需的纬度来供用户使用，但这样带来的主要问题有：无法适应用户日渐变化的需求 和 难于维护日渐增加的组合纬度。童式魔方通过让用户自由设计纬度并在分析时生成组合纬度很好的解决了上面的问题，那下面看看童式魔方是怎么组合树状纬度。设计界面：


图4.1

从上图可见，设计界面的右方是放着可提供给用户设计的纬度和度量，这些信息是由维护人员在cube定义阶段设置好的；界面的左方是用户设计后的结果，对于二维的数据分析提供了行设计纬度和列设计纬度。那么下来我们表4.1为例子来做一个分析报表；


主管岗位
经费类型

资金来源

机构

功能科目

经济科目


表4.1

表4.1的列表头是由 机构 挂 功能科目 挂 经济科目 组合而成；行表头是由主管岗位 挂 资金来源 后，并 经费类型 组合而成。行列纬度可分别设计，互不干系；先设计列纬度，点击“列设计纬度”标签，再点击新增可见纬度设置界面，如下图：


图4.2

在纬度设置界面有四种纬度可使用，这里只需使用普通纬度，选择一个机构纬度，并输入这个树状纬度的开始级别和结束级别，点击确定后即可得到一个设计纬度；由于是在机构下挂功能科目，所以下一个设计纬度需设置成机构的子节点，先点击机构节点在点击新增按钮，即可再次打开纬度设置界面，下面的操作同上，那么最后得到的结果如下图：



图4.3

对于行设计纬度是由 主管岗位 挂 资金来源 后，并 经费类型 组合而成，与列有所不同，在第一级有两个同级的节点，但对于设计纬度必须有一个根节点，所以这里需手工加一个根节点，再把主管岗位和经费类型并在这个根节点之下。得到的结果如下图：



图4.4

在行列纬度都设计好后，即可点击分析按钮来查看最终格式和分析结果，行列表头均可展开后收回，并支持定向筛选；

列表头的结果如下图：



图4.5

行表头结果如下图：



图4.6

总体结果如下图：



图4.7

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

   这些天遇到一个问题, 也就引出了本博客里的标题. 

    问题是这样的.  一个Java程序要启动两个java进程A和B,第一个进程A是按正常的启动方式进行的,这里边没什么问题;第二个进程B是在进程A里通过调用Runtime.getRuntime().exec(mCmd, mEnv, mDir)的形式启动的. 问题就出在传的参数mCmd上了, 这个mCmd的值是从一个xml文件里读来的, 这个xml的内容大致如下:

<app name="WP" cmd="C:\Program Files\Java\jdk1.6.0_07\bin\java -server -XX:+UseConcMarkSweepGC -...." />

这样执行exec方法时,JVM就报无法执行"C:\Program Files\Java\jdk1.6.0_07\bin\java"所指向的命令了, 原因很简单Windows没法找到没引号的"Program Files"文件夹,它会在空格处断开的.

这个怎么办? 

我试着给Program Files加了单引号,还是不行,windows仍然不认.

想给Program Files文件夹改名,可windows又不让!

..............

无奈了,只能在C盘根目录下另又装了一个JDK.

难道真的不要把JDK装到program files下吗?

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

前段时间写的滚动条样式的css代码段，备忘。。。。

-----------------------

/* 滚动条样式 */
.light-scroll {
	scrollbar-face-color : #fafafa;
	scrollbar-3dlight-color : #c0c0c0;
	scrollbar-base-color : #fff;
	scrollbar-arrow-color : #c0c0c0;
	scrollbar-shadow-color : #c0c0c0;
	scrollbar-darkshadow-color :#fff;
}

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

不是迅雷与google已经携手了,并且前段时间也发现用迅雷的gougou搜索电影,使用的是google的引擎,搜索的结果都是googe提供的.

但现在发现用gougou搜索电影,使用的引擎竟然是baidu的,搜索的结果也是baidu提供的,并且gougou的广告被firefox报"位于 un.so.gougou.com 的站点已经被报告为攻击网站"的错误,查看"为何组织此站"的说明页面是google提供的.

难道迅雷和google发生了什么问题吗?

不明白...

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

返回JS对象的类型

function objectType(obj)
{

  var constructor = (String)(obj.constructor);
  var tokens = constructor.split(" ");

  for(var i=0; i<tokens.length; i++)
  {
    if(tokens[i].indexOf("function") != -1)
    {
      var end = tokens[i+1].indexOf("(");

      if(end == -1)
        return(tokens[i+1]);
      else
        return(tokens[i+1].substring(0, end));
    }
  }

}// END objectType

alert(objectType( 'I am a string'));     //string
alert(objectType(true));                 //boolean
alert(objectType(100));                  //number

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

String url =  "http://localhost:8080/dealer/list";
String classes = new HttpUtil(ServletActionContext.getRequest().post(url));

InvList action = new InvListAction();
assertEquals(ActionSupport.SUCCESS,action.execute());

<listen>
   <listened-class>org.springframework.web.context.ContextLoaderListened</listened-class>
</listener>

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

请看代码：

/**
 * IP进制转换工具
 * 
 * @author YM
 */
public class IpConvert {

	/**
	 * 将IP进制(如:192.168.1.1)转换成十进制(如:3232235777)
	 * 
	 * @param ip
	 * @return
	 */
	public static long getIp10(String ip) {
		long ip10 = 0;
		String[] ss = ip.trim().split("\\.");
		for (int i = 0; i < 4; i++) {
			ip10 += Math.pow(256, 3 - i) * Integer.parseInt(ss[i]);
		}

		return ip10;
	}

	/**
	 * 将十进制(如:3232235777)IP转换成IP进制(如:192.168.1.1)
	 * 
	 * @param ip10
	 * @return
	 */
	public static String getIp(long ip10) {
		String ip = "";
		long temp = 0;

		for (int i = 3; i >= 0; i--) {
			temp = ip10 / (long) Math.pow(256, i) % 256;
			if (i == 3) {
				ip = ip + temp;
			} else {
				ip = ip + "." + temp;
			}
		}

		return ip;
	}

	public static void main(String[] args) {
		System.out.println(getIp10("192.168.1.1"));
		System.out.println(getIp(getIp10("192.168.1.1")));
	}
}

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