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

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

a = 8
if a > 0
  puts "a > 0"
elsif a < 0
  puts "a < 0"
else
  puts "a == 0"
end

a = 0
str = if a > 0 then "a > 0"
elsif a < 0 then "a < 0"
else "a == 0"
end
puts str


a = 0
puts "a == 0  g" if a == 0
puts "a == 0  h" unless a != 0


a = 1
case a
  when -1
    puts "a == -1"
  when 0
    puts "a == 0"
  when 1
    puts "a == 1"
  else
    puts "unknown"
end

a = "a"
case a
  when "a"
    puts "a == -1"
  when "b"
    puts "a == 0"
  when "c"
    puts "a == 1"
  else
    puts "unknown"
end


a = 3
str = case a
  when -10..-1 then "-10 < a < 0"
  when 0 then "a == 0"
  when 1..10 then "1 < a < 10"
  else "unknown"
end
puts str

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

class People
  def initialize(name, age)
    @name = name
    @age = age
  end
  
  def to_s
    "name = #{@name}, age = #{@age}"
  end
end

lily = People.new("Lily", 18)
puts lily

class Teacher < People
  def initialize(name, age, gender)
    super(name, age)
    @gender = gender
  end
  
  def to_s
    super + ", gender = #{@gender}"
  end
end

lisa = Teacher.new("Lisa", 28, "female")
puts lisa

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

import java.io.Serializable;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;

import com.wideplay.warp.persist.Transactional;

/**
 * <p>
 * Entity interface implemented by all persistent classes.
 */
public interface IEntity<T, PK extends Serializable>
{
	public void setEmp(com.google.inject.Provider<EntityManager> emp);

	public String getId();

	public Date getCreatedAt();

	public void setCreatedAt(Date createAt);

	public Date getChangedAt();

	public void setChangedAt(Date changedAt);

	public List<String> validate();

	public T find(PK id);

	public List<T> findAll();

	@Transactional
	public T save(T object);

	@Transactional
	public void remove(PK id);

}

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.EntityManager;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

import com.google.inject.Inject;
import com.wideplay.warp.persist.Transactional;

/**
 * 
 * <p>
 *  This class provides the basic properties for entities (id, createdAt, and
 *  changedAt) as well as default save, remove, find, and findAll methods.
 * 
 * <p>
 *  Custom finders and custom save / remove logic can be implemented in child
 *  entity classes as necessary.
 */
@MappedSuperclass
public abstract class AbsEntity<T, PK extends Serializable> implements IEntity<T, PK>
{

	@Transient
	@Inject
	protected com.google.inject.Provider<EntityManager> emp;

	@Transient
	private Class<T> persistentClass;
	
	@Id
	@Column(length = 36, nullable = false)
	//@GeneratedValue(strategy = GenerationType.AUTO)
	@GeneratedValue(generator = "hibernate-uuid.hex")
	@org.hibernate.annotations.GenericGenerator(name = "hibernate-uuid.hex", strategy = "uuid.hex")
	protected String id;
	

	@Temporal(TemporalType.TIMESTAMP)
	@Column(name = "created_at", nullable = false)
	protected Date createdAt = new Date();

	@Temporal(TemporalType.TIMESTAMP)
	@Column(name = "changed_at", nullable = false)
	protected Date changedAt = new Date();

	/**
	 * Constructor for dependency injection.
	 * 
	 * @param persistentClass
	 *            the class type you'd like to persist.
	 */
	public AbsEntity(Class<T> persistentClass)
	{
		this.persistentClass = persistentClass;
	}

	public void setEmp(com.google.inject.Provider<EntityManager> emp) {
		this.emp = emp;
	}

	public String getId() 
	{
		return id;
	}

	public Date getCreatedAt()
	{
		return createdAt;
	}

	public void setCreatedAt(Date createdAt)
	{
		this.createdAt = createdAt;
	}

	public Date getChangedAt() 
	{
		return changedAt;
	}

	public void setChangedAt(Date changedAt) 
	{
		this.changedAt = changedAt;
	}

