老翟 - BlogJava

commons-lang源码学习之ArrayUtils

1、比较两个对象是否类型相同

array1.getClass().getName().equals(array2.getClass().getName()

2、倒置(reverse)数组中的元素

         int i = 0;
        int j = array.length - 1;
        Object tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
          }

3、得到数组的容器类型

array.getClass().getComponentType();

4、lastIndex()这类方法的实现

for (int i = startIndex; i >= 0; i--) {
              if (objectToFind.equals(array[i])) {
                  return i;
              }
}

5、isEmpty()这类方法的实现只要一句话，isNotEmpty方法依此推

return array == null || array.length == 0;

6、将两个数组合并addAll

       boolean[] joinedArray = new boolean[array1.length + array2.length];
       System.arraycopy(array1, 0, joinedArray, 0, array1.length);
       System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);

7、将新元素加入到数组中

            int arrayLength = Array.getLength(array);
            Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
            System.arraycopy(array, 0, newArray, 0, arrayLength);
            return newArray;

8、获得数组长度的方法

int arrayLength = Array.getLength(array);

9、以反射的方式获得数组对象

Array.newInstance(array.getClass().getComponentType(), arrayLength + 1)

10、将某一元素从数组中移除

Object result = Array.newInstance(array.getClass().getComponentType(), getLength(array)- 1);
       System.arraycopy(array, 0, result, 0, index);
       if (index < length - 1) {
           System.arraycopy(array, index + 1, result, index, length - index - 1);
       }

posted @ 2011-03-08 15:01 jack zhai 阅读(792) | 评论 (0) | 编辑收藏

泛型知识

1、泛型是给java编译器使用的，在源文件经过编译后，编译器会将类型信息去掉，所以

testList<String> ls = new ArrayList<String>();
List<Boolean> ls1 = new ArrayList<Boolean>();
System.out.println(ls==ls1) ;
//true;

2、可以绕过编译器的类型信息检查，而直接加入对象

testimport java.util.* ;
import java.lang.* ;

public class Fanx {
	
	public static void main (String args[]) {
		ArrayList<Integer> ls = new ArrayList<Integer>();
		try{
			ls.getClass().getMethod("add", Object.class).invoke(ls,"abc") ;
		}catch(Exception e){
			System.out.println(e.getMessage());
		}
		
		System.out.println(ls.get(0));
	}
}//out:abc

3、泛型通配符

testpublic static void printCollection(Collection<?> coll) {
//可以传Collection<String>,Collection<Integer>,Collection<Boolean>等等，但在此方法内不能使用诸如coll.add(“Strin”)这样具有类型信息的方法
for(Object obj:coll){
	System.out.println(obj);
}//coll.add(“str”); 报错
}

4、限定通配符上边界，限定通配符上边界

testpublic static void printCollection1(Collection<? extends Number> coll) {
		//
		for(Object obj:coll){
			System.out.println(obj);
		}
}
//printCollection1(new ArrayList<Integer>()) ;//不报错
//printCollection1(new ArrayList<String>()) ; //报错，传入泛型参数必须为Number的子类

testpublic static void printCollection2(Collection<? super Number> coll) {
		//
		for(Object obj:coll){
			System.out.println(obj);
		}
	}
//printCollection1(new ArrayList<Integer>()) ;//不报错
//printCollection1(new ArrayList<String>()) ; //报错，传的参数化必须是以Number为父类

5、自定义泛型方法

testpublic <T> T swap(T[] t,int i,int j){
		T temp = t[i] ;
		t[i] = t[j] ;
		t[j] = t[i] ;
		return (T) t ;
}

6、类级别泛型

testpublic class Dao<T> {
	public <T> T getEntity(int id){
		return null;
	}
}

7、通过反射获得泛型的实际类型参数

testimport java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.Map;
import java.util.Vector;

//假如我们要想获得 Vector<Date> v = new Vector<Date>(); v的实际类型参数
//我们必须写一个如applyRef的方法
public class Dao {
	
	public void applyRef1(Map<String,Integer> map,Vector<Date> v){
		
	}
	
