ruyi574812039
- 浏览: 43831 次
- 性别:
-
最新评论
收藏列表
- 全部 [20]
- struts2 [1]
- 编码 [1]
- 笔记 [1]
- 范式 [1]
- 总结 [1]
- struts2文件下载 [1]
- java多态 [1]
- js编码 [1]
- oracle创建自增表空间 [1]
- 删除重复记录sql语句(任意保留一条) [1]
- java io总结 [1]
- java抽象类和final关键字 [1]
- java基础内存分析总结 [1]
- struts2学习记录之ognl表达式 [1]
- java设计模式总结 [1]
- java中 ==和equals()区别 [1]
- 2014/05/08开始总结 [1]
- svn，svn服务器，svn服务器安装 [1]
- java中xml处理 [1]
- 批量insert [1]
| 标题 | 标签 | 来源 | |
| java大量insert数据 | 批量insert | ||
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Calendar;
public class inserttest {
public static void test1(Connection iConn) throws SQLException{
Statement statement = iConn.createStatement();
String str_i;
for (int i=1;i<100000;i++) {
str_i=new Integer(i).toString();
String vSQL = "insert into t_employee(id,name,birthday,address,email,mobilephone,telephone,identity_card,weight,height)"
+ " values(seq_t_employee_id.nextval,'张三"+str_i+ "',sysdate - "+str_i+","
+ "'上海市南京东路11号203室"+str_i+"',"
+ "'abcd"+str_i+"@gmail.com',"
+ "'138'|| trim(to_char("+str_i+", '00000000')),"
+ "'021-'|| trim(to_char("+str_i+", '00000000')),"
+ "'3504561980' || trim(to_char("+str_i+", '00000000')),"
+ "64,1.72)";
//System.out.println(vSQL);
statement.executeUpdate(vSQL);
}
}
public static void test2(Connection iConn) throws SQLException{
String vSQL = "insert into t_employee(id,name,birthday,address,email,mobilephone,telephone,identity_card,weight,height)"
+ "values(seq_t_employee_id.nextval,'张三'||?,sysdate - ?,"
+ "'上海市南京东路11号203室'||?,"
+ "'abcd'||?||'@gmail.com',"
+ "'138'|| trim(to_char(?, '00000000')),"
+ "'021-'|| trim(to_char(?, '00000000')),"
+ "'3504561980' || trim(to_char(?, '00000000')),"
+ "64,1.72)";
PreparedStatement ps = iConn.prepareStatement(vSQL);
String str_i;
for (int i=1;i<100000;i++) {
str_i=new Integer(i).toString();
ps.setString(1, str_i);
ps.setString(2, str_i);
ps.setString(3, str_i);
ps.setString(4, str_i);
ps.setInt(5, i);
ps.setInt(6, i);
ps.setInt(7, i);
ps.executeUpdate();
}
}
public static void test3(Connection iConn) throws SQLException{
String vSQL = "insert into t_employee(id,name,birthday,address,email,mobilephone,telephone,identity_card,weight,height)"
+ " values(seq_t_employee_id.nextval,'张三'||?,sysdate - ?,"
+ "'上海市南京东路11号203室'||?,"
+ "'abcd'||?||'@gmail.com',"
+ "'138'|| trim(to_char(?, '00000000')),"
+ "'021-'|| trim(to_char(?, '00000000')),"
+ "'3504561980' || trim(to_char(?, '00000000')),"
+ "64,1.72)";
PreparedStatement ps = iConn.prepareStatement(vSQL);
String str_i;
for (int i=1;i<30000;i++) {
System.out.println(i);
str_i=new Integer(i).toString();
ps.setString(1, str_i);
ps.setString(2, str_i);
ps.setString(3, str_i);
ps.setString(4, str_i);
ps.setInt(5, i);
ps.setInt(6, i);
ps.setInt(7, i);
ps.addBatch();
//ps.executeUpdate();
}
ps.executeBatch();
}
public static void main(String[] args) throws ClassNotFoundException,SQLException {
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@192.168.0.146:1521:orcl", "zfjdgl", "1234");
//Connection conn = DriverManager.getConnection("jdbc:oracle:oci:@192.168.0.146:1521:orcl", "zfjdgl", "1234");
java.util.Date d1=Calendar.getInstance().getTime();
conn.setAutoCommit(false);
//1万记录：
//使用thin方式测试结果：
//test1(conn); //16766ms
//test2(conn); //5859ms
//test3(conn); // 359ms
//使用oci方式测试结果：
//test1(conn);//16516ms
//test2(conn);//5625ms
//test3(conn); //328s
//10万
//使用thin方式测试结果：
//test1(conn); //166907ms
//test2(conn);//53610ms
test3(conn);//10万记录时结果错误！只存储了34463记录。所以实际使用需要考虑一定记录数进行提交。
//3万记录时：用时1203ms
//使用oci方式测试结果：
// test1(conn);//181594ms
//test2(conn);//57641ms
//test3(conn);//3万记录时：1062ms（oci方式效率高于thin,oci方式需要安装客户端，一般web开发都使用thin方式）
//总结：1,2,3 3种方式。1,2种使用oci方式效率未得到提高。只有第三种oci方式效率高于thin方式。
//考虑实际情况，一般不使用oci方式，都使用thin方式，不需要安装客户端。
//批量insert时，效率3>2>1
//注意：使用addBatch时，有最大限制，要根据实际情况选择一定记录数进行提交。
java.util.Date d2= Calendar.getInstance().getTime();
System.out.println("es:"+(d2.getTime()-d1.getTime())+"ms");
conn.commit();
conn.close();
}
}
|
|||
| js处理url传递参数编码 | js编码 | ||
js编码：var url = ctxpath+'/jsps/msa/add.jsp?content='+encodeURIComponent(encodeURIComponent(temp_t));
jsp页面解码：
<input id="t_content" value="<%= java.net.URLDecoder.decode(request.getParameter("content"),"UTF-8")%>" type="hidden">
地址：http://www.cnblogs.com/goody9807/archive/2009/01/16/1376913.html
|
|||
| java编码 | 编码 | ||
Java开发中，常常会遇到乱码的问题，一旦遇到这种问题，常常就很扯蛋，每个人都不愿意承认是自己的代码有问题。其实编码问题并没有那么神秘，那么不可捉摸，搞清Java的编码本质过程就真相大白了。（见相册图片）
其实，编码问题存在两个方面：JVM之内和JVM之外。
1、Java文件编译后形成class
这里Java文件的编码可能有多种多样，但Java编译器会自动将这些编码按照Java文件的编码格式正确读取后产生class文件，这里的class文件编码是Unicode编码（具体说是UTF-16编码）。
因此，在Java代码中定义一个字符串：
String s="汉字";
不管在编译前java文件使用何种编码，在编译后成class后，他们都是一样的----Unicode编码表示。
2、JVM中的编码
JVM加载class文件读取时候使用Unicode编码方式正确读取class文件，那么原来定义的String s="汉字";在内存中的表现形式是Unicode编码。
当调用String.getBytes()的时候，其实已经为乱码买下了祸根。因为此方法使用平台默认的字符集来获取字符串对应的字节数组。在WindowsXP中文版中，使用的默认编码是GBK，不信运行下：
[java]
public class Test {
public static void main(String[] args) {
System.out.println("当前JRE：" + System.getProperty("java.version"));
System.out.println("当前JVM的默认字符集：" + Charset.defaultCharset());
}
}
public class Test {
public static void main(String[] args) {
System.out.println("当前JRE：" + System.getProperty("java.version"));
System.out.println("当前JVM的默认字符集：" + Charset.defaultCharset());
}
}
运行结果如下：
[plain]
当前JRE：1.6.0_10-rc2
当前JVM的默认字符集：GBK
当前JRE：1.6.0_10-rc2
当前JVM的默认字符集：GBK
当不同的系统、数据库经过多次编码后，如果对其中的原理不理解，就容易导致乱码。因此，在一个系统中，有必要对字符串的编码做一个统一，这个统一模糊点说，就是对外统一。比如方法字符串参数，IO流，在中文系统中，可以统一使用GBK、GB13080、UTF-8、UTF-16等等都可以，只是要选择有些更大字符集，以保证任何可能用到的字符都可以正常显示，避免乱码的问题。（假设对所有的文件都用ASCII码）那么就无法实现双向转换了。
要特别注意的是，UTF-8并非能容纳了所有的中文字符集编码，因此，在特殊情况下，UTF-8转GB18030可能会出现乱码，然而一群傻B常常在做中文系统喜欢用UTF-8编码而不说不出个所以然出来！最傻B的是，一个系统多个人做，源代码文件有的人用GBK编码，有人用UTF-8，还有人用GB18030。FK，都是中国人，也不是外包项目，用什么UTF-8啊，神经！源代码统统都用GBK18030就OK了，免得ANT脚本编译时候提示不可认的字符编码。
因此，对于中文系统来说，最好选择GBK或GB18030编码（其实GBK是GB18030的子集），以便最大限度的避免乱码现象。
3、内存中字符串的编码
内存中的字符串不仅仅局限于从class代码中直接加载而来的字符串，还有一些字符串是从文本文件中读取的，还有的是通过数据库读取的，还有可能是从字节数组构建的，然而他们基本上都不是Unicode编码的，原因很简单，存储优化。
因此就需要处理各种各样的编码问题，在处理之前，必须明确“源”的编码，然后用指定的编码方式正确读取到内存中。如果是一个方法的参数，实际上必须明确该字符串参数的编码，因为这个参数可能是另外一个日文系统传递过来的。当明确了字符串编码时候，就可以按照要求正确处理字符串，以避免乱码。
在对字符串进行解码编码的时候，应该调用下面的方法：
[java]
getBytes(String charsetName)
String(byte[] bytes, String charsetName)
getBytes(String charsetName)
String(byte[] bytes, String charsetName)而不要使用那些不带字符集名称的方法签名，通过上面两个方法，可以对内存中的字符进行重新编码
|
|||
| 常用设置记录 | 笔记 | ||
1.myecplise ALT+/自动提示设置： WIndows->Preferences->General->keys 将"Command"列中的"Word Completion"的快捷键设置为"CTRL+ALT+/",再将"Connand"列下的"Content Assist"的快捷键改成"ALT+/"点提交便可 |
|||
| telewave总结 | java中xml处理 | ||
替换xml串的值:
xml:原xml
endxml:替换后的xml
builder = factory.newDocumentBuilder();
Document doc = builder
.parse(new InputSource(new StringReader(xml)));
Element root = doc.getDocumentElement();
NodeList nl = root.getElementsByTagName("LoginId");
Element e = (Element) nl.item(0);
e.setTextContent("newlongid");//CS调用传递的用户名
NodeList n2 = root.getElementsByTagName("UserId");
Element e2 = (Element) n2.item(0);
e2.setTextContent("newuserid");//userid
StringWriter strWtr = new StringWriter();
StreamResult result = new StreamResult(strWtr);
Transformer transformer = TransformerFactory.newInstance()
.newTransformer();
transformer.transform(new DOMSource(doc), result);
String endxml = strWtr.toString();
|
|||
| struts2文件下载 | struts2文件下载 | ||
strut.xml
<action name="download" class="com.telewave.policesystemweb.szrk.DownloadAction" >
<result name="success" type="stream">
<!-- 下载文件类型定义 -->
<param name="contentType">application/octet-stream</param>
<!-- 下载文件输出流定义 -->
<param name="inputName">inputStream</param>
<!-- 下载文件处理方式 -->
<param name="contentDisposition">attachment;filename="${downfilename}"</param>
<!-- 下载文件的缓冲大小 -->
<param name="bufferSize">4096</param>
</result>
</action>
package com.telewave.policesystemweb.szrk;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.sun.xml.messaging.saaj.packaging.mime.internet.MimeUtility;
/**
* 文件下载
* @author Luxh
*/
public class DownloadAction extends ActionSupport {
private static final long serialVersionUID = -3036349171314867490L;
//文件名
private String fileName;
private String downfilename;
public String getFileName() {
return fileName;
}
public void setFileName(String fileName) throws UnsupportedEncodingException {
//用UTF-8重新编码文件名,解决中文乱码
this.fileName = fileName;
}
public String getDownfilename() {
return downfilename;
}
public void setDownfilename(String downfilename) {
this.downfilename = downfilename;
}
public InputStream getInputStream() throws UnsupportedEncodingException, FileNotFoundException{
int i = fileName.lastIndexOf("\\");
String str = fileName.substring(i+1);//截取文件名
HttpServletRequest request = ServletActionContext.getRequest();
String userAgent = request.getHeader("User-Agent");
userAgent = userAgent.toLowerCase();
String filernd = "";
//针对不同浏览器，进行不同的编码，目前支持火狐、谷歌、ie
if (null != userAgent){
if (-1 != userAgent.indexOf("firefox")) {//Firefox
filernd = "=?UTF-8?B?" + (new String(org.apache.commons.codec.binary.Base64.encodeBase64(str.getBytes("UTF-8"))))+ "?=";
}else if (-1 != userAgent.indexOf("chrome")) {//Chrome
filernd = new String(str.getBytes(), "ISO8859-1");
} else {//IE7+
filernd = java.net.URLEncoder.encode(str, "UTF-8");
filernd = StringUtils.replace(filernd, "+", "%20");//替换空格
}
} else {
filernd = str;
}
setDownfilename(filernd);
// IE浏览器可以用以下方式，不通过xml文件<param name="contentDisposition">attachment;filename="${downfilename}"</param>，但是非ie不支持以下这种方式，
// 只能通过xml文件方式读取action中的downfilename的值
// ServletActionContext.getResponse().setHeader(
// "Content-Disposition",
// "attachment;fileName="+filernd);
// + java.net.URLEncoder.encode(str, "ISO-8859-1"));
InputStream inputStream = new FileInputStream(fileName);
return inputStream;
}
@Override
public String execute() throws Exception {
return SUCCESS;
}
}
|
|||
| 数据库设计三范式 | 范式 | http://m.baidu.com/from=1000953b/bd_page_type=1/ssid=0/uid=0/pu=usm%400%2Csz%401320_1002%2Cta%40iphone_2_4.3_2_5.2/baiduid=1E5915CF5EB6858F0CE8C422A852F062/w=0_10_%E6%95%B0%E6%8D%AE%E5%BA%93%E8%AE%BE%E8%AE%A1%E4%B8%89%E5%A4%A7%E8%8C%83%E5%BC%8F/t=iphone/l=3/tc?ref=www_iphone&lid=7971625144864654207&order=1&vit=osres&tj=www_normal_1_0_10&m=8&srd=1&cltj=cloud_title&dict=30&sec=39680&di=ffe2b512fbd25130&bdenc=1&nsrc=IlPT2AEptyoA_yixCFOxXnANedT62v3IEQGG_ytK1DK6mlrte4viZQRAXjb6Kn_HGkewdoS4csxNaT0u3mRU7xJ_rrdmpWkbznuPd48hgK3AGRYZeQplNNbWVS7 | |
http://m.baidu.com/from=1000953b/bd_page_type=1/ssid=0/uid=0/pu=usm%400%2Csz%401320_1002%2Cta%40iphone_2_4.3_2_5.2/baiduid=1E5915CF5EB6858F0CE8C422A852F062/w=0_10_%E6%95%B0%E6%8D%AE%E5%BA%93%E8%AE%BE%E8%AE%A1%E4%B8%89%E5%A4%A7%E8%8C%83%E5%BC%8F/t=iphone/l=3/tc?ref=www_iphone&lid=7971625144864654207&order=1&vit=osres&tj=www_normal_1_0_10&m=8&srd=1&cltj=cloud_title&dict=30&sec=39680&di=ffe2b512fbd25130&bdenc=1&nsrc=IlPT2AEptyoA_yixCFOxXnANedT62v3IEQGG_ytK1DK6mlrte4viZQRAXjb6Kn_HGkewdoS4csxNaT0u3mRU7xJ_rrdmpWkbznuPd48hgK3AGRYZeQplNNbWVS7 |
|||
| 安装svn服务器小结 | svn，svn服务器，svn服务器安装 | ||
windows安装svn服务器小结： 1. 创建库目录： svnadmin create E:\svnserver\svnrepo 2. 启动服务器（有很多种方式）： C:\Users\zhangruyi>svnserve -d -r E:\svnserver\svnrepo 3.分配用户： 配置E:\svnserver\svnrepo\conf下的svnserve.conf文件和passwd文件。 svnserve.conf常用配置： password-db = passwd 取消注释，注意：之前不能用空格 anon-access = read 表示匿名访问 auth-access = write 表示匿名访问 passwd 配置： 用户名=密码 新加：zhangruyi=zhangruyi |
|||
| 2014/05/08开始总结 | 2014/05/08开始总结 | ||
1.
switch(a){
case 1:
case 2:
default:
}用法：
// default只可以有一个.
// 1.首先匹配a，若匹配上，直接从a处开始顺序往下执行，直到遇到break才退出。若没有break,直到全部执行完毕。
// 2.若匹配不上，直接找default开始顺序往下执行，直到遇到break才退出，若没有，全部执行完毕。
//总结一句话：匹配上的只是一个入口，退出与否关键在于break;
2.
this. : 当前对象
super. : 父类对象
this(1,2) :在当前类中的一个构造方法中，调用参数相匹配的另一个构造方法
super(1) : 调用父类中参数相匹配的构造方法
//注：super()只能写在子类构造方法的第一行。
3.
final 修饰方法不能被重写
修饰类不能被继承
修饰变量的值是不能被改变（常量）
private 修饰的方法不能被子类所继承
4.
一个类中两个方法。
方法1锁定后，虽然方法1锁定了当前调用该方法1的对象，但是另一个线程(会拿到被方法1锁定的对象）去访问其他未加锁的方法2。
若都加锁了，则一个线程访问方法1时，其他线程不会访问方法2.
5.
必须是synchronized的方法里才可以用this.wait()
当篮子满了，生产者wait,this.notify()叫醒消费者。
当篮子空了，消费者wait,this.notify()叫醒生产者
notify叫醒一个正在我这个对象上等待的线程
this.wait();只有synchronized的当前对象才可以wait；锁定在当前对象上的线程停止住。
只有锁住这个对象才可以wait；
wait什么时候醒过来？
wait后，该对象的锁不在属于我。
而sleep睡着了也会拿着锁！
this.notify(),叫醒当前在对象当中wait的线程。
6.case when then end用法：
select id1,id2,id3,
case when
to_number(id3) > (case when to_number(id1)>to_number(id2) then id1 else id2 end ) then id3
else (case when to_number(id1)>to_number(id2) then id1 else id2 end )
end maxval
from testcase
7.
left join on ,right join on ,(+)用法：
select count(*) from za_zfba_jcxx_rk_wfxyrxx t left join ga_jcxx_rk_syrk g on t.gmsfhm = g.gmsfhm 等价于
select count(*) from za_zfba_jcxx_rk_wfxyrxx t, ga_jcxx_rk_syrk g where t.gmsfhm = g.gmsfhm(+)
select count(1) from ga_jcxx_rk_syrk t left join za_zfba_jcxx_rk_wfxyrxx g on t.gmsfhm = g.gmsfhm 等价于
select count(*) from za_zfba_jcxx_rk_wfxyrxx t, ga_jcxx_rk_syrk g where t.gmsfhm(+) = g.gmsfhm
注：当副表关联字段有重复记录时，并非是主表的全记录，而会关联出重复记录！
8.
oracle中的rownum不可以用于 >
若想查询> 需要借助临时表：
select * from (select tt.gmsfhm,tt.wfxyrxh,rownum rownumt from za_zfba_jcxx_rk_wfxyrxx tt )t where rownumt>5
db2中，可以直接用rownumber() over()
9.
Map,Set,List遍历总结：
Map<String,String> mp = new HashMap<String,String>();
mp.put("1", "a");
mp.put("2", "b");
mp.put("3", "c");
//4种遍历map的方式
//1.遍历key，查value
for(String s: mp.keySet()){
System.out.println("key:"+s+",value:"+mp.get(s));
}
//2.只遍历value
for(String s:mp.values()){
System.out.println("value:"+s);
}
//3.利用evtrySet() Map.Entry是一个接口
for(Map.Entry<String, String> s: mp.entrySet()){
System.out.println("key:"+s.getKey()+",value:"+s.getValue());
}
//4.Map.Entry是一个接口，mp.entrySet()返回该类型的
Iterator<Map.Entry<String, String>> mi = mp.entrySet().iterator();
while(mi.hasNext()){
Map.Entry<String, String> mm = mi.next();
System.out.println("key:"+mm.getKey()+",value:"+mm.getValue());
}
//4种遍历List方式
//--------------------------
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
//1.遍历
for(String s: list){
System.out.println("list1:"+s);
}
//2.
Iterator<String> ilist = list.iterator();
while(ilist.hasNext()){
System.out.println("list2:"+ilist.next());
}
//3.由于list是有序的，所以可以get
for(int i=0;i<list.size();i++){
System.out.println("list3:"+list.get(i));
}
//4.诡异的遍历,貌似和2相同
for(Iterator<String> ilist2 = list.iterator();ilist2.hasNext();){
System.out.println("list4:"+ilist2.next());
}
//3种遍历Set方式
//--------------------------
Set<String> set = new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
//1.遍历
for(String s:set){
System.out.println("set1:"+s);
}
//2
Iterator<String> iset = set.iterator();
while(iset.hasNext()){
System.out.println("set2:"+iset.next());
}
//3
for(Iterator<String> iiset = set.iterator();iiset.hasNext();){
System.out.println("set3:"+iiset.next());
}
10.
static语句块在类加载的时候执行，且只执行一次。
做如下验证：
public class HelloWord {
public static int a = 1;
static {
System.out.println("静态块被初始化!");
}
}
public class T {
public static void main(String[] args) {
// 此时用到了HelloWord类，并没有new对象，将HelloWord.class加载到内存
// 类加载的时候初始化static语句块，且只初始化一次。
System.out.println(HelloWord.a);
// 输出结果：
// 静态块被初始化!
// 1
}
}
|
|||
| java中 ==和equals()区别 | java中 ==和equals()区别 | ||
"=="和"!="比较的是"栈"中的内容是否相同 (基础数据类型存在"栈"中，引用数据类型的引用存在"栈"中) 所以"=="对于基本数据类型比较的是值是否相同，对于引用数据类型比较的是引用的地址是否相同 而equals()比较的是"堆"中的内容: equals()只适用于引用数据类型，且比较的是"堆"中的对象是否是同一个对象 String中的equels()方法比较的是"堆"中的对象的值是否相同，是因为String重写了equals()方法。 |
|||
| java设计模式总结 | java设计模式总结 | ||
工厂模式：所有的工厂模式都是用来生产对象的。 (1)静态工厂方法，产生对象，构造方法为private (2)简单工厂 (3)抽象工厂方法（重点），生产一套产品 例子： 游戏当中所有的场景对象定义为一个接口GameFactory()。(所有场景:坦克，子弹，等等对象） 有一套OvalFactory()游戏场景实现了GameFactory() GameFactory() gf = new OvalFactory();//圆形的 则gf调用了一套圆形的游戏场景。 有一套FxFactory()游戏场景实现了GameFactory() GameFactory() gf = new OvalFactory();//方形的 则gf调用了一套方形的游戏场景。 （例子：qq更换一套皮肤，新增一套皮肤，更换一个工厂即可） |
|||
| struts2学习记录之OGNL表达式 | struts2学习记录之ognl表达式 | ||
<ol>
<li>访问值栈中的action的普通属性: username = <s:property value="username"/> </li>
<li>访问值栈中对象的普通属性(get set方法)：<s:property value="user.age"/> | <s:property value="user['age']"/> | <s:property value="user[\"age\"]"/> | wrong: <%--<s:property value="user[age]"/>--%></li>
<li>访问值栈中对象的普通属性(get set方法): <s:property value="cat.friend.name"/></li>
<li>访问值栈中对象的普通方法：<s:property value="password.length()"/></li>
<li>访问值栈中对象的普通方法：<s:property value="cat.miaomiao()" /></li>
<li>访问值栈中action的普通方法：<s:property value="m()" /></li>
<hr />
<li>访问静态方法：<s:property value="@com.bjsxt.struts2.ognl.S@s()"/></li>
<li>访问静态属性：<s:property value="@com.bjsxt.struts2.ognl.S@STR"/></li>
<li>访问Math类的静态方法：<s:property value="@@max(2,3)" /></li>
<hr />
<li>访问普通类的构造方法：<s:property value="new com.bjsxt.struts2.ognl.User(8)"/></li>
<hr />
<li>访问List:<s:property value="users"/></li>
<li>访问List中某个元素:<s:property value="users[1]"/></li>
<li>访问List中元素某个属性的集合:<s:property value="users.{age}"/></li>
<li>访问List中元素某个属性的集合中的特定值:<s:property value="users.{age}[0]"/> | <s:property value="users[0].age"/></li>
<li>访问Set:<s:property value="dogs"/></li>
<li>访问Set中某个元素:<s:property value="dogs[1]"/></li>
<li>访问Map:<s:property value="dogMap"/></li>
<li>访问Map中某个元素:<s:property value="dogMap.dog101"/> | <s:property value="dogMap['dog101']"/> | <s:property value="dogMap[\"dog101\"]"/></li>
<li>访问Map中所有的key:<s:property value="dogMap.keys"/></li>
<li>访问Map中所有的value:<s:property value="dogMap.values"/></li>
<li>访问容器的大小：<s:property value="dogMap.size()"/> | <s:property value="users.size"/> </li>
<hr />
<li>投影(过滤)：<s:property value="users.{?#this.age==1}[0]"/></li>
<li>投影：<s:property value="users.{^#this.age>1}.{age}"/></li>
<li>投影：<s:property value="users.{$#this.age>1}.{age}"/></li>
<li>投影：<s:property value="users.{$#this.age>1}.{age} == null"/></li>
<hr />
<li>[]:<s:property value="[0].username"/></li>
</ol>
|
|||
| java基础内存分析总结 | java基础内存分析总结 | ||
1.基础数据类型就一块内存（栈），引用数据类型两块内存（栈，堆）new出来的对象在堆中。引用在栈内存。
2.形参和局部变量一样，在栈内存分配。（方法调用完毕后，为这个方法分配的局部变量全部消失，即栈内存立即消失）
3.方法开始执行才分配内存空间。方法执行完毕，为此方法分配的局部变量都消失。
4.调用一个方法有返回值时，返回值也在栈内存中分配临时空间。
5.方法重载，一个类里出现名字相同的多个方法，条件：参数不同（类型，个数），只要根据参数能确定调用的是哪个方法就叫重载。 构造方法也可以重载。
6.静态的方法可以不通过对象调用。非静态的方法只能通过对象调用。
7.this，对哪个对象掉的这个方法，this就是谁。
8.非静态的成员变量，new 一个对象就在自己对象内有一个成员变量
static定义的成员变量只有一份（在数据区）。这个类的所有的对象共享的。
（多继承，一个子类对象含有多个父类对象，父类对象之间有重复的成员变量，非常容易出问题！java为了避免这个问题（实现多个接口时）！接口的成员变量用static修饰！不属于专门某个对象！）
接口是一个特殊的抽象类！只有常量和方法的定义（无实现）！接口里，所有的方法无需写abstract!都是abstract的！
接口的成员变量默认是 public static final 的！也只能是 public static final的！
接口中的方法只能是public 的抽象方法！
9.静态变量存在（数据区 data seg）。。。。。。。。(heap 堆)（stack 栈）
10.静态的成员变量，当没有对象时，用类名.静态的变量。
11.字符串常量分配在数据区。
12.静态的东西在数据区。局部变量永远在栈里，new出来的东西在堆里。代码在代码区。
13.局部变量在栈里分配，成员变量只有new以后才在堆里分配（对象中）。
14. 非静态的成员变量，只有new出来对象后才存在，所以没有new出对象是不可以调用的。
在静态的方法里，不可以访问非静态的（成员变量和方法）。
在静态的方法里可以不通过对象访问静态的（成员变量和方法）
15.package是为了解决类重名的问题。起名规则，公司的域名倒过来。neusoft.com-->com.neusoft
如果类的源文件放入包中，则必须在源文件第一句话写package.
import 引入别的包下的类。
同一个包下的类不需要import.
16.
修饰成员变量和方法时：
private（私有的），只有类内部可以访问。
default(什么都不写)，同一个包下可以访问。
protected（受保护的），同一个包下可以访问且子类也可以访问。
public （公共的） ，所有的都可以访问。
--------------
对于class的权限修饰符，只有两种：（当出现内部类时，private和protected可以修饰类class）
public和default
public 任何地方都可以访问
default 同一个包内可以访问。
17.被重写方法的修饰权限 〉=重写的方法的修饰权限。
18.创建子类的对象时，一定先调用父类的构造方法构造一个父类的对象。
如果调用父类的构造方法，必须写在子类的构造方法的第一行。
如果子类构造方法中不写父类的构造方法，系统调用无参数的父类的构造方法。
19.所有的对象，包括数组都实现了Object类的方法。
20.Object的getClass()方法！拿到的是自己编译好的class文件。（java反射机制）
hashCode(),返回对象的哈希编码。（这个对象在内存中有个位置，根据哈希编码可以很快找到这个位置）
21.Object的equals()方法等同于== ,比较对象的引用是否指向同一个对象。
22. 对象a instancesof b类型 a instancesof b 表示 a是不是b的引用
判断对象a是否是b类型的。
23.其他的jdk包都需要引入到类中，如果未引入则一定是java.lang的包下的
24. Java4类8种数据类型。
整型：byte short int long
浮点型：float double
逻辑型：Boolean
字符型：char
在栈中可以直接分配内存的数据是基本数据类型。 引用数据类型：是数据的引用在栈中，但是他的对象在堆中。
25.
java中默认的整数类型是int类型，如果要定义为float型，则要在数值后加上l或L；
默认的浮点型也是双精度浮点，如果要定义为float型，则要在数值后加上f或F。
26.
Dog 是Animal的子类：
向上转型：Animal a = new Dog();---有利于扩展性(a指向dog对象（含有自己的和父类继承过来的对象），但是对于Animal只能看到自己中有的方法。所以，a.只能调用继承过来的方法！)
向上转型后，向下转型(也叫强制转型)： Dog d = (Dog) a; （d.可以调用new出来的dog的全部方法）.
-----------------------------------------------
Dog 实现 Animal接口和Sing 接口
Animal a = new Dog(); ----a只可以调用,a.(重写Animal的方法)；
Sing s = (Sing)a;-----------此处可以强制转型？？
s 可以调用重写的Sing接口的那些方法。
记住 除了接口之间的转型必须有继承关系 而接口转型必须有相同的实现类
-----------------------------------------------
动态绑定也叫多态：在执行期间而非编译期间，根据实际类型调用方法。
只有new出来对象后，执行期间才可以知道调用哪个方法。
只要方法重写了，
产生多态条件：1.要有继承，2.要有重写，3.父类引用指向之类对象（即：向上转型）
当你调用父类里面被重写的方法的时候，实际new的时什么对象，
class Animal{
public void enjoy（）{
}
}
------
class Dog extends Animal{
public void enjoy（）{重写父类enjoy方法
}
}
class Cat extends Animal{
public void enjoy（）{ 重写父类enjoy方法
}
}
Animal a = new Dog() ，
Animal a = new Cat()
public void f(Animal a){
a.enjoy（），（根据传入的对象来决定调用什么方法）
传入new的Dog的对象，自动调用Dog类中重写的方法。
传入new的Cat的对象，自动调用Cat类中重写的方法。
}
|
|||
| struts2学习记录 | struts2 | ||
struts1与struts2区别：
(1):
在struts1上访问action时，都是同一个对象。会有线程同步的问题，需要进行很好的线程同步的控制。
struts2里访问action时，每次都会new一个对象，所有用户调用action时都是不同的对象，永远不会出现线程同步的问题。
学习struts2记录：
(1)
方法调用：
struts2里访问action时，会调用execute()方法。
action中class执行时，不一定要执行excute()方法，可以在strut.xml中配置method参数(不推荐使用)。
推荐使用：
1.在url地址中动态指定，动态方法调用(DMI)
2.通用符配置来调用。
在struts.xml中配置，通用符配置：约定优于配置。
访问时用Teacher_add.会调用TeacherAction下的add()方法。
<action name="*_*" class="com.bjsxt.struts2.action.{1}Action" method="{2}">
<result>/{1}_{2}_success.jsp</result>
</action>
(2)
在struts2中，action中的class只用这一种办法：extends ActionSupport(ActionSupport已经封装了许多方法)
(3)
路径问题：统一使用绝对路径。
(4)
接收参数的三种方式：
一：
在action中用类的属性接收参数：
在url地址传递参数时的变量名称可以和action中成员变量的名称一一对应。
strutst2自动调用setter()方法赋值，自动传递到成员变量中。
(在action中提供setter和getter方法。setName和url传递参数时name= 对应。)
setName,这个Name和传参的name对应。
二：
在action的类中使用DomainModel(域模型)接收参数：
在action的类中存在的不是直接的属性，而是域模型User (例如：private User user;//User就是类似于formbean;)
在action类中:只需一个setUser(),一个getUser()方法即可；
在域模型User中无论有几百个属性，都可以传递（传递参数时用user.a=xxx,user.b=xxx,user.c=xxx,user.d=xxx....）
public class UserAction extends ActionSupport {
private User user;
//private UserDTO userDTO;
public String add() {
System.out.println("name=" + user.getName());
System.out.println("age=" + user.getAge());
return SUCCESS;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
用域模型接收参数时，存在特殊情况：
当传入的参数和action中DomainModel(User,也就是formbean)匹配不上时
(例如在域模型User存在name,password两个属性，而需要传递name,password,confirpassword三个值）
两种方式处理：
1.用属性接收参数的方法全部接收过来，再给DomainModel(User).
2.用DTO(DTO中的属性和接收参数完全匹配),DTO接收后，在填到User中。
三：
action类implement ModelDriven<User>,实现了ModelDriven接口。
用ModelDriven接收参数(并不常用，但隐含了一种非常重要的程序思想,MVC)
public class UserAction extends ActionSupport implements ModelDriven<User>{
private User user = new User();
public String add() {
System.out.println("name=" + user.getName());
System.out.println("age=" + user.getAge());
return SUCCESS;
}
@Override
public User getModel() {
return user;
}
}
url参数传递方式：name=xxx,age=xxx
struts2的内部处理过程；(不常用)
filter接收到两个参数，就会去new这个UserAction, new这个UserAction时，会发现action实现了ModelDriven接口。
可以调用你的getModel();反馈一个Model(User),可调用这个User的setName()方法(在User类中存在的setName())。则会把参数放入user里了。
MVC:
V:那些个jsp展现。
M:后台的model
C:各种action(由C控制V和M互相通信，把M和V耦合度解开)
(5)
struts2_2.1.6版本的中文乱码问题：
在接收参数过程中，中文处理方法：
按照struts2文档，在struts.xml中配置 <constant name="struts.i18n.encoding" value="GBK" /> <!-- internationalization -->
struts.i18n.encoding在default.properties配置里，=UTF-8
中文乱码问题就可以解决了。
解决方式：
1.利用Spring的filter(建议)
2.在web.xml里用2.0的filter配置就不会有中文乱码问题，但不知道会有什么其他问题产生。
(6)简单的数据校验：
struts2里action中拿不到request,response,只能用struts2的方法实现。
action用this.addFieldError("name", "name is error");//设置错误信息
//<%@taglib uri="/struts-tags" prefix="s" %>引入标签。
在jsp中用<s:fielderror fieldName="name" theme="simple"/>取出。
fieldName和this.addFieldError("name"对应。
<s:property value="errors.name[0]"/>只取值。常用
<s:debug></s:debug>，默认展现出[Debug]链接.常用
struts2不太好的地方就是：<s:fielderror标签把返回的字符串name is error强制给展现
<s:fielderror展现标签基本上不用：
<s:fielderror fieldName="name" theme="simple"/>默认给加上<class=errorMessage>空样式了。
simple是struts2内置的一个比较简单的主题。
(7)
在struts2里必须提供一种机制
取得Map类型request,session,application,真实类型 HttpServletRequest, HttpSession, ServletContext的引用:
value stack，直接取
stack context（action context），加#取
context，上下文，理解为程序当前所处得环境。
ActionContext即，action运行的周边的环境情况。request,session,application等等。
action运行的时候要用到。
在页面中的request是HttpServletRequest, session是HttpSession, application是ServletContext。
第一种方式（主动取，不常用）：
在action中
request = (Map)ActionContext.getContext().get("request");
session = ActionContext.getContext().getSession();
application = ActionContext.getContext().getApplication();
request.put("r1", "r1");
session.put("s1", "s1");
application.put("a1", "a1");
在jsp中可以直接用request了：
<s:property value="#request.r1"/> | <%=request.getAttribute("r1") %> <br />
<s:property value="#session.s1"/> | <%=session.getAttribute("s1") %> <br />
<s:property value="#application.a1"/> | <%=application.getAttribute("a1") %> <br />
两种取值方式：
（1）<s:property value="#request.r1"/>，用标签的方式取值
（2）<%=request.getAttribute("r1") %>
（request全都放到HttpServletRequest里，有对HttpServletRequest封装处理，在jsp中可以直接使用request。)
第二种方式（常用，只用这种方式，除非常特殊情况）：
(IoC(控制反转)设计思想，也叫DI（依赖注入）)
依赖容器注入：依赖别人给我注入一个值。
而不像第一种自己主动去拿。
控制反转：给别人控制了
public class LoginAction2 extends ActionSupport implements RequestAware,SessionAware, ApplicationAware {
private Map<String, Object> request;
private Map<String, Object> session;
private Map<String, Object> application;
//DI dependency injection
//IoC inverse of control
public String execute() {
request.put("r1", "r1");
session.put("s1", "s1");
application.put("a1", "a1");
return SUCCESS;
}
@Override
public void setRequest(Map<String, Object> request) {//依赖struts2给注入
this.request = request;
}
@Override
public void setSession(Map<String, Object> session) {
this.session = session;
}
@Override
public void setApplication(Map<String, Object> application) {
this.application = application;
}
}
(8)
struts2模块包含。
（分模块开发时，一人一个类似于struts.xml的xml）
最后调试把所有人的xml包含到struts.xml中。
(9)默认action，在struts.xml里配置
找不到action时，都由默认的action处理。
(10)result的配置：
result类型：
服务器端跳转：访问服务器url，服务器直接跳转（客户端不知道）到另外jsp，浏览器地址栏显示的是最初请求的地址。
客户端跳转：访问服务器url，服务器反馈给客户端一个信息，然后客户端再次重新发起请求到另外的url，显示的是第二次请求的地址。
默认的就是dispatcher：服务器跳转到html，jsp(不能跳转到action)
redirect，客户端跳转到html，jsp
chain，服务器端跳转，可跳转到action
redirectAction，客户端跳转，跳转action
<action name="r1">
<result type="dispatcher">/r1.jsp</result>
</action>
<action name="r2">
<result type="redirect">/r2.jsp</result>
</action>
<action name="r3">
<result type="chain">r1</result>
</action>
<action name="r4">
<result type="redirectAction">r2</result>
</action>
(11)
<global-results>
全局的结果
所有的action有一个共同的<result时。
<global-results>
<result name="mainpage">/main.jsp</result>
</global-results>
其他包想用可以继承：
<package name="admin" namespace="/admin" extends="user">
<action name="admin" class="com.bjsxt.struts2.user.action.AdminAction">
<result>/admin.jsp</result>
</action>
</package>
(12)
动态结果集：（用的不多，了解即可）
<package name="user" namespace="/user" extends="struts-default">
<action name="user" class="com.bjsxt.struts2.user.action.UserAction">
<result>${r}</result>//这种写法，代表在配置文件里可以读取value stack里的值。OGNL表达式。就这一种用法。
</action>
</package>
对于任何action，他的属性都会放到value satck里面。
所以就是可以在action中动态的定义jsp后，会放到value stack里，然后在配置文件里可以取到。
注：凡是forward（服务器端跳转）的所有的action共享同一个value stack。
一次request只有一个value stack。不需要传参。
需要传递参数的情况：
发起一次请求，进行客户端跳转（重新请求，两次request，不共享同一个value stack）到action时，
action之间需要传递。
<result type="redirect">/user_success.jsp?t=${type}</result>
由于是jsp页面，没有action的存在，并没有value stack的存在。 <s:property value="t"/><br/>在jsp文件里这种方式取不到。
虽然没有value stack，但存在action context（stack context），存在parameters。
解决方式：<s:property value="#parameters.t"/>取得重定向后的参数。
|
|||
| java抽象类和final关键字 | java抽象类和final关键字 | ||
用abstract关键字来修饰一个类时，这个类叫做抽象类； 用abstract关键字来修饰一个方法时，该方法叫抽象方法。 含有抽象方法的类必须被声明为抽象类。 抽象类必须被继承，抽象方法必须被重写。 抽象类不能够实例化。 抽象方法只需声明，不需实现。 final关键字： final 修饰变量，方法，类 final修饰变量： 1.基础数据类型 （1）final int i = 0;编译时常量（可在编译时参与运算，节省运行时消耗） （2）可以运行时赋值; Random rand = new Random(47); final int a = rand.next(20); 2.引用数据类型 final使引用恒定不变，但是对象其自身却是可以被修改的。 （java并未提供使任何对象恒定不变的途径，可以自己编写类实现） final修饰方法： final修饰的方法不能被重写（现在只需考虑这一点即可）（java早期考虑效率问题） final修饰类： 不能被继承（慎用）。 final修饰变量的值不能被改变，修饰方法不能被重写，修饰类不能被继承。 |
|||
| java多态 | java多态 | ||
面向对象的核心：多态
向上转型:父类对象的引入指向子类对象：Anaimal a = new Dog(); （a可以调用继承过来的成员变量和方法，但不可以调用子类特用的方法和成员变量）
向下转型:要想调用子类特有的方法和成员变量，必须进行向下转型，Dog aa = (Dog) a; aa可以调用Dog()中所有的成员变量和方法。
向上转型带来了比较好的可扩展性,但并未达到最好的扩展性。
向上转型扩展性体现在： 传入(Anaimal a) ，根据实际传入的是对象判定
if (a instanceof Dog){
}
if (a instanceof Cat){
}
(比定义好多个方法扩展性好一些，但没有多态扩展性好)
多态，达到了扩展性的极致。
多态指在程序的执行期间(非编译期间)判断所引用对象的实际类型调用相应的方法。
运行起来后，根据实际new的对象，调用其方法
多态的3个条件：
1.继承。
2.重写。
3.向上转型。
体会多态带来的扩展性：
游戏图形例子：
基类：GameObject{
draw();
}
把现有的子弹和飞机放入容器中，拿出来if是飞机，按画飞机，if是子弹，按画子弹。
此时，如果想加入一个图形呢？
办法：改变原有结构，再if是新图形，再画新图形。
扩展性好的办法：
所有的游戏中图形都继承GameObject类，且都自己重写draw();
子弹有子弹的方法，重写。
飞机有飞机的方法，重写。
实际当中扔的是什么，就调用什么的draw方法。
扩展性体现：如果需要新加入一个图形，只需要画出新图形的方法，继承一下GameObject，重写一下draw()方法即可。
|
|||
| java IO总结 | java io总结 | ||
流的分类：
1.数入流和输出流（方向不同）
2.字节流和字符流（处理数据的单位不同）
3.节点流和处理流（功能的不同）
节点流：直接从数据源读写数据。
处理流：是连接在已存在的流（节点流或处理流）之上。 通过对数据的处理为程序提供更强大的读写功能。
J2SDK所提供的所有流类型位于java.io内，都分别继承自以下四种抽象流类型：
InputStream (输入字节流)
OutputStream (输出字节流)
Reader (输入字符流)
Writer （输出字符流）
凡是以Stream结尾的都是字节流(以字节为单位读取)。
凡是Reader或Writer都是字符流。
InputStream:
FileInputStream (从文件读数据)
PipedInputStream(从管道读数据)
ByteArrayInputStream(从字节数组中读数据)
常用方法：
int read()返回-1，表示已读到输入流的尾端。
int read( byte[] buffer) 返回实际读取的字节数，待buffer填满后，再处理
OutputStream:
常用方法：
void write(byte[] b) 写，将一个字节类型的数据中的数据写入输出流。
void close() 关闭流，释放内存。
void flush() 将输出流中缓冲的数据全部写出到目的地
所以在colse()之前需要先进行 flush();
和InputStream都是对称的。
都类似于字节的
Reader(字符):读
例如一个汉字字符占用两个字节，所以有必须存在这种流。否则读取半个汉字。
Writer(字符):写
注：输入管道和输出管道用完后一定要关闭,close();
in.close();
out.close();
写入时，只能创建文件，不能创建目录，使用以下方法：
File logosavedir = new File(path1);//path1为存放的路径
if (!logosavedir.exists()) {//如果不存在文件夹，则自动生成
logosavedir.mkdirs();
}
带缓冲区的叫缓冲流,就是在没有缓冲的流的管道上套一层Buffered的管道。（可显著的减少程序对硬盘的读写次数，保护硬盘）:
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\tes.txt"));
new FileWriter("D:\tes.txt")无缓冲区，再外套一层带缓冲区的管道BufferedWriter;
|
|||
| 删除重复记录sql语句(任意保留一条) | 删除重复记录sql语句(任意保留一条) | ||
DELETE FROM ba_ry_zgkssh
WHERE ROWID in (SELECT m.rowid
FROM (SELECT MAX(rowid) tim, gmsfzh, tbr
FROM ba_ry_zgkssh
where mz is not null
GROUP BY gmsfzh, tbr
HAVING COUNT(*) > 1) b,
ba_ry_zgkssh m
WHERE b.gmsfzh = m.gmsfzh
AND m.rowid < tim)
|
|||
| oracle创建自增表空间 | oracle创建自增表空间 | ||
create tablespace xjxy logging datafile 'D:\app\zhangruyi\oradata\orcl\xjxy.dbf' size 5000M autoextend on next 1000M maxsize unlimited extent management local segment space management auto; |
|||
| 各种总结 | 总结 | ||
----------2013-4-26
exists 和 in用法：
select * from ba_ry_jbxx T1 where exists(select 1 from ba_ry_zgkssh T2 where T1.Gmsfzh=T2.Gmsfzh) ;-- 1,无实际意义，也可以为*.exists()表示在这个范围内。not表示不在这个范围内。
select * from ba_ry_jbxx T1 where t1.gmsfzh in (select ba_ry_zgkssh.gmsfzh from ba_ry_zgkssh ) ; --in 需要字段对应。(当用到not in 的时候，注意：如果子查询中任意记录含有null的话，则查询结果不返回任何记录。除非子查询有非空限制（ba_ry_zgkssh.gmsfzh）否则，尽量不使用not in ）
效率问题：
GROUP BY
是分组查询, 一般 GROUP BY 是和聚合函数配合使用group by 有一个原则,就是 select 后面的所有列中,没有使用聚合函数的列,必须出现在 group by 后面（重要）
group by 后面是要跟着的 select 中所有不是聚合函数的字段。
select count(*),t1.mz from ba_ry_jbxx t1 group by t1.mz having count(*)> 2 and t1.mz = '01'
having 相当于where 与where的唯一区别是 当查询语句中有 聚合函数（having 后需要用到聚合函数） 的时候 就不能用where 了 只能用having
oracle中如何查询数据表中重复的数据？
select * from ba_ry_jbxx tt right join (select t.gmsfzh From ba_ry_jbxx t Group by t.gmsfzh having Count(t.gmsfzh) > 1 )T on T.Gmsfzh = tt.gmsfzh
或 select * from ba_ry_jbxx tt ,(select t.gmsfzh From ba_ry_jbxx t Group by t.gmsfzh having Count(t.gmsfzh) > 1 )T
where tt.gmsfzh = T.Gmsfzh
--------------2013-4-27
java创建线程的两种方式：
第一种方式：使用Runnable接口创建线程
第二种方式：直接继承Thread类创建对象
继承 Thread类：----------start(),run()方法都是Thread类中特有的方法。此类是实现了Runnable接口而重写的方法。run()方法为线程执行的内容。
1.新建一个线程类继承Thread类A （从写run()方法）。
2.new A().start();----表示启动线程（不一定立即执行），程序会自动调用run()方法真正执行线程（cpu有空间的话）
实现Runnable接口：
1.新建一个线程类B实现Runnable接口（从写run()方法）。
2.new Thread ( new B() ).start() ---------启动线程。
----------------2013-4-28
多态：（执行期间，而非编译期间）
条件；父类对象的引用指向子类对象，重写。
CountDownLatch latch = new CountDownLatch(list.size());
直到list.size()为0时，主线程继续往下走。
latch.countDown(),自动-1.
--------------------------------------------------------------------------------2013-5-13
[javascript]关于window.showModalDialog的缓存问题 window.showModalDialog()方法常用于在IE弹出对话框，
前不久使用中发现一个“滞留”问题，即弹出对话框中的网页内容不能及时更新，仍然显示第一次弹出时的内容，直到父页面刷新。
经过查找资料，发现有解决方法如下：
1、给弹出的窗口的页面加上时间参数，这样可以消除缓存：
<script language='javascript'>
var time = new Date();
window.showModalDialog("newWin.html?time="+time,"父页面传递到子页面的值","")
</script>
2、在页面代码Page_Load()中设置缓存过期：
Response.Expires = -1；
3、在一个HTML页面中使用iframe，在其中嵌套真正要显示的页面，这样虽然iframe被缓存了，但里面真正要显示的页面还是重新加载了。
var kpxm_src = "<%=request.getContextPath()%>/jsp/zljc/jchd/setJcfw.jsp?hdbh="+hdbh+ "&tmpId=" + new Date().getTime();;
var sFeatures=fnSetValues();
var result = window.showModalDialog(kpxm_src,"父页面传递到子页面的值",sFeatures);
参数1:URL
参数2：父页面传给子页面的值
参数3.子页面的高度，宽度属性值。
window.showModalDialog和window.open()区别:
打开一个子窗口，并且可与父窗口相互传递数据，window.showModalDialog与window.open的最大区别就在于由ShowModalDialog打开子窗口后，父窗口将不能操作。
父窗口向子窗口传递参数采用ShowModalDialog的第2个参数即可，父窗口要获取子窗口传回的参数则可通过ShowModalDialog函数的返回值result获取。
子窗口获取父窗口参数的方法为采用子窗口window对象dialogArguments属性获取，例如：
var a=window.dialogArguments;
window.dialogArguments 即为父窗口window对象的引用。
注意第二个参数用window,这样你就把父窗口对象当做参数传递给了子窗口.
你也可以调用主窗口里的函数:
window.dialogArguments.函数名();
子窗口向父窗口返回参数采用window.returnValue属性，如：
window.returnValue=1;
showModalDialog() 弹出一个对话框，对话框是依附于打开它的那个窗口的；window.open() 是开一个新窗口，和打开它的那个窗口是独立的
关闭子窗口的办法:onclick="window.close();
WEB-INF是Java的WEB应用的安全目录。所谓安全就是客户端无法访问，只有服务端可以访问的目录。
如果想在页面中直接访问其中的文件，必须通过web.xml文件对要访问的文件进行相应映射才能访问。
WEB-INF文件夹下除了web.xml外，还存一个classes文件夹，用以放置 *.class文件，这些 *.class文件是网站设计人员编写的类库，
实现了jsp页面前台美工与后台服务的分离，使得网站的维护非常方便。web.xml文件为网站部署描述XML文件，对网站的部署非常重要。
Web-Inf文件夹中除了有classes文件夹和一个web.xml文件外、还有lib文件夹（用于存放需要的jar包）（用于配置，比如说用来配置过滤器等。）
-----------------------------------------2013-5-28
1.
replace()函数用法：
SELECT REPLACE('JACK and JUE','J','BL') "Changes"
FROM DUAL;
Changes
--------------
BLACK and BLUE
2.
chr()函数和ascii()函数相反转换。
select chr('36') from dual ======== $
select ascii('$') from dual ========== 36
insert into test(col1,col2,col3,type) values(0,0,0,'&jfd') ,会弹出一个Variables提示框，要求你输入变量'jfd'值
而如果执行：insert into test(col1,col2,col3,type) values(0,0,0,chr(38)||'jfd')，就会直接把'&jfd'插入。
-----------------------------------2013-5-29
----------------------------------------------2013-7-16
document.getElementById("JSPY").innerHTML ="<B><font size = '3' >" +jspy_gsh+"</font></B>" ;
document.getElementById("JSPY").innerText = jspy_gsh;
innerHTML 可以动态在固定标签上加标签.
innerText 只可以在标签上加入文本.
--------------------------------2013-7-17
tabList1.getSelectedRow().PZBH;
-------------------------------------2013-7-18
导入导出dmp两种方式:
1.通过客户端访问数据库进行导入导出.
2.直接在数据库的机器上进行导入导出.
在本地(通过客户端访问数据库,客户端版本和数据库版本必须兼容): imp baxt/baxt@orcl ------(orcl此时为连接数据库配置的服务名)
在数据库上: imp baxt/baxt@orcl ------------(orcl此时为数据库的sid)
查询sid的sql语句: select instance_name from v$instance;
----------------------------2013-8-12
---cookies:
1.服务器可以向客户端写内容.
2.只能是文本内容.
3.只能拿自己webapp写入的东西.
4.Cookies分为两种:属于窗口/子窗口
属于文本
5.一个servlet/jsp设置的cookies能够被同一个路径下面或者子路径下面的servlet/jsp读取到.(路径值URL)不是指真实路径.
//绝对路径(真实的路径)
//相对路径(URL)
http协议时非连接的.
Cokkies记录在客户端.
--Session记录在服务器端.服务器端的一块内存.名/值对出现.
SessionID (窗口传(SessionID)到服务器端,根据SessionID找到对应的session)
session利用cookies(窗口的)传递即可.
--session和窗口对应.
\规则:1.如果浏览器支持Cookies,创建session时,会把sessionid保存在cookies里面.
cookies真正禁止掉.通过session第二种实现方法.(如下,通过url地址传递)
2.如果不支持cookies,必须自己编程使用URL重写的方式实现session.
response.encodeURL()
/转码
/URL后面加上sessionid.
//session不像cookies有路径的问题.同一个应用下的所有的servlet/jsp可以共享同一个session.前提是同一个客户端窗口.
--application(所有的客户端都可以访问)
-----------------------2013-8-13
去掉字符串数组中的重复值的方法:(Set不允许重复,所以把重复的都放入set后,再toArray后就去掉了.)
for(int ii=0;ii<tempStr.length;ii++){
set.add(tempStr[ii]);
}
String[] str = (String[]) set.toArray(new String[0]);
----------2013-8-28
前台取标识：
var BKBM = document.getElementById("BKBM").value;
action1 = strAction+"?method=delete_zgkssh&BKBM="+BKBM;
var response = doPost(action1);
if("1" == response ){
alert("注销成功！");
}else{
alert("注销失败！");
}
后台返回： response.getWriter().write("1");
-----------
java.util.date和java.sql.date比有什么区别？
一般时候用java.util.Date和数据库jdbc相关的方法都在java.sql这个包里，
接受以java.sql.Date为参数。例如：java.sql.PreparedStatement里的setDate(int parameterIndex, java.sql.Date x)
---------------
java.lang包是默认导入的,不用手动引入。其他包就需要手动了。
--------------------------2013-8-30
效率测试：
（1）
ba_ry_jbxx：2000条
ba_ry_zgkssh：68801
查询ba_ry_zgkssh 的gmsfzh不在ba_ry_jbxx中的办法：
当ba_ry_jbxx未加gmsfzh索引字段时。特慢（120s）。
select count(1)
from ba_ry_zgkssh t
where not exists
(select 1 from ba_ry_jbxx a where a.gmsfzh = t.gmsfzh)
当ba_ry_jbxx加索引后，效率特大提高（不到1s）。
不用not exists时，用
select count(1)
from ba_ry_zgkssh a, ba_ry_jbxx b
where a.gmsfzh = b.gmsfzh(+)
and decode(b.gmsfzh,'','1','0')='1'
效率也不错！
--------------------------------2013-9-4
servlet是可以在任何服务器端运行的小程序。
web服务器端
email服务器端
ftp服务器端
http服务器端
doGet方式参数名都跟在url地址后面
doPost则不跟在后面
oracle
伪字段，rownum
取第几行到第几行。
rownum只能用<或<= 。
加主键和唯一，自动加索引。
-----------------plsql语言：
定义现有表中的字段类型的变量 变量声明方法：ba_ry_zgkssh.bkbm%TYPE;
定义现有表中的一条记录的类型 声明方法：baydata ba_ry_zgkssh%rowtype;
cursor bay is
select *
from ba_ry_zgkssh t
where t.bkdssxq like '2101%' and t.gxsj > sysdate -3
for baydata in bay(游标) loop
定义数组，也得指定类型
必须手动创建一个类型。
type type_table_emp_empno is table of emp.empno%type index by binary_integer;
定义了新的类型 type_table_emp_empno；
然后可以使用
v_empnos type_table_emp_empno；
v_empnos(0) :=1;
v_empnos(1) :=2;
v_empnos(-1) :=2;//下标可以取负值。
----Record变量类型。
type type_record_dept is record;
定义一个record的类型 record_dept(
deptno dept.deptno%type;
dname dept.dname%type;
loc dept.loc%type;
);
v_temp type_record_dept;
用法：
v_temp.deptno :=1;
v_temp.dname :='bj';
v_temp.loc :='bb';
--------使用%rowtype声明record变量;（好处，表加字段后，无需修改）
v_temp dept%type;--即可。
select 语句里必须有into（切保证有且只有一条记录）或者用游标。
---%rowcount。
sql%rowcount;表示刚刚执行的sql语句影响了多少行！
if循环：
if then
elseif then
else
endif;
plsql语言中所有的循环一定是loop end loop;
三种循环：
(1)
loop
exit when(i>11);//退出
end loop;
相当于 do while()循环。
（2）
while j<11
loop
end loop;
相当于while（）循环
（3）
for k in 1..10 loop
end loop;
相当于 for 循环
//fetch一下后游标指针自动向下移动。
游标：
----只会打印一条！
cursor c is select * from emp ;
v_emp emp%rowtype;
open c;
fetch c into v_emp;
dbms_output.put_line(v_emp.empno);
close c;
---------------------------------------------
do while()循环游标。
------全部打印完。
cursor c is select * from emp ;
v_emp emp%rowtype;
open c;
loop;
fetch c into v_emp;
exit when (c%notfound);
dbms_output.put_line(v_emp.empno);
close c;
end loop;
----------------------------------------------------
while（） 循环游标
-------------------------------------------------
（for循环和游标一起用简单）
for循环取游标是三种循环中最简单的:
cursor c is select * from emp ;
begin--------------v_emp不需要声明，for自动给声明。游标不需要开启和关闭，for自动开启和关闭。
for v_emp in c loop
dbms_output.put_line(v_emp.empno);
end loop;
end;
-------------------------------------------
1.%notfound 最近的fetch语句找不到记录。
2.%found 最近的fetch语句找到记录。
3.%rowcount 记录数
------------------------
带参数的游标。
-----------------------------2013-9-9
容器：
---------------------------------2013-9-12
DOM编程：
------------------
Websphere和Weblogic，为应用服务器
---------------------------2013-9-17
java.sql.Date
-------------------2013-11-4
Cookies有两种：
1.临时的，在内存中的。
2.以文本文档形式存在客户端中。
session的两种实现方式：
1.通过Cookies实现。把session id 放在Cookies里面（临时的即可，只跟浏览器窗口有关）。
2.通过URL重写实现。(所有的连接地址加上response.encodeURL())
规则：
如果浏览器支持Cookies,创建session时，会把session id保存在Cookies(临时的).
如果浏览器不支持Cookies,每次会生成新的session id .此时必须自己编程，使用URL重写的方式实现session.(通过url后传入session id)
在一个页面设置的Cookies，只有这个页面所在的目录下或者其子路径下的所有的jsp/servlet可以访问。
session不存在路径的问题，同一个application下的jsp/sevlet可以共享同一个session,前提是同一个客户端窗口。
application.所有的客户端共有的。
Cookies设置了过期时间，就会在客户端硬盘上生成txt文件。
若未设置过期时间，则表示这个Cookies的声明周期为浏览器会话期间，关闭浏览器窗口，cookies就消失。一般不会在客户端硬盘上生成txt文件。而是保存在内存中。
jsp就是servlet。
tomact下的work是存放jsp转换完成之后的class文件和java文件。
<%! int a= "";%>//声明成员变量
<% int b= "";%>//声明局部变量
<%! void m(){};%>//声明方法正确写法.
<% void n(){};%>//错误写法，类似于在方法里声明方法了。
html的注释：<!-- --> ，客户端浏览器可以查看
jsp的注释：<%-- --%>,客户端浏览器看不到，程序员自己看的注释。
Directive编译指令,编译期间的命令：
<%@ 指令的名称 %>
常见的三种编译指令：
page
<%@ page import="org.dom4j.*"% contentType="text/html; charset=GBK">
<%@ page errorPage="error.jsp"% >配置当当前出错时显示的页面。
include:将指定的jsp程序或者html文件包含进来。
<%@ include file="fileURL" %> ,先包含进来，再编译，然后再执行。
taglib
<jsp:include >执行期间引入进来。
<jsp:forward >和response.sendRedirect区别：
<jsp:forward >使用同一个request
response.sendRedirect是不同request
|
|||