java知识点总结

* java基础

1.charAt(1);
	String a="你好";
	char b=a.charAt(1); //注意这里返回的类型是char,1是指的是'好'这个字符,位置是从0开始的
2.count++表示先执行输出,然后再++
	++count表示先执行++再执行输出
3.String a="helloworld";
	a.toCharArray();//返回的是char数组
4.增强for
	int[] a=new int[]{1,2,3,4,3,1};
		for(int i:a){
			System.out.println(i);
		}
5.jdbc连接sqlserver数据库
	Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	Connection conn=DriverManager.getConnection("jdbc:sqlserver://localhost:1433;DatabaseName=U","huyao","123");
6.jdbc连接oracle数据库
	Class.forName("oracle.jdbc.driver.OracleDriver");
	Connection conn=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl","huyao","123");
7.request.getServeName();
	获取ip地址
8.
	public static boolean isNummOrEmpty(String source){
		return(source==null||"".equals(source.trim()));
	}
9.	
   在命令行的时候输入 set classpath=d:\java\可以设置java的路径,以后所有的类都从这里面找,告诉jvm的保存路径
输入set classpath=.设置成当前的路径
10.将string类型转化为Date类型
	public static Date parseStringToDate(String s) throws Exception{
		java.text.SimpleDateFormat sdf=new 						java.text.SimpleDateFormat("yyyy-MM-dd");
		return sdf.parse(s);
	}
	
11.关于string对象的subString()方法
	substring(beginInt);//从起始位置开始往后的字符,
	substring(beginInt,endInt);//从起始位置开始,到结束位置,起始位置是0,1,2...结束位置的算法1,2,3..
	
12.int[] a=new int[]{1,2,3,4,3,1};
		for(int i:a){
			Thread.sleep(5000);//延时5秒后执行下面的程序
			System.out.println(i);
		}
13.不定参数
	private  static boolean isNull(String ...args){
		for(int i=0;i<args.length;i++){
			if(args[i]==null ||"".equals(args[i])){
				return true;
			}
		}
		return false;
	}


14.关于this
  a）this关键字是在对象内部指代对象自身的引用 （正确）
  b）this关键字可以在类中的任何位置使用  （错误）注：this不能在静态函数中使用。
  c）this关键字和类关联，而不是和特定的对相关联（错误） 注：this跟对象关联，它是对象本身的引用。
  d)同一个类的不同对象公用同一个this（错误） 注：this于特定的对象关联，一个对象对于一个this，不能共用。
15.起始页面自动跳转
	 <meta http-equiv="refresh" content="0; url=toLoginHomeAction"> 
16.不足补0
	public static void main(String[] args) throws Exception {
		System.out.println(addZero(89,3));
	}
	public static String addZero(int num,int len){
		StringBuffer sb=new StringBuffer();
		sb.append(num);
		while(sb.length()<len){
			sb.insert(0, "0");
		}
		return sb.toString();
	}
17.cmd
进入目标目录
输入 java -jar MyEclipseKeyGen.jar
后面就是要执行的jar文件
18.如何获得闰年:
	if(year%4==0&&year%100!=0||year%400==0)
	
19.文件重命名
File file=new File("a.txt");
file.renameTo(new File("b.txt"));


20.如何查询端口被哪个进程占用?
	netstat -nao查询到PID
	一般情况下PID在进程管理器中不会显示,点击 查看-显示PID
	
21.-Xms256m -Xmx1024m -XX:PermSize=600m -XX:MaxPermSize=600m


22.
	1.window--preferences-General--Startup and Shutdown 勾上 prompt for workspace on startup
	2.如果还是打开一个工作空间,删除快捷方式,或者在快捷方式--属性--目标后面加 -clean
	如:："D:/Program Files/MyEclipse8.0/myeclipse.exe" -clean 
	
23.
	window-preferences-run/debug-perspectives
	open the associated perspective when lauching
	设置为always
	open the associated perspective when application suspends
	设置为always


24.
	1. 要么右键单击文件，选择 Open With - MyEclipse JSP Editor 打开，这样不会采用可视化的打开，耗资源少，自动提示也非常快。 
	2. 要么采取一劳永逸的方法 Window - Preferences - General - Editors - File Associations 
	将默认打*.jsp的editor关联设置为MyEclipse JSP Editor 

  
  
* Class.getResourceAsStream和ClassLoader.getResourceAsStream

	1.返回inputStream
		1).在使用Class.getResourceAsStream 时， 资源路径有两种方式， 一种以 / 开头，则这样的路径是指定绝对路径， 如果不以 / 开头，则路径是相对与这个class所在的包的。 
		2).在使用ClassLoader.getResourceAsStream时， 路径直接使用相对于classpath的绝对路径。 
	举例，下面的三个语句，实际结果是一样的： 
	com.explorers.Test.class.getResourceAsStream("abc.jpg")
	com.explorers.Test.class.getResourceAsStream("/com/explorers/abc.jpg")
	ClassLoader.getResourceAsStream("com/explorers/abc.jpg")//后面可以加.getFIle()获取文件