	public static void main(String[] args) {
		try {
			Method method = new Dao().getClass().getMethod("applyRef1", Map.class,Vector.class) ;
			
			Type[] pType = method.getParameterTypes();
			
			Type[] neiType = method.getGenericParameterTypes();
			
			System.out.println(pType[0]) ;
			System.out.println(pType[1]) ;
			
			System.out.println(neiType[0]) ;
			System.out.println(neiType[1]) ;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

posted @ 2011-03-05 19:45 jack zhai 阅读(88) | 评论 (0) | 编辑收藏

对传入字符进行排列组合并进行md5编码，最后写入文件

Combinationsimport java.io.File;
import java.io.Serializable;


public class Combinations implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 6509436857839528414L;
	
	private int min;
	private int max;
	private char[] chars;// 字符数组
	private int charLen;// 字符串长度

	private String path ;
	private String trueStr ;
	private IOUtil iou;
	

	public Combinations() {
		this.min = 1;
		this.max = trueStr.length() ;
		this.charLen = trueStr.length();
		this.chars = trueStr.toCharArray();
	}


	public Combinations(String str, int min, int max, String path) {
		this.min = min;
		this.max = max;
		this.trueStr = str ;
		this.charLen = str.length();
		this.chars = str.toCharArray();
		iou = IOUtil.getInstence(path);
	}

	public void combination() {
		if (min > max) {
			int t = max;
			max = min;
			min = t;
		}
		for (int i = min; i <= max; i++) {
			combination(new StringBuffer(""), i);
		}
	}

	public void combination(StringBuffer str, int length) {
		if (length < 1) {
			System.out.println("长度小于1");
		}
		
		if (length == 1) {
			for (int i = 0; i < charLen; i++) {
				StringBuffer result = new StringBuffer(str);
				result.append(chars[i]);
				iou.put(result.toString(), 
						MD5Util.getMD5Str(result.toString()));
			}
		}

		if (length > 1) {
			for (int i = 0; i < charLen; i++) {
				StringBuffer temp = new StringBuffer(str);
				 combination(temp.append(chars[i]), length - 1);
			}
		}

	}
	
	/**
	 *setter getter  
	 */
	public IOUtil getIou() {
		return iou;
	}

	public void setIou(IOUtil iou) {
		this.iou = iou;
	}

	public int getMin() {
		return min;
	}

	public void setMin(int min) {
		this.min = min;
	}

	public int getMax() {
		return max;
	}


	public void setMax(int max) {
		this.max = max;
	}


	public char[] getChars() {
		return chars;
	}


	public void setChars(char[] chars) {
		this.chars = chars;
	}


	public int getCharLen() {
		return charLen;
	}


	public void setCharLen(int charLen) {
		this.charLen = charLen;
	}


	public String getPath() {
		return path;
	}


	public void setPath(String path) {
		this.path = path;
	}


	public String getTrueStr() {
		return trueStr;
	}


	public void setTrueStr(String trueStr) {
		this.trueStr = trueStr;
	}


	public static void main(String[] args) {
		String path = "F:"+File.separator+"md5"
						+File.separator+"md5.txt";
		Combinations ct = new Combinations("123456",1,4,path);
		ct.combination() ;
		ct.getIou().close() ;
	}


}

md5Utilimport java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


public class MD5Util {
	/**
	 * MD5 加密
	 */
	public static String getMD5Str(String str) {
		MessageDigest messageDigest = null;

		try {
			messageDigest = MessageDigest.getInstance("MD5");
			messageDigest.reset();
			messageDigest.update(str.getBytes("UTF-8"));
		} catch (NoSuchAlgorithmException e) {
			System.out.println("NoSuchAlgorithmException caught!");
			System.exit(-1);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		byte[] byteArray = messageDigest.digest();

		StringBuffer md5StrBuff = new StringBuffer();

		for (int i = 0; i < byteArray.length; i++) {
			if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)
				md5StrBuff.append("0").append(
						Integer.toHexString(0xFF & byteArray[i]));
			else
				md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));
		}

		return md5StrBuff.toString();
	}

}

IO工具包