	public List<String> validate() 
	{
		// create our list for errors
		List<String> errors = new ArrayList<String>();

		// Validate the model fields.
		if (this.id == null || this.id.length() == 0) 
		{
			errors.add("Identifier is null or empty.");
		}
		if (this.createdAt == null)
		{
			errors.add("Created at date is null.");
		}
		// if no errors occured we'll return null.
		if (errors.size() == 0)
		{
			errors = null;
		}

		// return errors that occured
		return errors;
	}

	public T find(PK id)
	{
		return emp.get().find(this.persistentClass, id);
	}

	@SuppressWarnings("unchecked")
	public List<T> findAll()
	{
		return emp.get().createQuery(
				"FROM " + this.persistentClass.getSimpleName()).getResultList();
	}


	@Transactional
	public T save(T object) 
	{
		return emp.get().merge(object);
	}


	@Transactional
	public void remove(PK id) 
	{
		EntityManager em = emp.get();
		em.remove(em.find(this.persistentClass, id));
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean equals(Object o)
	{
		if (this == o)
			return true;
		if (o == null || !(o instanceof IEntity))
		{
			return false;
		}
		IEntity other = (IEntity) o;

		// if the id is missing, return false
		if (id == null)
		{
			return false;
		}

		// equivalence by id
		return id.equals(other.getId());
	}

	@Override
	public int hashCode() 
	{
		if (id != null)
		{
			return id.hashCode();
		}
		else 
		{
			return super.hashCode();
		}
	}

	@Override
	public String toString() 
	{
		// TODO Auto-generated method stub
		return "id: " + id + ", createdAt: " + createdAt.toString()
				+ ", changedAt: " + changedAt.toString();
	}
}

import java.util.List;

import javax.persistence.Column;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import com.google.inject.name.Named;
import com.model.Role;
import com.wideplay.warp.persist.dao.Finder;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "USER_TYPE", discriminatorType = DiscriminatorType.STRING)
@Table(name = "USER")
public abstract class BaseUser extends AbsEntity<BaseUser, String> implements IEntity<BaseUser, String> 
{
	 @Column(name = "EMAIL")
	 private String email;

	 @Column(name = "PASSWORD", length = 50)
	 private String password;

	 @Column(name = "FULL_NAME", length = 50)
	 private String fullName;

	 @Column(name = "ACTIVE")
	 private boolean active = true;
	  
	 @Column(name = "LOGIN_RANDOM_PASSWORD") 
	 private String loginRandomPassword;
	    
    @ManyToOne(targetEntity = Role.class)
    @JoinColumn(name = "FK_ROLE_ID")
    private Role role;
    
	/**
	 * Necessary to use the generic operation methods in AbsEntity.
	 */
	@SuppressWarnings("unchecked")
	public BaseUser()
	{
		super(BaseUser.class);
	}
	
	/** ********************************************** */
	/** Properties *********************************** */
	/** ********************************************** */

	public String getEmail() 
	{
		return email;
	}

	public void setEmail(String email) 
	{
		this.email = email;
	}

	public String getPassword()
	{
		return password;
	}

	public void setPassword(String password) 
	{
		this.password = password;
	}

	public String getFullName()
	{
		return fullName;
	}

	public void setFullName(String fullName) 
	{
		this.fullName = fullName;
	}

	public boolean isActive()
	{
		return active;
	}

	public void setActive(boolean active) 
	{
		this.active = active;
	}

	public String getLoginRandomPassword() 
	{
		return loginRandomPassword;
	}

	public void setLoginRandomPassword(String loginRandomPassword)
	{
		this.loginRandomPassword = loginRandomPassword;
	}

	public Role getRole() 
	{
		return role;
	}

	public void setRole(Role role)
	{
		this.role = role;
	}
		
	/** ********************************************** */
	/** Operators ************************************ */
	/** ********************************************** */

	// Override save, remove, find, and findAll methods as necessary.
	//
	/** ********************************************** */
	/** Custom Finders ******************************* */
	/** ********************************************** */
	@Finder(query = "FROM Role WHERE id = :roleId")
	public Role findRoleById(@Named("roleId")Long roleId) 
	{
		return null; // never called
	}
	
	@Finder(query = "From Role order by roleName")
	public List<Role> findAllRoles() 
	{
		return null;
	}


}

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