* StringBuilder和StringBuffer

	1. 在执行速度方面的比较：StringBuilder >  StringBuffer   
	2. StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，
	不像String一样创建一些对	象进行操作，所以速度就快了。
	3.  StringBuilder：线程非安全的
　 		StringBuffer：线程安全的
    当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。
	当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。
 
	对于三者使用的总结：1.如果要操作少量的数据用 = String
　　　　　　            2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
　　　　　　            3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

* BeanUtils

	import org.apache.commons.beanutils.BeanUtils;
		public class Test {
			public static void main(String[] args) {
				Money m=new Money(112);
				try {
					BeanUtils.setProperty(m, "amount", 20);
				} catch (Exception e) {
				}
				System.out.println(m.getAmount());
			}
		}
		1.导入jar包 
		2.利用BeanUtils.setProperty给该实例的amount字段赋值,输出的是20而不是112

* BufferedImage

	String imgPath="D://1.jpg";
		try {
			BufferedImage bi=ImageIO.read(new FileInputStream(imgPath));
			或者
			ImageIO.read(new File(imgPath));
			//ImageIO用于读取图像文件
			int h=bi.getWidth();
			System.out.println(h);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

* button按钮提交表单

	<script type="text/javascript">
		function doLogin(){
			document.forms[0].submit();
		}
	</script>
	
	<s:form action="loginAction">
   		<input type="button" value="提交" οnclick="doLogin()"/>
   	</s:form>

* JSP自定义标签

	一般情况下开发jsp自定义标签需要引用以下两个包
	import javax.servlet.jsp.*;
	import javax.servlet.jsp.tagext.*;


		1.创建自定义标签类 //这里可以实现Tag接口,或者继承SimpleTagSupport,如果继承SimpleTagSupport只需要重写doTag方法
			public class Helloworld extends TagSupport{
				private int count;	//这个count可以作为参数,必须要有set方法
				public void setCount(int count){
					this.count=count;	
				}
				public int doEndTag(){
					this.getPageContext().getOut().print("...");
				}
			}
			
		2.在Web-Inf创建标签库描述文件.tld(Tag Library Description)//右键新建xml(basic schema)
				<?xml version="1.0" encoding="UTF-8"?>


				<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
				 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
				 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd">


				<tlib-version>1.0</tlib-version>
				<jsp-version>2.0</jsp-version>
				<short-name>cc</short-name>
				<uri>/mytaglib</uri>	//uri页面上引入的路径
				<tag>
					<name>showUserInfo</name>
					<tag-class>com.mytags.UserInfoTag</tag-class>
					<body-content>empty</body-content>	//如果不需要标签体则设置empty，反之设定jsp
					<attribute>
						 <name>user</name>
						 <required>false</required>
						 <rtexprvalue>true</rtexprvalue>//是否可在属性中使用表达式
					</attribute>
				</tag>


				</taglib>


		3.配置web.xml
			<jsp-config>
				<taglib>
					<taglib-uri>/mytaglib</taglib-uri>
					<taglib-location>/WEB-INF/mytaglib.tld</taglib-location>
				</taglib>
			</jsp-config>




		4.在需要使用此标签的jsp页面头部引入
		<%@ taglib uri="/mytaglib" prefix="cc"%>






		5.自定义repeat标签
			(1).创建需要展现javabean（UserInfo）集合的实例（用于测试数据） 


		<%
			List<UserInfo> users = new ArrayList<UserInfo>();   
			users.add(new UserInfo("Zhangsan", 12, "Zhangsan@163.com"));
			users.add(new UserInfo("Lisi", 22, "Lisi@sina.com"));
			users.add(new UserInfo("Wangwu", 33, "Wangwu@qq.com"));
			pageContext.setAttribute("users", users);
		%>


			(2).给标签绑定数据源  
		<table width='500px' border='1' align='center'>
			<tr>
				<td width='20%'>UserName</td>
				<td width='20%'>Age</td>
				<td>Email</td>
			</tr>
			<cc:repeater var="item" items="${pageScope.users }">
				<tr>
					<td>${item.userName }</td>
					<td>${item.age }</td>
					<td>${item.email }</td>
				</tr>
			</cc:repeater>
		</table>


	(3).创建自定义标签类
	public class Repeater extends TagSupport {
    private Collection items;
    private Iterator it;
    private String var;
    @Override
    public int doStartTag() throws JspException {
        if(items == null || items.size() == 0) return SKIP_BODY;
        it = items.iterator();  
        if(it.hasNext()) {
            pageContext.setAttribute(var, it.next());
        }
        return EVAL_BODY_INCLUDE;
    }


    @Override
    public int doAfterBody() throws JspException {
        if(it.hasNext()) {
            pageContext.setAttribute(var, it.next());
            return EVAL_BODY_AGAIN;//这里是AGAIN
        }
        return SKIP_BODY;
    }
    @Override
    public int doEndTag() throws JspException {
        return EVAL_PAGE;
    }


    public void setItems(Collection items) {
        this.items = items;
    }
  
    public void setVar(String var) {
        this.var = var;
    }


}


	(4).在Web-Inf创建标签库描述文件
	<tag>
		<name>repeater</name>
		<tag-class>com.mytags.Repeater</tag-class>
		<body-content>jsp</body-content>
		<attribute>
			<name>items</name>
			<required>false</required>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
		<attribute>
			<name>var</name>
			<required>true</required>
			<rtexprvalue>true</rtexprvalue>
		</attribute>
	 </tag>


	(5).在需要使用此标签的jsp页面头部引入
	<%@ taglib uri="/mytaglib" prefix="cc"%>


	
6.SKIP_BODY,SKIP_PAGE,EVAL_BODY_INCLUDE,EVAL_BODY_AGAIN返回值的各个含义 
	skip_body,eval_body_include是doStartTag的返回值
	skip_body指的是跳过标签内部的内容比如
	<cc:mytag>helloworld</cc:mytag>
	如果cc:mytag输出的是fuck并且doStartTag返回的是skip_body则不显示helloworld
	
	skip_page,EVAL_PAGE是doEndTag的返回值
	
	

* String.compareTo();

	1.基本用法
	import  java.lang.*
	public class compareto{
		public static void main(String[] args){
			String strCom="I like XX";
			String strCom1="I like AA";
			String strCom2="you are AA";
			String strCom3="you are BB";
			System.out.println(strCom.compareTo(strCom1));
			System.out.println(strCom2.compareTo(strCom3));		
		}
	}
	输出:23
		-1
	//先看strCom和strCom1，很明显，它俩是从X跟A开始不同的，
	//而X和A的ASC码相差23个，然后可以看到输出的是“23”
	//然后看strCom2和strCom3，开始不同的是A跟B……
	//因为是A在先，B在后，所以输出"-1"


	2.特别注意
			String a="abcdefg";
			String b="abc";
			System.out.println(a.compareTo(b));
	//当a和b比较是如果比较到其中的一个所有的字符都相同,compareTo返回的是他们之间的长度差	

* Hashtable和HashMap的区别： 

	1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类； 
	2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决： 
	Map Collections.synchronizedMap(Map m) 
	这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。 
	3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。

* </HEAD>

	<jsp:include page="../authority.jsp" flush="true" />
	<BODY leftmargin="0" topmargin="0">

	1.flush=true
	设置flush为true，就是说，如果你的缓冲区的内容很多了，就将数据读出，以免数据泄漏，造成错误。 	服务器端页面缓冲，大致的意思是，在将生成的HTML代码送到客户端前，先在服务器端内存中保留，因为解释JSP或Servlet变成HTML是一步步进行的，可以在服务器端生成完HTML或生成一部分HTML（所占用字节数已达到指定的缓冲字节数）后再送到客户。   
	如果不缓冲，就会解释生成一句HTML就向客户端送一句。   
	在<jsp:include语句中，必须设置flush="true">

	如果这个属性定义为true(默认值),那么既使在缓存溢出时也会强制输出正常结果,如果其值被设置为false,这个溢出就可能导致意外错误


	2.include的两种形式
	一:执行时间上: 　　
	<%@ include file=”relativeURI”%> 是在翻译阶段执行 　　
	<jsp:include page=”relativeURI” flush=”true” /> 在请求处理阶段执行. 　　

	二:引入内容的不同: 　　
	<%@ include file=”relativeURI”%> 　　
	引入静态文本(html,jsp),在JSP页面被转化成servlet之前和它融和到一起. 　　
	<jsp:include page=”relativeURI” flush=”true” />
	引入执行页面或servlet所生成的应答文本. 
	　　
	另外在两种用法中file和page属性都被解释为一个相对的URI.如果它以斜杠开头,那么它就是一个环境相关的路径.
	将根据赋给应用程序的URI的前缀进行解释,如果它不是以斜杠开头,那么就是页面相关的路径,就根据引入这个文件的页面所在的路径进行解释

* 

  <%@ page contentType="text/html;charset=utf-8"%>
	<%
	if(request.getProtocol().compareTo("HTTP/1.0")==0)
		response.setHeader("Pragma","No-cache");
	if(request.getProtocol().compareTo("HTTP/1.1")==0)
		response.setHeader("Cache-Control", "no-cache");
	response.setDateHeader("Expires", 0);
	%>
	作用:主要是为了清除缓存,防止浏览器后退功能,确保网页信息是最新的.为了指示IE浏览器（客户端）不要缓存页面

* ResultSetMetaData

利用ResultSet的getMetaData的方法可以获得ResultSetMeta对象，而ResultSetMetaData存储了ResultSet的MetaData。所谓的MetaData在英文中的解释为“Data about Data”，直译成中文则为“有关数据的数据”或者“描述数据的数据”，实际上就是描述及解释含义的数据。以Result的MetaData为例，ResultSet是以表格的形式存在，所以getMetaData就包括了数据的字段名称、类型以及数目等表格所必须具备的信息。在ResultSetMetaData类中主要有一下几个方法。


ResultSetMetaData rsmd=rs.getMetaData();


1．getColumCount()方法
方法的原型：public int getColumCount() throws SQLException。
方法说明:返回所有字段的数目
参数:无。
返回值:整数值：所有字段的数目。
异常产生:SQLException：数据库发生任何的错误，则会产生一个SQLException对象。


2．getColumName()方法
方法的原型：public String getColumName (int colum) throws SQLException。
方法说明:根据字段的索引值取得字段的名称。
参数:colum：字段的索引值，第一个字段为1，第二个字段为2，依次类推。
返回值:字符串：字段的名称。
异常产生:SQLException：数据库发生任何的错误，则会产生一个SQLException对象。


3．getColumType()方法
方法的原型：public String getColumType (int colum) throws SQLException。
方法说明根据字段的索引值取得字段的类型，返回值的定义在java.sql.Type类。
参数colum：字段的索引值，第一个字段为1，第二个字段为2，依次类推。
返回值字符串：SQL的数据类型定义在java.sql.Type类。
异常产生SQLException：数据库发生任何的错误，则会产生一个SQLException对象。

* jdbc中statement接口的方法

	executeQuery(String sql)  用于执行单个结果
	executeUpdate(String sql) 返回的是int影响的行数 用于执行insert,update,delete,create table,drop table 等ddl语句(数据定义语言),create table 和drop table 等不操作的语句返回的总是0
	execute(String sql)  返回的是boolean是否返回resultset,如果出现多个结果集则要先调用stmt.getMoreResults,再调用getResultSet
	
* Statement和PreparedStatement的区别就不多废话了,直接说PreparedStatement最重要的addbatch()结构的使用.
1:
	(1).建立链接,(打电话拨号 )     
	   Connection    connection =getConnection();


	(2).不自动 Commit (瓜子不是一个一个吃,全部剥开放桌子上,然后一口舔了)
		connection.setAutoCommit(false);   


	(3).预编译SQL语句,只编译一回哦,效率高啊.(发明一个剥瓜子的方法,以后不要总想怎么剥瓜子好.就这样剥.)
		PreparedStatement statement = connection.prepareStatement("INSERT INTO TABLEX VALUES(?, ?)");   


	(4).来一个剥一个,然后放桌子上
		//记录1
		statement.setInt(1, 1);
		statement.setString(2, "Cujo");
		statement.addBatch();   
		//记录2
		statement.setInt(1, 2);
		statement.setString(2, "Fred");
		statement.addBatch();   
		//记录3
		statement.setInt(1, 3);
		statement.setString(2, "Mark");
		statement.addBatch();   
		//批量执行上面3条语句. 一口吞了,很爽
		int [] counts = statement.executeBatch();   
		//Commit it 咽下去,到肚子(DB)里面
		connection.commit();

2.stmt.addBatch("update  TABLE1 set 题目="盛夏话足部保健1"   where id="3407"");
	stmt.addBatch("update  TABLE1 set 题目="夏季预防中暑膳食1" where id="3408"");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("11","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("12","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("13","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("14","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("15","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("16","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("17","12","13","","")");
	stmt.addBatch("INSERT INTO  TABLE1  VALUES("18","12","13","","")");


	int [] updateCounts=stmt.executeBatch();
	cn.commit();

* 反射

		1.获取Class类实例的方法:类名.class,实例名.getClass(),Class.forName(className)
		package net.sxif.facelook.test;
		import java.lang.reflect.Constructor;
		public class TestRef {
		public TestRef(){
			System.out.println(this.getClass().getName()+"被创建");
		}
		
		@SuppressWarnings("unchecked")
		public static Object createBeanByClassName(String className)throws Exception{
			Object obj=null;
			Class clazz=null;
			//创建实例
			try{
				clazz=Class.forName(className);
			}catch(ClassNotFoundException e){
				throw new Exception("这个类"+className+"找不到!"); 
			}
			//如果是借口
			if(clazz.isInterface()){
				throw new Exception("这个是接口不能!");
			}
			Constructor[] cons=clazz.getConstructors();
			//如果没有构造
			if(cons==null||cons.length<1){
				throw new Exception("没有构造函数");
			}
			Constructor defaultCon=cons[0];
			//如果没有无参构造
			if(defaultCon.getParameterTypes().length>0){
				throw new Exception("没有无参构造函数");
			}
			obj=defaultCon.newInstance();
			return obj;
		}
		
		public static void main(String[] args) {
			try{
				TestRef t=(TestRef)createBeanByClassName("net.sxif.facelook.test.TestRef");
			}catch(Exception e){
				e.printStackTrace();
			}
		}


	}


	2. public class Money{
		public int amount;
	}
	//如果需要获取该类的字段
	Money instance=new Money();
	Class<?> c=instance.getClass(); 
	Field[] fields=c.getDeclaredFields();
	for(Field f:fields){}


	for(int j=0;j<pageSize;j++)
				TeamStateModel m=new TeamStateModel();	
				Field[] fs=model.getClass().getDeclaredFields();
				for(int i=0;i<fs.length;i++){
					String name=fs[i].getName();
					name=name.substring(0,1).toUpperCase()+name.substring(1);
					String type=fs[i].getGenericType().toString();
					if(type.equals("class java.lang.String")){
						Method getMethod=model.getClass().getMethod("get"+name);
						Method setMethod=model.getClass().getMethod("set"+name,new Class[]{String.class});
						String value=(String)getMethod.invoke(model);
						String[] singleValue=value.split(",");
						setMethod.invoke(m, new Object[]{singleValue[j].trim()});
					}
				}
				System.out.println("prids:"+m.getPrids());
				System.out.println("stateName:"+m.getStateName());
				System.out.println("region:"+m.getRegion());
				if(HuyaoUtil.isNullOrEmpty(m.getPrids())){
					m.setPrids(UUID.randomUUID().toString());
				}
				if(!HuyaoUtil.isNullOrEmpty(m.getStateName()) && !HuyaoUtil.isNullOrEmpty(m.getRegion())){
					biz.saveOrUpdate(m);
				}
				else{
					return null;
				}
			}


	//获取该类的父类的字段
	Class<?> spc=instance.getSuperClass();
	Field[] fields=spc.getDeclaredFields();
	3. 在泛型类中如何获取T的实例的类型
		//利用反射获取类型
		private Class<T> entityClass;
		@SuppressWarnings("unchecked")
		protected BaseDao(){
			Type type=getClass().getGenericSuperclass();
			Type trueType=((ParameterizedType)type).getActualTypeArguments()[0];
			this.entityClass=(Class<T>)trueType;	
		}


		//按照id获取T
		@SuppressWarnings("unchecked")
		public T queryById(Integer id) {
			Session session=HibernateUtil.getSession();
				T t=null;
			t=(T)session.get(entityClass, id);
			return t;
		}

* 关于访问修饰符 

    public private protected(继承链上的) internal(项目中) protectedinternal (在继承连上或者在项目中)
class  1		0		0				1				0
member 1		1		1				1				1
---------------------------------------------------------------------------
								<default>包内
class 1		0		0				1
member1		1		1				1
---------------------------------------------------------------------------

  
* 使用过滤器验证用户登陆的身份

	1.新建filter包
	2.在filter包中新建AuthenticationFilter类
		import javax.servlet.Filter;
	里面的doFilter方法
		public void doFilter(ServletRequest req, ServletResponse res,
		FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request=(HttpServletRequest)req;
		HttpServletResponse response=(HttpServletResponse)res;
		if(request.getSession().getAttribute(AllKeys.CURRENT_USER_SESSION_KEY)==null){
			String uri=request.getRequestURI();        //获取地址包括项目名的地址如 　/houserent/admin/index2.jsp
			StringBuffer url=request.getRequestURL();  //获取全地址　　http://localhost:8080/houserent/admin/index2.jsp
			request.setAttribute("returnUrl", uri);
			request.getRequestDispatcher("/login.jsp").forward(request, response);
			return;
		}
		else{
			chain.doFilter(req,res);
		}
	}
	3.安装过滤器,admin下面的页面必须通过验证才可以进入,不然直接跳转到login页面
	<web-app>
  		<filter>
  			<filter-name>AuthenticationFilter</filter-name>
  			<filter-class>net.sxif.houserent.filter.AuthenticationFilter</filter-class>
  		</filter>
  
  		<filter-mapping>
  			<filter-name>AuthenticationFilter</filter-name>
  			<url-pattern>/admin/ *</url-pattern>
  		</filter-mapping>
		</web-app>
	4.login.jsp页面嵌入returnUrl地址
		<input type="hidden" name="returnUrl" value="${requestScope.returnUrl }"/>
	5.在servlet/login中如果返回url地址,则转到index页面,如果非空则跳转到returnUrl页面
		if(u!=null){
			request.getSession().setAttribute(AllKeys.CURRENT_USER_SESSION_KEY, u);
			request.setAttribute("hs", hs);
			if(!StringUtil.isNulOrEmpty(returnUrl)&&!"null".equals(returnUrl)){
				responseUrl=returnUrl.substring(request.getContextPath().length());
				//getContextPath()指的是获取项目名的地址 如 request.getContextPath()指的是  /houserent	
			}
			else{
				responseUrl="/admin/index.jsp";
			}
		}else
		{
			request.setAttribute("erroMessage", "用户名或者密码错误!");
			responseUrl="/login.jsp";
		}
		request.getRequestDispatcher(responseUrl).forward(request, response);

* 如何获取Session对象的方法

		Configuration config = new Configuration().configure();
		SessionFactory factory = config.buildSessionFactory();
		Session s = factory.openSession();
		UserInfo user = (UserInfo) s.get(UserInfo.class, id); //id指的是获取的UserInfo的主键,如果该主键不存在会报错
		s.close();
		return user;

* 关于获取总的页数

	1.Math的方法Ceil,这里返回的是124
	double a=123.3;
	System.out.println(Math.ceil(a));
	int totalPages=(int)Math.ceil(1.0*count/pageSize); //注意这里需要将count或者pageSize转化成double类型才可以,所以要*1.0
	2.count总的新闻条数,pageSize每页显示的数量
	totalPages=(count%pageSize==0)?(count/pageSize):(count/pageSize+1);

* 集合操作的工具类 Collections extends Object

		1.Collections的方法
			static void reverse(List l):反转[-1,1,3,9,-4]-->[-4,1,3,9,-1]
			static void shuffle(List l):随机
			static void sort(List l):正排序
			static void sort(List l,Comparator c):根据比较器,来排序
			static void rotate(List l,int distance):移动旋转
			static void swap(List l,int i,int j):交换i位置的和j位置的,从0开始算
			static Object max(Collection c)
			static Object min(Collection c)
			static void fill(List l,Object obj):把所有的元素都替换成obj
			static int frequency(Collection c,Object obj):obj出现的次数
			static boolean replaceAll(List l,Object oldVal,Object newVal):把所有的旧的值替换成新的值


		2.sort(List l,Comparator c) 用法
		Collections.sort(a, new Comparator(){
					public int compare(Object a,Object b)
				{
					return (Integer)b-(Integer)a;//return a-b表示升序,b-a表示降序
				}


		});


		3.rotate(List l,int distance) 用法
			int distance=1 表示向右边移动一个位置
			[2, 1, 3, -1, 6]-->[6,2,1,3,-1]
			int distance=-1 表示向左移动一个位置
			[2, 1, 3, -1, 6]-->[1,3,-1,6,2]
			
		4.java集合框架
			Collection 接口存储一组不唯一,无序的对象
			list接口存储一组不唯一,有序的对象
			Set接口存储一组唯一,无序的对象

* 关于Map,HashMap

	1.Map接口的几个方法
 		Object put(Object key,Object val)
 		Object get(Objecty key) 
 		Object remove(Object key)
 		int size()
 		Set keySet()
 		Collection values()
  		boolean containsKey(Object key)
	2.如何遍历
		Iterator it=dogs.iterator();
		while(it.hasNext()){
			Dog d=(Dog)it.next();
		}
	3.几个问题
		1.HashMap<String,String> m=new HashMap<String,String>();
			m.put("first","beijing" );
			m.put("first","shanghai");
			System.out.println(m.get("first"));
			输出的是 shanghai
		2.HashMap<String,String> m=new HashMap<String,String>();
			m.put(null,"beijing" );
			m.put(null,"shanghai");
			System.out.println(m.get(null));
			输出是 shanghai
			hashmap中可以将null作为键或者值加入到map中

* LinkedList

	void addFirst(Object o)
	void addLast(Object o)
	Object getFirst()
	Objcet getLast()
	Object removeFirst()
	Object removeLast()
	添加或者删除元素的时候linkedlist表现比arraylist好

* 枚举 

	1.基本的枚举用法
		public enum Gender{
			Male,Female;
		}


	2.实现接口的枚举
		1)枚举
			public enum Gender {
				male("男"),female("女");
				private String hyName;
				private Gender(String name){
					this.hyName=name;
				}
				public String getName(){
					return this.hyName;
				}
			}
		2)Test类
			public class Test {
			public static void main(String[] args) {
				Gender g=Gender.male;
				System.out.println(g.getName());
				}
			}
			
	3.包含抽象方法的枚举类
		1)枚举类
			public enum Caculator {
				Plus{
					public double eval(double a,double b){
						return a+b;
					}
				},Minus{
					public double eval(double a,double b){
						return a-b;
					}
				};
				public abstract double eval(double a,double b);
			}
		2)Test类
			public class Test {
				public static void main(String[] args) {
					System.out.println(Caculator.Minus.eval(3,2));
				}


			}