md5Utilimport java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IOUtil implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1611785226109373473L;
	
	/*
	 * 接收key 和 value，然后写入一个map，计数器count++如果count>30，IOWrite进入flush；
	 * 判断文件是否大于30MB，则新建另一文件将map清空，将count设置为0；
	 */
	private String sourcePath;
	private String newPath;
	private int MAXSIZE = 30000;
	private int fileCount = 0; // 文件计数器
	private PrintWriter pw = null;
	private List<String> list = new ArrayList<String>();
	private static IOUtil instance = new IOUtil();

	private IOUtil() {
	}

	public static IOUtil getInstence(String path) {
		if (null == instance) {
			instance = new IOUtil();
		}
		instance.setSourcePath(path);
		instance.setNewPath(path);
		return instance;
	}

	public void put(String key, String value) {
		//判断path中的文件
		File file = new File(newPath) ;
		if(!file.exists()){
			try {
				file.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
		}
		
		
		try {
			pw = new PrintWriter(new FileWriter(file));
		} catch (IOException e) {
			System.out.println("找不到文件" + e.getMessage());
		}
		
		if (list.size() <= MAXSIZE) {
			list.add(key + "  " + value);
		} else {
			Iterator<String> it = list.iterator();
			while (it.hasNext()) {
				pw.println(it.next());
			}
			// 刷新
			pw.flush();
			list.clear();
			this.fileCount++;
			this.newPath = this.sourcePath.substring(0, this.sourcePath
					.lastIndexOf('.'))
					+ "_"
					+ this.fileCount
					+ this.sourcePath.substring(this.sourcePath
							.lastIndexOf('.'));

		}
	}

	@SuppressWarnings("unchecked")
	public void close() {
		Iterator itor = null;
		if (list.size() > 0 && this.pw != null) {
			itor = list.iterator();
			while (itor.hasNext()) {
				pw.println(itor.next());
			}
			pw.close();
		}
		itor = null;
		pw = null;
	}

	/*******************
	 * getter setter
	 *******************/
	public String getSourcePath() {
		return sourcePath;
	}

	public void setSourcePath(String sourcePath) {
		this.sourcePath = sourcePath;
	}

	public String getNewPath() {
		return newPath;
	}

	public void setNewPath(String newPath) {
		this.newPath = newPath;
	}

	public PrintWriter getPw() {
		return pw;
	}

	public void setPw(PrintWriter pw) {
		this.pw = pw;
	}

}

posted @ 2011-03-03 13:17 jack zhai 阅读(300) | 评论 (0) | 编辑收藏

对象的创建过程《Think in java》读书笔记

假设有一个Dog类

1、当首次创建Dog的对象时（构造器可以看成静态方法），或者Dog类的静态方法/静态域首次被访问时，java解释器必须查找类路径，以定位Dog.class文件
2、然后载入Dog.class，有关静态初始化的所有动作都会执行。因此，静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
3、当用new Dog()创建对象的时候，首先将在堆上为Dog类分配足够的存储空间。
4、这块存储空间会被清零，这就看上去地将Dog对象中所有基本类型数据都设置成了默认值，而引用则被设置成了null。
5、执行所有出现于字段定义处的初始化动作。
6、执行构造器。

posted @ 2011-02-23 16:17 jack zhai 阅读(120) | 评论 (0) | 编辑收藏

类的内部，变量的定义先后顺序决定变量初始化的顺序

1、在类的内部，变量的定义先后顺序决定变量初始化的顺序，它们将会在任何方法（构造函数）被调用前被初始化

package cc.text;
2

public class Dog {
4

Cat c1 = new Cat(1) ; ;
6

Cat c2 = new Cat(2) ;
7

public Dog(){
8

c1 = new Cat(1) ;
9

}
10

public void foo(){
11

System.out.println("dog woo!");
12

}
13

Cat c3 = new Cat(3) ;
14

public static void main(String[] args) {
16

Dog d = new Dog() ;
17

d.foo() ;
18

}
19

}
20

class Cat{
21

public Cat(int i){
22

System.out.println("ini cat"+ i);
23

}
24

}
25

posted @ 2011-02-23 16:07 jack zhai 阅读(200) | 评论 (0) | 编辑收藏

