姚姐夫

2012年3月29日星期四

获取两个数组的差集(A|B)U(B|A)

<T> T[] different(T[] newArray, T[] oldArray) {
if (newArray == null) {
return oldArray;
}
if (oldArray == null) {
return newArray;
}
Set<T> newSet = new HashSet<T>(Arrays.asList(newArray));
Set<T> temp = new HashSet<T>(Arrays.asList(newArray));
Set<T> oldSet = new HashSet<T>(Arrays.asList(oldArray));
newSet.removeAll(oldSet);
oldSet.removeAll(temp);
newSet.addAll(oldSet);
return (T[]) newSet.toArray();
}

判断两个数组是否相等[compare two array]

<T> boolean isDiffrent(T[] a, T[] b) {
if (a != null && b != null) {
if (a.length != b.length)
return true;
Comparator comparator = new Comparator<T>() {
public int compare(T o1, T o2) {
return 0;// TODO need to implement
}
};
Arrays.sort(a, comparator);
Arrays.sort(b, comparator);
return !Arrays.equals(a, b);
}
return false;//!null.equals(null)
}

Real-World Experiences With Hibernate

original link

HibernateTools eclipse插件 CodeBuilder

写了两个hql查询参数设置辅助类，一个根据参数(?)位置(index)顺序方式，另一个用名称参数

顺序方式

import java.util.ArrayList;

import java.util.List;

import org.hibernate.Hibernate;

import org.hibernate.Query;

import org.hibernate.type.Type;

@SuppressWarnings( { "unchecked", "unused" })

/**

* hql查询参数设置包装类用?顺序赋值的方式

* @author jeff.yao

* @date 2012-3-28

* */

public class QueryParamWarper {

private final List<QueryParam> list = new ArrayList<QueryParam>(16);// 初始化长度

public QueryParamWarper() {

}

// 支持链式操作

public QueryParamWarper add(QueryParam e) {

list.add(e);

return this;

}

// 支持链式操作

public QueryParamWarper add(Object value, Type type) {

list.add(new QueryParam(value, type));

return this;

}

public List<QueryParam> getList() {

return list;

}

public Query setQuery(final Query query) {

for (int index = 0, length = list.size(); index < length; index++) {

QueryParam p = list.get(index);

Type type = p.getType();

query.setParameter(index, p.getValue(), type);

}

return query;

}

public static void main(String[] args) {

QueryParamWarper w = new QueryParamWarper();

for (int i = 0; i < 100; i++) {

w.getList().add(new QueryParam("string" + i, Hibernate.STRING));

}

class QueryParam {

* http://docs.jboss.org/hibernate/orm/3.5/api/org/hibernate/type/Type.html

* http://www.roseindia.net/hibernate/hibernate-types.shtml

private Type type;

private Object value;

/**

* @param type Hibernate.Type

* @param value

public QueryParam(Object value, Type type) {

super();

this.type = type;

this.value = value;

}

public Type getType() {

return type;

}

public Object getValue() {

return value;

}

名称参数

import java.util.Collection;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import org.hibernate.Query;

/**

* hql查询参数设置辅助类用命名参数赋值的方式

* @author jeff.yao

* @date 2012-3-28

* */

public class QueryParamHelper {

private Map<String, Object> map = null;

public QueryParamHelper(int initialCapacity) {

map = new HashMap<String, Object>(initialCapacity <= 0 ? 16 : initialCapacity);

}

public QueryParamHelper(Map<String, Object> map) {

if (map != null) {

this.map = map;

}

public QueryParamHelper set(String name, Object value) {

map.put(name, value);

return this;

}

@SuppressWarnings("unchecked")

public Query setParameter(Query query) {

if (map != null) {

Set<String> keySet = map.keySet();

for (String name : keySet) {

Object value = map.get(name);

Class clazz = value.getClass();

if (Collection.class.isAssignableFrom(clazz)) {

query.setParameterList(name, (Collection) value);

} else if (clazz.isArray()) {

query.setParameterList(name, (Object[]) value);

} else if (clazz == Date.class) {// 日期用setTimestamp

query.setTimestamp(name, (Date) value);

} else {

query.setParameter(name, value);

}

return query;

}

equals&&hashCode方法的最佳实践

original link->
equals&&hashCode是一对孪生方法，使用集合（Collection such as Set, List or Map）需要将自定义类作为键值（key）时，需要了解这哥俩，在自定义类中它俩一般要同时重写。

equals的最佳实践：
1.反身性(Reflexive) o.equals(o)
2.对称性(Symmetric)o1.equals(o2) <=> o2.equals(o1) ,o1,o2类型要相同
3.传递性(Transitive) o1.equals(o2) && o2.equals(o3) =>o1.equals(o3)
4.一致性(Consistent) 只要o1,o2没有变,o1.equals(o2) 始终成立
5.null和任何对象不等,!o1.equals(null)
6.o1.equals(o2) => o1.hashCode() == o2.hashCode() ,equals/hashCode方法要一起重写且含有相同的识别属性，对象相等hashCode也相同，反之不一定成立

hashCode的最佳实践：

1.一个对象的hashCode必须始终保持不变

2.对象相等hashCode相同,一个属性[没]被用于判别是否equals，也必须[没]用于计算hashCode，反之亦然。

3.不等的对象可能返回相同的hashCode（撞衫了，囧）

public class Pet {
 
 int id;
 
 String name;
 
 public boolean equals(Object obj){
  if(this == obj) return true; // if both are referring to the same object
  if ((obj == null) || (obj.getClass() != this.getClass())) {
    return false;
  }
  Pet rhs = (Pet) obj;
  return id == rhs.id&&(name == rhs.name ||
  (name != null&&name.equals(rhs.name)) ); 
 }
  
 public int hashCode() { 
  int hash = 9;
  hash = (31 * hash) + id;
  hash = (31 * hash) + (null == name ? 0 : name.hashCode()); 
  return hash; 
 }

位或操作(|)在循环中的使用

AbstractSet.java的代码中发现这句

public boolean removeAll(Collection<?> c) {
boolean modified = false;
if (size() > c.size()) {
for (Iterator<?> i = c.iterator(); i.hasNext(); )
modified |= remove(i.next());//位或操作,只要又一次remove返回true，结果即为true
} else {
for (Iterator<?> i = iterator(); i.hasNext(); ) {
if (c.contains(i.next())) {
i.remove();
modified = true;
}
}
}
return modified;
}

PS:这个代码还有点可以借鉴的地方是，循环前比较两个集合的长度大小，递归小的那个集合

2012年3月19日星期一

image local preview

image preview

2012年3月16日星期五

picture local preview图片本地预览

//图片预览
function previewImage(file) {
//图片选择本地上传，限制大小不超过1M，格式为JPG、GIF、PNG 大小写
var suffix = ["JPG","GIF","PNG"];
var img = document.getElementById("image");
try {
img.src = file.files.item(0).getAsDataURL();
} catch(e) {
try {
var reader = new FileReader();
reader.onload = function(evt) {
img.src = evt.target.result;
}
reader.readAsDataURL(file.files[0]);
} catch(e) {
try {
file.select();
var src = document.selection.createRange().text;
src = src || document.selection.createRangeCollection().item(0).text;
img.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=\"scale\",src=\"" + src + "\")";
} catch(e) {
try {
img.src = file.value;
} catch(e) {
console.log(e);
}
}
}
$(img).css({width: "300px",height: "200px"});
}
}