* 匿名内部类

	1.接口
	public interface Product {
		public String getPrice();
	}


	2.Test类
	public class Test {
		public static void test(Product p){
			System.out.println("我今天买了一个包价格:"+p.getPrice());
		}
		public static void main(String[] args) {
			test(new Product(){public String getPrice(){return "二十五块!";}});
		}
	}
	3.作用
	可以简化代码,在需要product实例的时候在new Product()后面加上一个匿名内部类

* 关于声明

	声明的时候不可以使用request,response等因为request等一段代码是一个类的一个方法,声明则是重新申明一个方法或者变量
	1.导入的包为:
		<%@ page import="java.text.*" %>
	2.声明主体为:
		<%!
			String formatDate(Date d){
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
				return sdf.format(d);
			}
 		%>
	3.调用声明:
 		<%=formatDate(h.getDate()) %>

* 关于随机生成验证码

	1.生成图片在servlet/Image中
		public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
	
		response.setContentType("image/jpeg");
		BufferedImage img = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB); //第一个参数是宽,第二个参数是高
		Graphics g = img.getGraphics();
		g.setColor(Color.lightGray);//设置背景色
		g.fillRect(0, 0, 80, 20);//设置内容在图片中的位置,参数(int x,int y,int width,int height)
		g.setFont(new Font("Arial", 0, 20));//设置字体
		g.setColor(new Color(0, 64, 0));//设置字体颜色
		String code = StringUtil.randomString();// "" + (new java.util.Random().nextInt(9000) + 1000);
		request.getSession().setAttribute("validationCode", code);
		g.drawString(code, 10, 20); //后面两个参数分别为startx,starty 开始的位置
		ImageIO.write(img, "JPG", response.getOutputStream());
 		//Image是一个抽象列，BufferedImage是Image的实现。 Image和BufferedImage的主要作用就是将一副图片加载到内存中。 
	}
	2.在包中写一个随即生成字符串的类
		package net.szsx.jsp_10.util;
		import java.util.Random;
		public class StringUtil {
		private static final String PATTERN = "123ABCxE";
		private static final int DEFAULT_LEN = 4;
	
		private static Random random = null;
		static{
			random = new Random();
		}
	
		public static String randomString(){
		StringBuilder s = new StringBuilder();
		for(int i = 0; i < DEFAULT_LEN; i++){
			s.append(PATTERN.charAt(random.nextInt(PATTERN.length())));
			}
			return s.toString();
			}
		}
		//random.nextInt(1000) 表示从0-1000中随即产生一个数字0<=r<1000
	3.jsp页面中
		<img src="Image" title="" alt="" οnclick="this.src='servlet/Image?i=Math.random()'"/>
		//按键的时候图片改变,为了防止服务器缓存,后面加一个参数
	4.注意点:验证验证码的时候是在表单提交了以后在服务器端验证输入是否正确不是在页面验证