方法重载

a、区分方法的重载有：

1、参数顺序

public void info(int i, String str);

public void info(String str, int i);

2、以返回值区分重载方法

void f(){}

int f(){return 1;}

当int i = f();时就会调用int f(){return i;}方法

b、基本类型的重载

1、基本类型从一个“较小”的类型自动提提升成“较大”的类型

2、如果找不到有char型的方法，就会把char型提升为int型

posted @ 2011-02-23 13:41 jack zhai 阅读(123) | 评论 (0) | 编辑收藏

使用Dbcp和DbUtils的简单实例

摘要: 这个类是用OSChina红薯老大的。 package com.dbutilTest; import java.sql.Connection; import java.sql.SQLException; import java.util.HashMap; import java.util.Map; import javax.... 阅读全文

posted @ 2011-02-22 00:02 jack zhai 阅读(62) | 评论 (0) | 编辑收藏

面向对象学习之狗门代码

Bark，狗叫声类import java.util.Collection;
import java.util.List;


public class Bark {
	private String sound ;

	private DogDoor dogDoor ;
	
	public Bark(DogDoor dogDoor){
		this.dogDoor = dogDoor ;
	}
	public Bark(String sound) {
		this.sound = sound ;
	}
	public Bark(DogDoor dogDoor,String sound) {
		this(dogDoor) ;
		this.sound = sound ;
	}

	
	public boolean equals(Bark bark) {
		if(bark!=null && bark.sound.equals(this.sound)){
			return true ;
		}
		return false ;
	}
	
	public String getSound() {
		return sound;
	}

	public void setSound(String sound) {
		this.sound = sound;
	}
	
	public Bark() {} 
	
}

BarkRecognizer，狗叫识别器import java.util.Collection;
import java.util.Iterator;


public class BarkRecognizer {
	private DogDoor dogDoor ;

	public BarkRecognizer(DogDoor dogDoor) {
		super();
		this.dogDoor = dogDoor;
	}
	
	public void recognizer(Bark bark) {
		Collection barks = dogDoor.getAllowedBarks() ;
		Iterator it = barks.iterator() ;
		while(it.hasNext()){
			if(bark.equals((Bark)it.next()) ){
				dogDoor.open() ;
				System.out.println("the door opens");
				break ;
			}
		}
		
		System.out.println(bark.getSound() + "is not bruce");
		
//		if(barks != null && barks.size() >=1){
//			 if(barks.contains(bark)){
//				 dogDoor.open() ;
//			 }
//		}
	}
	
	public BarkRecognizer() {}
}

狗门import java.util.LinkedList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

public class DogDoor {
	
	private boolean open ;
	List barks = new LinkedList();
	
	public void open() {
		if(!open){
			this.open = true ;
		}
		final Timer timer = new Timer() ;
		timer.schedule(new TimerTask(){
			public void run() {
				close() ;
				timer.cancel() ;
			}
		},5000);
	}
	
	public void close() {
		this.open = false ;
		System.out.println("the door close");
	}
	
	public void addAllowedBark(Bark bark) {
		if(bark!=null){
			this.barks.add(bark) ;
		}
	}
	
	public List getAllowedBarks() {
		return this.barks ;
	}
	
	public boolean isOpen() {
		return open ;
	}
	
}

遥控器
public class Remote {
	private DogDoor dogDoor ;

	public Remote(DogDoor dogDoor) {
		super();
		this.dogDoor = dogDoor;
	}

	public void pressButton() {
		dogDoor.open() ;
	}
	
	public Remote() {} ;
}

测试类import org.junit.Test;