import com.model.abs.BaseUser;

@Entity()
@DiscriminatorValue("C_USER")
public class CustomUser extends BaseUser 
{
	/** ********************************************** */
	/** Custom Finders ******************************* */
	/** ********************************************** */
}

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.google.inject.Inject;
import com.wideplay.warp.persist.PersistenceService;

public class InitializerJpa 
{
	private final Log log = LogFactory.getLog(getClass());

	@SuppressWarnings("unused")
	private final PersistenceService service;

	/**
	 * Starters the JPA persistence service.
	 * 
	 * @param service
	 *            the persistence service to start.
	 */
	@Inject
	InitializerJpa(PersistenceService service) 
	{
		this.service = service;

		service.start();
		log.info("JPA Persistence Service started...");
	}
}

import com.app.InitializerJpa;
import com.google.inject.AbstractModule;
import com.wideplay.warp.jpa.JpaUnit;


public class MainModule extends AbstractModule 
{
	protected void configure() 
	{
		bindConstant().annotatedWith(JpaUnit.class).to("Persist_Unit");

		// to automatically start up the persistence service
		bind(InitializerJpa.class).asEagerSingleton();
	}
}

<?xml version="1.0" encoding="UTF-8" ?> 
<persistence xmlns="http://java.sun.com/xml/ns/persistence"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
	http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">

	<!-- A JPA Persistence Unit -->
	<persistence-unit name="Persist_Unit" transaction-type="RESOURCE_LOCAL">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
 
		<!-- JPA entities can be registered here, but it's not necessary -->

		<properties>
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost/ex_ddd"/>
            <property name="hibernate.connection.username" value="root"/>
            <property name="hibernate.connection.password" value="123"/>
            <property name="hibernate.connection.pool_size" value="1"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
			<property name="hibernate.hbm2ddl.auto" value="create"/> 
        </properties>
        
	</persistence-unit>

</persistence>

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

class ForLoop
  
  def callFor 
    for i in 1..3
      print "index = #{i}\n"
    end
  end
  
  def callWhile
    a = 1
    a *= 2 while a < 10
    puts a
    
    a -= 2 until a < 0
    puts a
  end
  
  def callWhile2
    a = 1
    a += 1  while a < 5
    puts a
  #  print "index = #{a}\n"
  end

  def time
    3.times do
      print "Ho! "
    end
  end
  
  def upto
     1.upto(3) do |x|
      puts x
    end
  end
  
  def step
    0.step(10, 2) do |x|
      puts x
    end
  end

  def each 
    [1, 2, 3, 4, 5].each do |x|
      puts x
    end
  end
  
  def callFor2  # seems similar as each
    for n in [5, 4, 3, 2, 1]
      puts n
    end
  end
  
  def callLoop
     i = 0
     loop do
      i += 1
      puts i
      next if not i > 3
      puts "i > 3"
      redo if i >= 6 and i <= 9
      puts "i < 6 or i > 9"
      break if i == 10 
    end
  end
  
end

instance = ForLoop.new
instance.callFor
print "----------\n"
instance.callWhile2
print "----------\n"
instance.time
print "\n----------\n"
instance.upto
print "----------\n"
instance.step
print "----------\n"
instance.each
print "----------\n"
instance.callFor2
print "----------\n"
instance.callLoop

# output
#index = 1
#index = 2
#index = 3
#----------
#5
#----------
#Ho! Ho! Ho! 
#----------
#1
#2
#3
#----------
#0
#2
#4
#6
#8
#10
#----------
#1
#2
#3
#4
#5
#----------
#5
#4
#3
#2
#1
#----------
#1
#2
#3
#4
#i > 3
#i < 6 or i > 9
#5
#i > 3
#i < 6 or i > 9
#6
#i > 3
#7
#i > 3
#8
#i > 3
#9
#i > 3
#10
#i > 3
#i < 6 or i > 9

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

print "1: "
puts "name".object_id
print "1: "
puts "name".object_id
print "1: "
puts "name".object_id

print "2: "
puts :name.object_id
print "2: "
puts :name.object_id
print "2: "
puts :name.object_id

print "3: "
puts 123456.object_id
print "3: "
puts 123456.object_id
print "3: "
puts 123456.object_id