* 设置java虚拟机内存解决总是跳出javaw.exe占用8080端口问题

	打开eclipse,选择Window--Preferences...在对话框左边的树上双击Java，再双击Installed JREs，在右边选择前面有对勾的JRE，再单击右边的“Edit”按钮，出现一个 	Edit JRE 的对话框，在其中的Default VM Arguments: 框中输入 -Xms128m -Xmx512m ,这样设置Java拟虚机内存使用最小是128M，最大是512M，再单击“OK”关闭 Edit 	JRE 对话框，再单击“OK”关闭 Preferences对话框，Eclipse一下子就运行快了起来，呵~ 或者是可以在eclipse.ini文件中将默认设置改为-vmargs -Xms128M -Xmx512M 	-XX:PermSize=64M -XX:MaxPermSize=128M或者更大，这要看你自己机器的内存配置而定，如果这样解决不了就右击eclipse快捷方式，在属性---快捷方式标签下---目标	中输入D:\eclipse\eclipse.exe -clean -vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M,其中D:\eclipse\eclipse.exe是eclipse的位置，就可以	了 

* 关于用户登出的action

@SuppressWarnings("serial")
public class LoginOutAction extends ActionSupport {


	public String execute(){
		ActionContext ac=ActionContext.getContext();
		ac.getSession().clear();
		return SUCCESS;
	}
}

