java内容

(一、开启数据库事件)

DataSourceTransactionManager transactionManager = (DataSourceTransactionManager)SpringApplicationContext.getBean(“transactionManager”);
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事物隔离级别，开启新事务，这样会比较安全些。
TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态

transactionManager.commit(status);//提交事物
transactionManager.rollback(status);//回滚事物

(二、判断字符串中某个字符的个数)

str1字符串中有几个str2字符串
public static int countStr(String str1, String str2) {
int count=0;
if (str1.indexOf(str2) == -1) {
return 0;
}
while(str1.indexOf(str2)!=-1){
count++;
str1=str1.substring(str1.indexOf(str2)+str2.length());
}
return count;
}

(三、MD5加密)

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public static String getMD5(String str) {
String md5code = null;
MessageDigest md = null;
try {
md = MessageDigest.getInstance(“MD5”);
byte[] secretBytes =md.digest(str.getBytes());
md5code = new BigInteger(1, secretBytes).toString(16);
// 如果生成数字未满32位，需要前面补0
for (int i = 0,md5codeLength = md5code.length(); i < 32 - md5codeLength; i++) {
md5code = “0” + md5code;
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return md5code;
}

(四、静态快)

静态代码块，在虚拟机加载类的时候就会加载执行，而且只执行一次；
非静态代码块，在创建对象的时候（即new一个对象的时候）执行，每次创建对象都会执行一次
执行顺序
	静态代码块—>非静态代码块—>构造方法

(map循环)

HashMap<String, String> map = new HashMap<String, String>();
Iterator<?> itr = map.entrySet().iterator();
while (itr.hasNext()) {
Map.Entry entry = (Entry) itr.next();
entry.getKey();
entry.getValue();
}

(list)

数组
  Vector线程安全；ArrayList线程不安全
 查询快；插入、删除慢；好比多人看电影必须坐在一起，中间插入一个人或者走一个 后面的人员全部要移位
 循环用普通for循环快
链表
  LinkedList 线程不安全
 查询慢；插入、删除快；好比多人看电影 做到那都行，中间插入一个人 只需要把自己的地址告诉前面的人 和得到被插入人的新位置就行了，其他人都不动。
 循环LinkList用增强for循环快
链表跟数组的区别
  数组静态分配内存，链表动态分配内存；数组在内存中连续，链表不连续；数组利用下标定位，时间复杂度为O(1)，链表定位元素时间复杂度O(n)；数组插入或删除元素的时间复杂度O(n)，链表的时间复杂度O(1)。
单链表与双链表区别
  单链表只有一个指向下一结点的指针，也就是只能next
双链表除了有一个指向下一结点的指针外，还有一个指向前一结点的指针，可以通过prev()快速找到前一结点，顾名思义，单链表只能单向读取。双链表比较占用空间。

List list_1 = new ArayList();
list_1.add(123);
List list_2 = list_2;
如果list_1=null; list_2里面的值不变
如果list_.clear(); list_2里面的值跟着变

GC内存回收（list大数据量，如果知道数据量最好设置大小new ArrayList(100000);
  如果list不再用了：list.clear();list=null;System.gc();
  如果list需要再用：list.clear();System.gc();

(休眠)

 Thread.sleep(1000*3); // 休眠3秒

(日期)

 Date dNow = new Date( );
 SimpleDateFormat ft = new SimpleDateFormat (“yyyy-MM-dd HH:mm:ss:SSS”);
 System.out.println("当前时间为: " + ft.format(dNow));

long start = System.currentTimeMillis( );

Calendar c = Calendar.getInstance();//默认是当前日期
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
常量| 描述

• | -
  Calendar.YEAR |年份
  Calendar.MONTH| 月份 0代表1月
  Calendar.DATE |日期
  Calendar.DAY_OF_MONTH |日期，和上面的字段意义完全相同
  Calendar.HOUR| 12小时制的小时
  Calendar.HOUR_OF_DAY |24小时制的小时
  Calendar.MINUTE |分钟
  Calendar.SECOND |秒
  Calendar.DAY_OF_WEEK| 星期几 1代表星期日
  // 获得年份
  int year = c1.get(Calendar.YEAR);
  //把c1对象的日期加上10天
  c1.add(Calendar.DATE, 10);
  //把c1对象的日期减去10
  c1.add(Calendar.DATE, -10);

java.util.GregorianCalendar 是Calendar的一个具体实现
判断年份是否为闰年。
boolean isLeapYear(int year)
例子：
 GregorianCalendar gcalendar = new GregorianCalendar();
 int year = gcalendar.get(Calendar.YEAR);
 System.out.println(gcalendar.toString());

(正则表达式)

pattern字符串中是否包含content的规则，content是个字符串规则
boolean isMatch = Pattern.matches(pattern, content);

Pattern p = Pattern.compile(“\bcat\b”);//匹配左边界是cat或者右边界是cat （边界不是开头，多个里面 空格之后 空格之前就是边界）
Matcher m = p.matcher(“cat cat cat cattie cat”); // 获取 matcher 对象
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}

字符	说明
|将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如， n匹配字符 n。\n 匹配换行符。序列 \\ 匹配 \ ，\\( 匹配 (。
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。
*	零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。
+	一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。
?	零次或一次匹配前面的字符或子表达式。例如，"do(es)?“匹配"do"或"does"中的"do”。? 等效于 {0,1}。
{n}	n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,}	n 是非负整数。至少匹配 n 次。例如，"o{2,}“不匹配"Bob"中的"o”，而匹配"foooood"中的所有 o。"o{1,}“等效于"o+”。"o{0,}“等效于"o*”。
{n,m}	m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。‘o{0,1}’ 等效于 ‘o?’。注意：您不能将空格插入逗号和数字之间。
?	当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?“只匹配单个"o”，而"o+“匹配所有"o”。
.	匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
(pattern)	匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"(“或者”)"。
(?:pattern)	匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (
(?=pattern)	执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95
(?!pattern)	执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95
x	y
[xyz]	字符集。匹配包含的任一字符。例如，"[abc]“匹配"plain"中的"a”。
[^xyz]	反向字符集。匹配未包含的任何字符。例如，"[^abc]“匹配"plain"中"p”，“l”，“i”，“n”。
[a-z]	字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z]	反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。
\b	匹配一个字边界，即字与空格间的位置。例如，“er\b"匹配"never"中的"er”，但不匹配"verb"中的"er"。
\B	非字边界匹配。“er\B"匹配"verb"中的"er”，但不匹配"never"中的"er"。
\cx	匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。
\d	数字字符匹配。等效于 [0-9]。
\D	非数字字符匹配。等效于 [^0-9]。
\f	换页符匹配。等效于 \x0c 和 \cL。
\n	换行符匹配。等效于 \x0a 和 \cJ。
\r	匹配一个回车符。等效于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\t	制表符匹配。与 \x09 和 \cI 等效。
\v	垂直制表符匹配。与 \x0b 和 \cK 等效。
\w	匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
\W	与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
\xn	匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41"匹配"A”。“\x041"与”\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
\num	匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
\n	标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
\nm	标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
\nm	当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
\un	匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。

(java流)

输出
OutputStream out = new FileOutputStream(“C:/java/hello”)//如果文件不存在不会自动创建（覆盖原有内容）
OutputStream out = new FileOutputStream(new File(“C:/java/hello”));//如果文件不存在会自动创建（覆盖原有内容）
OutputStream out = new FileOutputStream(new File(“C:/java/hello”), true);//如果文件不存在会自动创建（不覆盖原有内容）
String str=“Hello World”;
byte[] b=str.getBytes();
out.write(b);//因为是字节流，所以要转化成字节数组进行输出
//如果需要指定编码使用
OutputStreamWriter writer = new OutputStreamWriter(out , “UTF-8”);
writer.append(“中文输入”);

输入
InputStream in=new FileInputStream(new File(“C:/java/hello”));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] b = new byte[1024];
int n;
while ((n = in.read(b)) != -1) {
  bos.write(b, 0, n);
}
byte[] bytes = bos.toByteArray();
String s = new String(bytes);

(多线程)

1.调用一个类有参数传递
public class RunnableDemo implements Runnable {
private Thread t;
private Map map;
private String threadName;
public RunnableDemo(String threadName, Map map) {
this.map = new HashMap();
this.map.putAll(map);
this.threadName =threadName;
}
@Override
public void run() {
for(int i = 1; i<4; i++) {
System.out.println("Thread: " + threadName + ", " + i +“map:”+map.toString());
}
}
public void start() {
if(t==null) {
t = new Thread(this,threadName);
t.start();
}
}
}

调用:
Map map = new HashMap();
RunnableDemo rd = new RunnableDemo(“thread-1”,map);
rd.start();
2.共用一个类的参数数值
public class RunnableDemo2 implements Runnable {
private int num =1000;
private static RunnableDemo2 uniqueInstance = new RunnableDemo2();
private RunnableDemo2(){}
public static RunnableDemo2 getInstance() {
return uniqueInstance;
}
@Override
public void run() {
while(true) {
synchronized (this) {
if(num<=0) {
break;
}
num–;
System.out.println("Thread: " + Thread.currentThread().getName()+“剩余”+num);
}
}
}
}

调用方法（类只能实例一次所以用了单例模式）
RunnableDemo2 rd = RunnableDemo2.getInstance();
Thread th = new Thread(rd,“窗口1”);th.start();
Thread th2 = new Thread(rd,“窗口2”);th2.start();
如果不用单例模式（这种方式可以测试用，正常程序实现不了）
RunnableDemo2 rd = new RunnableDemo2();
Thread th = new Thread(rd,“窗口1”);th.start();
Thread th2 = new Thread(rd,“窗口2”);th2.start();