public class TestDogDoor {
	@Test
	public void dogDoorTest() {
		DogDoor door = new DogDoor() ;
		door.addAllowedBark(new Bark("rowlf")) ;
		door.addAllowedBark(new Bark("roooowlf")) ;
		door.addAllowedBark(new Bark("woof")) ;
		door.addAllowedBark(new Bark("rawlf")) ;
		
		BarkRecognizer recognizer = new BarkRecognizer(door) ;
		
		Remote remote = new Remote(door);

		System.out.println("bruce starts barkings") ;
		
		recognizer.recognizer(new Bark("rowlf")) ;
		
		System.out.println("bruce has gone outside") ;
		
		try{
			Thread.currentThread().sleep(1000) ;
		}catch(InterruptedException e){
			System.out.println("error") ;
		}
		
		System.out.println("bruce' all done") ;
		System.out.println("but he's stuck outside!") ;
		Bark smallDogBark = new Bark("yip") ;
		System.out.println("a small dog starts barking");
		recognizer.recognizer(smallDogBark) ;
		
		try{
			Thread.currentThread().sleep(1000) ;
		}catch(InterruptedException e){
			System.out.println("error") ;
		}
		System.out.println("bruce starts barking");
		recognizer.recognizer(new Bark("woof")) ;
		
		System.out.println("bruce 'back inside");
		
	}
}

posted @ 2010-12-21 12:01 jack zhai 阅读(160) | 评论 (0) | 编辑收藏

spring框架下使用hibernateTemplate

在spring配置文件中加入：

spring配置文件<?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:context="http://www.springframework.org/schema/context"
    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.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <context:annotation-config />
    <context:component-scan base-package="cc.apl330" />

<bean
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>classpath:jdbc.properties</value>
        </property>
    </bean> 

    <bean id="dataSource" destroy-method="close"
        class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName"
            value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean> 

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 
        <property name="annotatedClasses">
            <list>
                <value>com.bjsxt.model.User</value>
                <value>com.bjsxt.model.Log</value>
            </list>
        </property>
         -->
         <property name="packagesToScan">
            <list>
                <value>cc.apl330.model</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.MySQLDialect
                </prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

</beans>

posted @ 2010-12-17 21:43 jack zhai 阅读(126) | 评论 (0) | 编辑收藏

Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2所需要的jar包列表

jar包名称	所在位置	说明
antlr-2.7.6.jar	hibernate/lib/required	解析HQL
aspectjrt	spring/lib/aspectj	AOP
aspectjweaver	..	AOP
cglib-nodep-2.1_3.jar	spring/lib/cglib	代理，二进制增强
common-annotations.jar	spring/lib/j2ee	@Resource
commons-collections-3.1.jar	hibernate/lib/required	集合框架
commons-fileupload-1.2.1.jar	struts/lib	struts
commons-io-1.3.2	struts/lib	struts
commons-logging-1.1.1	单独下载，删除1.0.4(struts/lib)	struts spring
dom4j-1.6.1.jar	hibernate/required	解析xml
ejb3-persistence	hibernate-annotation/lib	@Entity
freemarker-2.3.13	struts/lib	struts
hibernate3.jar	hibernate
hibernate-annotations	hibernate-annotation/
hibernate-common-annotations	hibernate-annotation/lib
javassist-3.9.0.GA.jar	hiberante/lib/required	hibernate
jta-1.1.jar	..	hibernate transaction
junit4.5
mysql-
ognl-2.6.11.jar	struts/lib
slf4j-api-1.5.8.jar	hibernate/lib/required	hibernate-log
slf4j-nop-1.5.8.jar	hibernate/lib/required
spring.jar	spring/dist
struts2-core-2.1.6.jar	struts/lib
xwork-2.1.2.jar	struts/lib	struts2
commons-dbcp	spring/lib/jarkata-commons
commons-pool.jar	..
struts2-spring-plugin-2.1.6.jar	struts/lib

posted @ 2010-12-15 09:53 jack zhai 阅读(3648) | 评论 (2) | 编辑收藏

仅列出标题

老翟

commons-lang源码学习之ArrayUtils

泛型知识

对传入字符进行排列组合并进行md5编码，最后写入文件

对象的创建过程《Think in java》读书笔记

类的内部，变量的定义先后顺序决定变量初始化的顺序

方法重载

使用Dbcp和DbUtils的简单实例

面向对象学习之狗门代码

spring框架下使用hibernateTemplate

Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2所需要的jar包列表

导航

常用链接

留言簿

随笔分类

随笔档案

相册

搜索

最新评论

阅读排行榜

评论排行榜