* 关于tag<s:..>struts-tag的应用

	1.迭代输出
	 <body>
   	<table border="1px">
   	<tr>
   		<td>id</td>
   		<td>name</td>
   		<td>price</td>
   	</tr>
   		<s:iterator var="p" value="ps">
   			<tr>
   				<td><s:property value="#p.id"/></td>
   				<td><s:property value="#p.name"/></td>
   				<td><s:property value="#p.price"/></td>
   			</tr>
   		</s:iterator>
   	</table>
  	</body>
	2.迭代输出还可以直接写属性比如
	<table border="1">
   		<s:iterator value="students" id="abc">
   			<tr>
   				<td><s:property value="no"></s:property></td>
   				<td><s:property value="name"></s:property></td>
   				<td><s:property value="telephone"></s:property></td>
   			</tr>
   		</s:iterator>
   	</table>
	 

*读取配置文件

	public static void main(String[] args) {  
            Properties prop=new Properties();  
            try {  
                prop.load(Test.class.getResourceAsStream("/abc.properties"));  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            String content=prop.getProperty("1");  
            System.out.println(content);  
        } 

*四舍五入

private double round(double d, int decimalNum) {  
    if(decimalNum>0){  
        String num="";  
        for(int i=0;i<decimalNum;i++){  
            num+="0";  
        }  
        DecimalFormat df=new DecimalFormat("0."+num);  
        String s=df.format(d);  
        return Double.parseDouble(s);  
    }else{  
        //如果是取整数的decimalFormat会导致.5的时候不四舍五入.比如9418.5会被舍成9418所以用Bigdecimal来实现整数四舍五入  
        return new BigDecimal(d).setScale(decimalNum, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
      
}  

*关于包装类

1.Integer number=new Integer("1fds");//这里要是可以转化为int类型否则抛出java.lang.NumberFormatException  
Integer number2=new Integer(12);  
  
Integer几个常用的方法:  
.compareTo(Integer anotherNumber) 返回 int ;//如果和对方相等 返回0 小于返回-1 大于返回1  
.equals   
.intValue(); //以int的类型返回Integer对象  
.shortValue();  
.valueOf(String str);  //返回 Integer 把String转化为Integer对象  
.parseInt(String str); //返回 int   
.String str=Integer.toString(123);  
.String str2=Integer.toBinaryString(123);   //二进制  
.String str3=Integer.toHexString(123);  //十六进制  
.String str4=Integer.toOctalString(123);    //八进制  
.Integer.MAX_VALUE;  
.Integer.MIN_VALUE;  
.Integer.SIZE:                          //几个常量,size表示二进制位数32  
2.Double
3.Boolean  
4.Character
5.Number是所有以上的父类

*产生随机数

1. Math方法
//0--x  
(int)(Math.random()*x)  
//1--x  
1+(int)(Math.random()*x)  
x--y  
//先产生x到y之间的随机数再加上x  
x+(int)(Math.random()*(y+1-x))  

2.Random方法
[java] view plaincopy
(1).  
Random r=new Random();  
for(int i=0;i<100;i++){  
    System.out.println(r.nextInt(100));//[0,100)  
}  
  
(2).  
如果想得到[0,100]  
r.nextInt(101)即可  
  
(3).  
如果想得到[-3,8)  
r.nextInt(11)-3;  
  
(4).  
如果想得到[0,1.0)之间的小数  
r.nextDouble();  
  
(5).  
[0,5.0)  
r.nextDouble()*5;  
  
(6).  
[1,2.5)  
r.nextDouble()*1.5+1;  
  
(7).构造里面的种子如:Random r=new Random(20);的作用  
    Random r=new Random(50);  
    for(int i=0;i<10;i++){  
        System.out.print(r.nextInt(10));  
    }  
    System.out.println();  
    Random r2=new Random(150);  
    for(int i=0;i<10;i++){  
        System.out.print(r2.nextInt(10));  
    }  
    //如果种子相同的话那么产生的两个随机数都相同,除非种子不一样,产生的随机数才不一样  

3.产生随机字母
[java] view plaincopy
public static void main(String[] args) {  
        Random r=new Random();  
        char[] chars=new char[26];  
          
        for(int i=0;i<chars.length;i++){  
            char c=(char)(r.nextInt(26)+'A'); //小写字母就是'a'  
            chars[i]=c;  
        }  
        Arrays.sort(chars);  
        StringBuffer sb=new StringBuffer(new String(chars));  
        sb.reverse();  
        System.out.println(sb.toString());  
    }  

*不足补0

public static void main(String[] args) throws Exception {  
    System.out.println(addZero(89,3));  
}  
public static String addZero(int num,int len){  
    StringBuffer sb=new StringBuffer();  
    sb.append(num);  
    while(sb.length()<len){  
        sb.insert(0, "0");  
    }  
    return sb.toString();  
}