# output
#1: 21719110
#1: 21719080
#1: 21719050 
#  "name".object --> 对象的Id
#2: 34258
#2: 34258
#2: 34258
#  :name.object_id  -->  对象的值的Id
#3: 246913
#3: 246913
#3: 246913

class A
  attr_accessor :name
end

a = A.new
print "a.name = "
puts a.name

a.name = "Lily"
print "a.name = "
puts a.name

class B
  def name
    @name
  end
  
  def name=(name)
    @name = name
  end
end

b = B.new
print "b.name = "
puts b.name

b.name = "Lily"
print "b.name = "
puts b.name

# output
#a.name = nil
#a.name = Lily
#b.name = nil
#b.name = Lily

class Symbol
  def to_proc
    proc {|obj, *args| obj.send(self, *args)}
  end
end

words = %w(abc bcd cde def efg)
list = words.map(&:capitalize)
print "1: "
puts list.inspect

list2 = words.map {|w| w.send(:capitalize)}
print "2: "
puts list2.inspect

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

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

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

  //  现有代码，好多取当前时间直接  new Date() 只是取当前Server的时间
     new Date();

       //  使用指定时区 PST(太平洋时区) 和默认语言环境获得一个日历。
	 Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("PST"));
       //    使用默认时区和语言环境获得一个日历。
        Calendar calendar2 = Calendar.getInstance();
		
		System.out.println(calendar.getTime() + " " + calendar.getTimeInMillis());
		System.out.println(calendar2.getTime() + " " + calendar2.getTimeInMillis());

    private static Map<String, String> US_TimeZoneMap = null;

    /**
     *  Get right timezone date by calendar
     * 
     * @param stateCode  state name
     * @return Date timezoneDate
     */
    @SuppressWarnings("deprecation")
    public static Date getTimezoneDate(String stateCode)
    {    
        Calendar calendar = Calendar.getInstance(getTimezone(stateCode));
        Date date = new Date(calendar.get(Calendar.YEAR),
                              calendar.get(Calendar.MONTH),
                               calendar.get(Calendar.DAY_OF_MONTH));
        return date;
    }
   
    /**
     *  Get timezone type by state name
     * 
     * @param stateCode
     * @return TimeZone
     */
    public static TimeZone getTimezone(String stateCode)
    {
        return TimeZone.getTimeZone(initializeTimezoneMap().get(stateCode));
    }
   
    /**
     *  Initialize a map store timezone info
     * 
     * @return Map  timezone Map
     */
    public static Map<String, String> initializeTimezoneMap()
    {
        if (US_TimeZoneMap == null)
        {
            US_TimeZoneMap = new HashMap<String, String>();
            US_TimeZoneMap.put("CA", "PST");
            US_TimeZoneMap.put("CO", "MST");
            // ...
            US_TimeZoneMap.put("IL", "CST");
            US_TimeZoneMap.put("GA", "EST");
        }

        return US_TimeZoneMap;
    }

 	    // get current moment in default time zone
	    DateTime dt = new DateTime();
	    // translate to London local time
	    DateTime dt2 = dt.withZone(DateTimeZone.forID("America/Los_Angeles"));

// This is similar in concept to the default time zone of the java.util.TimeZone class.
DateTimeZone defaultZone = DateTimeZone.getDefault();
DateTimeZone.setDefault(myZone);

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

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

ITPUB上的， 总结的很全。

linux目录架构

一些常用的基本命令:

压缩命令：

vi一般用法

认识SHELL

帐号管理

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

Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
所有实现Collection接口的类都必须提供两个标准的 构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这 个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}
由Collection接口派生的两个接口是List和Set。

List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。
实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并 没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
Vector非常类似 ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但 是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时 调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

Stack 类
Stack继承自 Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方 法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口
请注意，Map没有继承 Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供 3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相 同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如 果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希 表的操作。
如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
Hashtable是同步的。

HashMap类
HashMap和 Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类
WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

（参考：Sun JDK1.4.1 API DOC）

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

Design Patterns

A design pattern is a recurring solution to a standard problem. The most well-known design patterns (in total 23) were documented by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides also called The Gang of Four (GOF) in the book Design Patterns -- Elements of Reusable Software (1995). There a hunderds of design patterns described in the literature. This tutorial only describes the design patterns documented by the GOF. The GOF has divided the design patterns into three types. Type name Description Creational patterns Deal with initializing and configuring classes and objects Abstract Factory Builder Factory Factory Method Prototype Factory Singleton Structural patterns Deal with decoupling interface and implementation of classes and objects Adapter Bridge Composite Decorator Facade Flyweight Proxy Behavioral patterns Deal with dynamic interactions among societies of classes and objects Chain of Responsibility Command Interpreter Iterator Mediator Memento Observer State Strategy Template Visitor Creational patterns. Name Description Factory Method Method in a derived class creates associates Abstract Factory Factory for building related objects Builder Factory for building complex objects incrementally Prototype Factory for cloning new instances from a prototype Singleton Factory for a singular (sole) instance

knowledge of pattern
#  creational
1. factory method: lazy initialize specific instance

2. abstract factory: supply a interface for the system

3. builder: builder or create a object apart from its descrition

4. prototype: create new object which type base on the type of specific instance

5. singleton: make sure one class only have one instance, supply for every visitor
 allways used with factory pattern together.

# structural
6. adapter: give a interface of class for get another required interface, implement compatibility

7. bridge: extranet abstract class from implement class, make it suit for their single change
public abtract class AbstractRoot
{
    operation();
}

8. composite: make a object as tree structure, make "part-all" clearly. 

组合模式:  ----继承

9. decorator: change extend(8) to delegate

装饰器模式: --- 委托



10. facade: supply a interface for visiting the sub-system

11. flyweight: it seem logic like cache.
     if (flyweight[key] exists)
     {
        return existing flyweight;
     }
     else
     {
        create new flyweight;
        add it to pool of flyweights;
        return the new flyweight;
     }
     
12. proxy:   a, remote proxy       visit
             b, virtual proxy      performance
             c, protection proxy   control
             d, smart reference    get reference number
             
# behavioral
13. interpreter 解释模式

14. Template Method 模版模式 
AIM: 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
ENV: 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现.
TODO: 比较组合模式
 
15. Chain of Responsibility
AIM: 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止.
有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
可处理一个请求的对象集合应被动态指定。

16. Command 命令模式
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。


17. Iterator 迭代模式

18. Mediator 仲裁模式

19. Memento  记忆模式

20. Observer 观察者模式

21. State 状态模式
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

22. Strategy 策略模式
TODO: 比较State
定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

23. Vistor 访问模式

 

  <head first ooad>

感觉OO原则其实我们平时编码的最基本原则, 设计模式可以就是遵循的OO原则来运用的.
OO principle
#1 the open-closed principle(ocp)
classed shoulde be open for extension, and closed for modification.

#2 the don't repeat yourself principle (DRY)
have each piece of imformation and behavior in your system in a single,sensible place.

#3 the single responsibility principle(SRP)
Single responsibility priciple correctly when each of your objects has only one reason to change

#4 the Liskov substitution priinciple(LSP)
感觉LSP就是用委托....

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

One day an employee sends a letter to his boss asking for an increase in his salary!
Dear Bo$$
In thi$ life, we all need $ome thing mo$t de$perately. I think you $hould be under$tanding of the need$ of u$ worker$ who have given $o much $upport including $weat and $ervice to your company.
I am$ure you will gue$$ what I mean and re$pond $oon.
Your$ $incerely,
Norman $oh
一名公司雇员某天给老板写信请求加薪。
亲爱的老板：
人的一生我们都迫切一种东西。大家一直为公司挥汗付出，我想你应该理解我们的需要。
我相信你会猜到我的意思并能及时回复。
诚挚的
诺曼.苏
The next day, the employee received this letter of reply:
Dear NOrman,
I kNOw you have been working very hard. NOwadays, NOthing much has changed. You must have NOticed that our company is NOt doing NOticeably well as yet.
NOw the newspaper are saying the world’s leading ecoNOmists are NOt sure if the United States may go into aNOther recession. After the NOvember presidential elections things may turn bad.
I have NOthing more to add NOw. you kNOw what I mean.

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