【java提高】---细则(1)
异常
一.异常与错误的区别
再讲异常之前我们就应该要知道异常和错误的区别
Error类和Exception类的父类都是throwable类,他们的区别是:
Error类一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢等。对于这类错误的导致的应用程序中断,
仅靠程序本身无法恢复和和预防,遇到这样的错误,建议让程序终止。
Exception类表示程序可以处理的异常,可以捕获且可能恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。
二.异常的体现分类
1.checked 异常检查期异常 java.lang.Excetion 在编译期需要人工处理否则编译失败:Exception的子类除了运行期异常都是检查期异常
2.非Checked异常运行时异常 java.lang.RuntimeException 不需要处理的直接能编译通过:所有的RuntimeException以及其子类都是运行异常
举例:运行期异常
结果:运行期异常,当你敲好代码时不会报错,而当你运行时才会报除数不能为0的错误
举例:检查期异常:
结果:检查期异常,当你编译的时候就会报错,一定要抛出异常编译才能通过
三.异常的处理机制
Java语言主要依赖于 try catch finally 和throws throw 五个关键字来描述异常
1) 在发生异常的地方直接处理
使用try catch finally 直接处理异常
a) try-catch-finally结构中try块是必须有的,catch和finally块为可选,但两者至少必须出现其中之一。
b) catch 可以同时出现多个,但一个异常最多捕获一个catch,而且catch的顺序是从上往下
c) finally 无论是否捕获异常都会执行的一行代码
演示1:try异常
![](https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif)
1 public class TestException { 2 public static void main(String[] args) { 3 int c = 0; 4 try 5 { 6 int a = 3; 7 int b = 0; 8 // 这块代码出现了异常 9 c = a / b; 10 // 那么异常之后的代码都不会被执行 11 System.out.println("Hello World"); 12 } 13 catch (ArithmeticException e) 14 { 15 System.out.println("除数不能为零"); 16 } 17 finally 18 { 19 //不管有没有发生异常,finally语句块都会被执行 20 System.out.println("Welcome"); 21 } 22 System.out.println(c); 23 // 当b为0时,有异常,输出为c的初始值0 24 } 25 } 26 //输出结果:除数不能为零 Welcome 0
演示2:带有return的异常
1 import java.io.FileInputStream; 2 import java.io.FileNotFoundException; 3 public class DemoException { 4 public static void main(String[] args) { 5 int a=test3(); 6 System.out.println(a); 7 } 8 @SuppressWarnings("finally") 9 public static int test3(){ 10 try { 11 System.out.println(9 / 0); 12 return 1; 13 } catch (Exception e) { 14 System.out.println("呵呵"); 15 return 2; 16 }finally{ 17 System.out.println("哈哈"); 18 return 3; 19 } 20 } 21 } 22 //输出结果 "呵呵""哈哈" 3
得出结论:作用范围 return 终止整个方法体,但在finally出现之前 return是老大 finally 作用范围> return
2)将异常抛给调用者让调用者处理
1 //throws在方法体头部通过声明 抛出异常... 2 public void dealFile() throws FileNotFoundException{ 3 FileInputStream fis =new FileInputStream("C:/name.txt"); 4 } 5 //那么那么上面调用这个方法可以选择是继续抛出,还是捕获异常
案例一:通过throws抛出异常,调用者直接捕获抛出的异常
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
运行结果:
非数据类型不能转换。
注意:使用Throws是的限制
两小原则
使用throws 声明抛出异常一个限制
子类继承父类重写父类的方法
子类抛出的异常必须比父类少
子类抛出的异常必须比父类小
两小原则是针对检查期异常的,运行期异常不遵循这个规则(RuntimeException 以及子类)
案例二:通过throw抛出异常
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
运行结果如下:
面试题:Throw 和Throws有什么区别?
Throw语句是用在方法体内表示抛出的异常由方法体内的语句处理
Throws 语句是在方法声明之后抛出异常表示在抛出的异常交给调用者处理
Throws 要么使用try –catch –finally 处理要么继续抛出
四.自定义异常
所谓自定义异常,通常就是定义一个类,去继承Exception类或者它的子类。因为异常必须直接或者间接地继承自Exception类。
通常情况下,会直接继承自Exception类,一般不会继承某个运行时的异常类。
自定义异常可以用于处理用户登录错误,用户输入错误提示等。
自定义异常需要遵循以下步骤
- 继承RuntimeExcetion 或者Exception
- 写一个无参的构造函数
- 写一个String类型的构造函数
举例:自定义异常:
public class MyException extends Exception { public MyException() { super(); } public MyException(String message) { super(message); } }
一种处理异常方式
public class ExceptionTest4 { public void method(String str) throws MyException { if(null == str) { throw new MyException("传入的字符串参数不能为null!"); } else { System.out.println(str); } } public static void main(String[] args) throws MyException //异常处理方式1,不断向外抛出 { ExceptionTest4 test = new ExceptionTest4(); test.method(null); } }
另一种异常处理方式:
1 public class ExceptionTest4 2 { 3 4 public void method(String str) throws MyException 5 { 6 if (null == str) 7 { 8 throw new MyException("传入的字符串参数不能为null!"); 9 } 10 else 11 { 12 System.out.println(str); 13 } 14 } 15 16 public static void main(String[] args) 17 { 18 //异常处理方式2,采用try...catch语句 19 try 20 { 21 ExceptionTest4 test = new ExceptionTest4(); 22 test.method(null); 23 24 } 25 catch (MyException e) 26 { 27 e.printStackTrace(); 28 } 29 finally 30 { 31 System.out.println("程序处理完毕"); 32 } 33 34 } 35 }
最后说一句,try-catch-finally虽好用,但是如果是滥用,这样只是会让程序的可读性变的很糟糕,当程序报错,就无法快速准确的定位了。
如果有个别地方写的不到位或者不够完善希望大家多多指点,看了有不明白的地方也可以留言,我也会尽快帮助解答。
正则表达式---常用符号
首先声明,我这里列表的是经常使用的一些符号,如果你想得到全部,那建议你通过API中,搜索Pattern类,会得到所有符号。
字符类 | |
---|---|
[abc] | a、b 或 c(简单类) |
[^abc] | 任何字符,除了 a、b 或 c(否定) |
[a-zA-Z] | a 到 z 或 A 到 Z,两头的字母包括在内(范围) |
[a-d[m-p]] | a 到 d 或 m 到 p:[a-dm-p](并集) |
[a-z&&[def]] | d、e 或 f(交集) |
[a-z&&[^bc]] | a 到 z,除了 b 和 c:[ad-z](减去) |
[a-z&&[^m-p]] | a 到 z,而非 m 到 p:[a-lq-z](减去) |
预定义字符类 | |
---|---|
. | 任何字符(与行结束符可能匹配也可能不匹配) |
\d | 数字:[0-9] |
\D | 非数字: [^0-9] |
\s | 空白字符:[ \t\n\x0B\f\r] |
\S | 非空白字符:[^\s] |
\w | 单词字符:[a-zA-Z_0-9] |
\W | 非单词字符:[^\w] |
边界匹配器 | |
---|---|
^ | 行的开头 |
$ | 行的结尾 |
\b | 单词边界 |
\B | 非单词边界 |
Greedy 数量词 | |
---|---|
X? | X,一次或一次也没有 |
X* | X,零次或多次 |
X+ | X,一次或多次 |
X{n} | X,恰好 n 次 |
X{n,} | X,至少 n 次 |
X{n,m} | X,至少 n 次,但是不超过 m 次 |
为了让大家更加明白,对上面的进行部分解释
元字 符 | 举例 |
.点 | 例如正则表达式r.t匹配这些字符串:rat、rut、r t,但是不匹配root。 |
$ | 例如正则表达式weasel$ 能够匹配字符串"He's a weasel"的末尾 但是不能匹配字符串"They are a bunch of weasels." |
^ | 匹配一行的开始。例如正则表达式^When in能够匹配字符串"When in the"的开始,但是不能匹配"What and When in the" |
* | 匹配0或多个正好在它之前的那个字符。例如正则表达式。*意味着能够匹配任意数量的任何字符。 |
\ | 这个是用来转义用的。例如正则表达式\$被用来匹配美元符号,而不是行尾,类似的,正则表达式\.用来匹配点字符,而不是任何字符的通配符。 |
| | 将两个匹配条件进行逻辑“或”(Or)运算。例如正则表达式(him|her) 匹配" to him"和"i to her",但是不能匹配" to them."。 |
+ | 匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。 |
? | 匹配0或1个正好在它之前的那个字符。 |
{i} {i,j} |
例如正则表达式A[0-9]{3} 能够匹配字符"A"后面跟着正好3个数字字符的串,例如A123、A348等,但是不匹配A1234。 而正则表达式[0-9]{4,6} 匹配连续的任意4个、5个或者6个数字字符。 |
最后讲一个初学者很容易搞混的知识点
正则表达式的() [] {}的区别
() 是为了提取匹配的字符串。表达式中有几个()就有几个相应的匹配字符串。圆括号中的字符视为一个整体。
[]是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。
{}一般用来表示匹配的长度,比如 \s{3} 表示匹配三个空格,\s[1,3]表示匹配一到三个空格。
(0-9) 匹配 '0-9′ 本身。 [0-9]* 匹配数字(注意后面有 *,可以为空)[0-9]+ 匹配数字(注意后面有 +,不可以为空){1-9} 写法错误。
[0-9]{0,9} 表示长度为 0 到 9 的数字字符串。
注意:关于() [] {}区别,如果你还没用明白的话,也没有关系,这两天我还会写正则表达式类文章,到时候我会用列子说明。
正则表达式
说真的正则表达式真不好写,当我收集资料准备开始写的时候,发现收集的东西越来越多范围也越来越广,我文章的前提就是文章要清晰,
在缕清自己思路之后,我从先简后难的方式来写有关正表达式,你们如果觉得这篇写的还可以的话,可以先关注我,接下来我会陆续更新。
一.什么是正则表达式
正则表达式(regular expressions)是一种描述字符串集的方法,它是以字符串集中各字符串的共有特征为依据的。
正则表达式可以用于搜索、编辑或者是操作文本和数据。这是官方表达听的有点绕口,用通俗的话来说就是:正则表达式主要用来处理和文本有关的内容
常见的处理方式有四种:1.匹配 2.切割 3.替换 4.获取 在下面我也会一一举例说明。
二.正则表达式常见的符号含义
这个我在正则表达式(1)中,有关常用的也大概做个介绍,大家可以往前翻阅。
三.常见的处理方式有四种
(1)匹配 我这里使用的是字符串对象的方法 match(String regex),
1 import java.util.regex.*; 2 public class TestException{ 3 public static void main(String[] args) throws Exception { 4 String tel="18600000111"; 5 String reg="1[3578]\\d{9}"; //首字母1,第二字母3,5,7,8,后面都是数字共有9位 6 boolean b1 =tel.matches(reg); 7 System.out.println(b1);//输出结果true 8 } 9 }
(2)切割 我这里使用的是字符串中的split方法
案例一:切割一个或多个空格
1 //切割一个或者多个空格 2 import java.util.regex.*; 3 public class TestException{ 4 public static void main(String[] args) throws Exception { 5 String str ="aaa bbb ccc ddd eee"; 6 String [] arr =str.split(" +");//“ +”表示至少有一个空格 7 for(String s:arr){ 8 System.out.print(s); 9 } 10 } 11 }
运行结果;
aaabbbcccdddeee
案例二:通过.来切割字符串
1 //通过.来切割字符串 2 import java.util.regex.*; 3 public class TestException{ 4 public static void main(String[] args) { 5 String str2="zhangsan.lisi.wangwu"; 6 /* \\是代表转义字符,如果你直接放split("."),是无法切割的,因为.在正则表达式中.有它特有的含义 7 当你用转义之后\\.那么它就只代表一个点,而不具有特殊意义*/ 8 String [] arr2 =str2.split("\\."); 9 for(String s:arr2){ 10 System.out.println(s); 11 } 12 } 13 } 14 /* 补充:在java中需要转义的除了.外,还有需要先转义不能直接切割的: 15 * $ ( ) * + [ ] ? \ ^ { } | 16 * 这么几个大家用它来切割的时候,转义后就可以了 17 */
运行结果:
zhangsan lisi wangwu
案例三:用重复项来切割
1 //用重复项来切割 2 import java.util.regex.*; 3 public class TestException{ 4 public static void main(String[] args) { 5 String str3 ="wer#######tayuio****asdfg"; 6 String reg ="(..)"; //(.)代表第一个任意字符 \\1代表回去第一组数据 +代表1个或者多个 7 String [] arr3=str3.split(reg); 8 for(String s:arr3){ 9 System.out.println(s); 10 } 11 } 12 } 13 /* 补充:我怕初学者对"(.)\\1+",还没有搞懂,我这里在单独解释一下:(.)的字符视为一个整体。 \\1代表回去第一组数据 14 * 那它其实在这里也就代表(.),所以就相当于(.)(.)+,这里仅仅是相当于,也是为了好理解,其实他们还是有本质区别的 15 * 因为(.)==\\1,就是说如果.代表a,那么\\1也就代表a,而(.)≠(.),前面代表a后面可以代表b,因为前后两个点不是同一个点 16 * 我也不知道这样比较是否恰当, 反正意思就是这个意思 17 */
运行结果:
wer tayuio asdfg
(3)替换 使用String字符串汇总的方法
案例一:把重复的数据 替换为#
1 //把重复的数据 替换为# 2 import java.util.regex.*; 3 public class TestException{ 4 public static void main(String[] args) { 5 String str="wer#####yw****fghj"; 6 //把重复的数据 替换为# 7 str=str.replaceAll("(.)\\1+", "#");//(.) 第一个任意字符 \\1 取第一组数据 + 1个或者多个 8 System.out.println(str) ; 9 } 10 }
运行结果:
wer#yw#fghj
案列二:把重复项都变成单个
1 import java.util.regex.*; 2 public class TestException{ 3 public static void main(String[] args) { 4 String str="wer#####yw****fg???hj"; 5 //后一个参数的含义 可以通过$ 数字引用第一个参数中的组,这个美元符号代表就是前面小括号里的内容 6 str=str.replaceAll("(.)\\1+", "$1"); 7 System.out.println(str); 8 } 9 }
运行结果:
wer#yw*fg?hj
案例三:电话号码中间几位用*表示
1 import java.util.regex.*; 2 public class TestException{ 3 public static void main(String[] args) { 4 String str2="15889895644";//158****5644 5 str2=str2.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2"); 6 System.out.println(str2);// $1表示符号前面第一个小括号,$2代表第二个,如果有第三个小括号,那也可以$3; 7 } 8 }
运行结果:
158****5644
(4)获取 字符串中没有直接提供该功能 只能通过正则表达匹配
案例一:获取正则表达式所匹配的字符串
1 import java.util.regex.*; 2 public class TestException{ 3 public static void main(String[] args) { 4 String str="da jio zhu yi laa, ming tian fang jia laa"; 5 //1.定义规则 6 String reg="\\b[a-z]{3}\\b";//任意三个字符 \\b 是单词的边界(明白为什么加这个) 7 Pattern p =Pattern.compile(reg); 8 //3.通过正则表达对象 获取匹配器对象 并把操作的字符串关联 9 Matcher m =p.matcher(str); 10 while(m.find()){ //find()用来搜索与正则表达式相匹配的任何目标字符串 11 System.out.println(m.start()+"....."+m.group()+"..."+m.end()); 12 } //start()开始位置 group()用来返回包含了所匹配文本的字符串 end()结束位置 13 } 14 } 15 /* 有关: 在regex(正则表达式)包中,包括了两个类,Pattern(模式类)和Matcher(匹配器类)。 16 * 这个大家也可以多去了解 17 */
运行结果:
3.....jio...6 7.....zhu...10 14.....laa...17 35.....jia...38 39.....laa...42
四:最后来一个综合小案例
题目1:10.10.10.10 192.168.118.40 192.168.1.200 127.0.0.108 按照升序排序
1 import java.util.Arrays; 2 import java.util.regex.*; 3 public class TestException{ 4 public static void main(String[] args) { 5 String ip="10.10.10.10 192.168.118.40 192.168.1.200 127.0.0.108"; 6 /* 7 * 为了方便 每一个端都补零 保证每一个字段至少是三位 8 */ 9 ip=ip.replaceAll("(\\d+)", "00$1");//补0,让至少有三位数 10 11 ip=ip.replaceAll("0*(\\d{3})", "$1");//所有都变成三位数 12 13 String [] ips =ip.split(" +");//用空格来切割 14 Arrays.sort(ips);//升序排序 15 for(String x:ips){ 16 System.out.println(x.replaceAll("0*(\\d+)", "$1"));//还原 17 } 18 } 19 } 20 /** 这个题目或许看着不难,难就难在思维模式,它这每一步都很关键,也是希望大家在学习的途中多思考,而不是停留在看的基础上 21 */
运行结果:
10.10.10.10 127.0.0.108 192.168.1.200 192.168.118.40
这篇文章到这里结束了,接下来对于正则表达式我还会再写,比如Pattern(模式类)和Matcher(匹配器类),再比如如何获取文本中的电话号码等等深入的一些东西,不过最近应该不写了,
接下来我会写一些其它有关的知识。
Java使用patchca生成验证码
Patchca是Piotr Piastucki写的一个java验证码开源库,打包成jar文件发布,patchca使用简单但功能强大。
本例实现了自定义背景,由于生成图片较小,波动太大时会导致部分文字显示不全,所以更改了滤镜属性。
效果图:
代码如下:
package com.ninemax.cul.servlet; import java.awt.Color; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.io.IOException; import java.io.OutputStream; import java.util.ArrayList; import java.util.List; import java.util.Random; import javax.imageio.ImageIO; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import org.patchca.background.BackgroundFactory; import org.patchca.color.ColorFactory; import org.patchca.color.RandomColorFactory; import org.patchca.filter.ConfigurableFilterFactory; import org.patchca.filter.library.AbstractImageOp; import org.patchca.filter.library.WobbleImageOp; import org.patchca.font.RandomFontFactory; import org.patchca.service.Captcha; import org.patchca.service.ConfigurableCaptchaService; import org.patchca.text.renderer.BestFitTextRenderer; import org.patchca.text.renderer.TextRenderer; import org.patchca.word.RandomWordFactory; /** * 验证码生成类 * * 使用开源验证码项目patchca生成 * 依赖jar包:patchca-0.5.0.jar * 项目网址:https://code.google.com/p/patchca/ * * @author zyh * @version 1.00 2012-7-12 New */ public class ValidationCodeServlet extends HttpServlet { private static final long serialVersionUID = 5126616339795936447L; private ConfigurableCaptchaService configurableCaptchaService = null; private ColorFactory colorFactory = null; private RandomFontFactory fontFactory = null; private RandomWordFactory wordFactory = null; private TextRenderer textRenderer = null; public ValidationCodeServlet() { super(); } /** * Servlet销毁方法,负责销毁所使用资源. <br> */ public void destroy() { wordFactory = null; colorFactory = null; fontFactory = null; textRenderer = null; configurableCaptchaService = null; super.destroy(); // Just puts "destroy" string in log } public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doPost(request, response); } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("image/png"); response.setHeader("cache", "no-cache"); HttpSession session = request.getSession(true); OutputStream outputStream = response.getOutputStream(); // 得到验证码对象,有验证码图片和验证码字符串 Captcha captcha = configurableCaptchaService.getCaptcha(); // 取得验证码字符串放入Session String validationCode = captcha.getChallenge(); session.setAttribute("validationCode", validationCode); // 取得验证码图片并输出 BufferedImage bufferedImage = captcha.getImage(); ImageIO.write(bufferedImage, "png", outputStream); outputStream.flush(); outputStream.close(); } /** * Servlet初始化方法 */ public void init() throws ServletException { configurableCaptchaService = new ConfigurableCaptchaService(); // 颜色创建工厂,使用一定范围内的随机色 colorFactory = new RandomColorFactory(); configurableCaptchaService.setColorFactory(colorFactory); // 随机字体生成器 fontFactory = new RandomFontFactory(); fontFactory.setMaxSize(32); fontFactory.setMinSize(28); configurableCaptchaService.setFontFactory(fontFactory); // 随机字符生成器,去除掉容易混淆的字母和数字,如o和0等 wordFactory = new RandomWordFactory(); wordFactory.setCharacters("abcdefghkmnpqstwxyz23456789"); wordFactory.setMaxLength(5); wordFactory.setMinLength(4); configurableCaptchaService.setWordFactory(wordFactory); // 自定义验证码图片背景 MyCustomBackgroundFactory backgroundFactory = new MyCustomBackgroundFactory(); configurableCaptchaService.setBackgroundFactory(backgroundFactory); // 图片滤镜设置 ConfigurableFilterFactory filterFactory = new ConfigurableFilterFactory(); List<BufferedImageOp> filters = new ArrayList<BufferedImageOp>(); WobbleImageOp wobbleImageOp = new WobbleImageOp(); wobbleImageOp.setEdgeMode(AbstractImageOp.EDGE_MIRROR); wobbleImageOp.setxAmplitude(2.0); wobbleImageOp.setyAmplitude(1.0); filters.add(wobbleImageOp); filterFactory.setFilters(filters); configurableCaptchaService.setFilterFactory(filterFactory); // 文字渲染器设置 textRenderer = new BestFitTextRenderer(); textRenderer.setBottomMargin(3); textRenderer.setTopMargin(3); configurableCaptchaService.setTextRenderer(textRenderer); // 验证码图片的大小 configurableCaptchaService.setWidth(82); configurableCaptchaService.setHeight(32); } /** * 自定义验证码图片背景,主要画一些噪点和干扰线 */ private class MyCustomBackgroundFactory implements BackgroundFactory { private Random random = new Random(); public void fillBackground(BufferedImage image) { Graphics graphics = image.getGraphics(); // 验证码图片的宽高 int imgWidth = image.getWidth(); int imgHeight = image.getHeight(); // 填充为灰色背景 graphics.setColor(Color.GRAY); graphics.fillRect(0, 0, imgWidth, imgHeight); // 画100个噪点(颜色及位置随机) for(int i = 0; i < 100; i++) { // 随机颜色 int rInt = random.nextInt(255); int gInt = random.nextInt(255); int bInt = random.nextInt(255); graphics.setColor(new Color(rInt, gInt, bInt)); // 随机位置 int xInt = random.nextInt(imgWidth - 3); int yInt = random.nextInt(imgHeight - 2); // 随机旋转角度 int sAngleInt = random.nextInt(360); int eAngleInt = random.nextInt(360); // 随机大小 int wInt = random.nextInt(6); int hInt = random.nextInt(6); graphics.fillArc(xInt, yInt, wInt, hInt, sAngleInt, eAngleInt); // 画5条干扰线 if (i % 20 == 0) { int xInt2 = random.nextInt(imgWidth); int yInt2 = random.nextInt(imgHeight); graphics.drawLine(xInt, yInt, xInt2, yInt2); } } } } }
由于是个Servlet所以web.xml配置如下:
<servlet> <servlet-name>validationCode</servlet-name> <servlet-class>com.ninemax.cul.servlet.ValidationCodeServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>validationCode</servlet-name> <url-pattern>/validationCodeServlet.png</url-pattern> </servlet-mapping>
JSP引用(部分):
<img id="validationCode" alt="验证码图片" title="验证码图片" src="<%=path %>/validationCodeServlet.png" onclick="refreshCode(this)" /> <a id="aRecode" href="javascript:void(0);" onclick="refreshCode()">换一张</a>
JS重新载入图片方法(参考):
/** * 刷新验证码 * @param imgObj 验证码Img元素 */ function refreshCode(imgObj) { if (!imgObj) { imgObj = document.getElementById("validationCode"); } var index = imgObj.src.indexOf("?"); if(index != -1) { var url = imgObj.src.substring(0,index + 1); imgObj.src = url + Math.random(); } else { imgObj.src = imgObj.src + "?" + Math.random(); } }
数组增删 集合删除
一、数组增删
package com.test; import java.util.List; import java.util.ArrayList; import java.util.Set; import java.util.HashSet; public class ArrayBlock { /* 去掉数组中重复的值 */ public static void testA() { String [] str = {"cat", "dog", "pig", "dog",}; // 先把数组转为集合 List<String> list = new ArrayList<String>(); for (int i=0; i<str.length; i++) { if(!list.contains(str[i])) { list.add(str[i]); } } /* toArray(T[] a)用法 * 因为list集合默认是object类型,那传入new String[2],首先有泛型作用 * 如果list长度大于2,那new String[2]只有泛型作用,如果长度等于2 * 那就用new String[2]这个数组,如果小于2, 那数组多余部分为null */ String[] newStr = list.toArray(new String[1]); } //删除数组中其中一个元素 public static void testB() { String [] str = {"cat", "dog", "pig", "dog",}; //删除pig List<String> list = new ArrayList<String>(); for (int i=0; i<str.length; i++) { list.add(str[i]); } //list移除记得放外面 list.remove(2); //返回一个包含所有对象的指定类型的数组 String[] newStr = list.toArray(new String[1]); } //在数组中增加一个元素 public static void testC() { String [] str = {"cat", "dog", "pig", "dog",}; //增加pee List<String> list = new ArrayList<String>(); for (int i=0; i<str.length; i++) { list.add(str[i]); } // list.add()默认在集合最后插入数据,而 add(2, "pee")就指定在索引第二个位置插入 list.add(2, "pee"); String[] newStr = list.toArray(new String[1]); } }
二、集合删除数据
package com.test; import java.util.List; import java.util.ArrayList; import java.util.Iterator; public class ListBlock { public void deliect() { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("c"); //方法一: 用for增强方法删除 for (String str : list) { if (str.equals("a")) /* 在使用增强for循环的过程不能对元素进行删除、修改、增加的操作等操作。 * 但是,如果操作一下,立刻break跳出,也是不会报错的! */ list.remove(str); } //方法二:使用传统for循环遍历 for (int i = 0; i < list.size(); i++) { String str = list.get(i); if (str.equals("a")) { /* 不会报错,但会少都一条信息, 因为执行删除操作;删除完成,则集合后边的元素会自动前移, * 导致下次遍历漏掉一个元素,所以少删后面那个元素。 * 解决方法:在remove();方法下写上 --i; */ list.remove(i); } } //方法三:使用api提供的方法list.iterator(),这个方法不会出现问题 Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String str = iterator.next(); if (str.equals("a")) { iterator.remove(); } } } }
三、map集合删除数据
package com.test; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; public class ListBlock { public static void main(String[] args) { HashMap<String, String> map = new HashMap<String, String>(); map.put("1", "one"); map.put("2", "two"); map.put("3", "three"); map.put("4", "four"); // 删除元素 Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<String, String> entry = it.next(); String key = entry.getKey(); int k = Integer.parseInt(key); if (k % 2 == 1) { /*iterator的remove()方法,也有需要我们注意的地方: * 每调用一次iterator.next()方法,只能调用一次remove()方法。 * 调用remove()方法前,必须调用过一次next()方法。 */ it.remove(); } } } }
大家看下哪里不对,或者需要补充的,欢迎指点。
map集合排序
这篇文章讲的不仅仅是map排序,比如把对象按某一属性排序,它都可以解决这些问题。
比如,有N个对象,每个对象有个属性就是成绩,成绩分:优秀,良好,合格。那我们如何按照成绩的好坏进行排序呢,下面请看代码。
1.people对象
package com.test; /*people对象其实很简单,就提供了三个属性*/ class People { private String Name; //姓名 private String Score; //成绩 private String id; //学号 public String getName() { return Name; } public void setName(String name) { Name = name; } public String getScore() { return Score; } public void setScore(String score) { Score = score; } public String getId() { return id; } public void setId(String id) { this.id = id; } public People(String name, String score, String id) { super(); Name = name; Score = score; this.id = id; } }
2.主要方法
package com.test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.TreeMap; /** * Map进行多条件排序输出 * 成绩具有优秀,合格,不合格好吃属性。 * 入口Map * 首先按照优秀,合格,不合格排序 * 然后按照人名的标志Id排序 * 出口Map * * */ public class MainSort { /** * 准备参数,创建对象 * @return */ private static Map<String, People> getPeopleMap() { Map<String,People> PeopleMap = new TreeMap<>(); // 创建对象 People b = new People("小明" , "优秀", "b"); People a = new People("小红" , "合格", "a"); People c = new People("丁丁" , "合格", "c"); People d = new People("冬冬" , "良好", "d"); People e = new People("小黄" , "优秀", "e"); People f = new People("小李" , "良好", "f"); People g = new People("小钟" , "优秀", "g"); // 添加乱序key值,把对象放入map集合 PeopleMap.put("xniem", b); PeopleMap.put("akjd", a); PeopleMap.put("uioo", c); PeopleMap.put("qw84", d); PeopleMap.put("584sdf'", e); PeopleMap.put("4aisdf", f); PeopleMap.put("458jsf", g); return PeopleMap; } /** * 循环打印Map */ private static void show(Map<String, People> PeopleMap) { // 循环Map 这个打印肯定是无序的,也不是按放入的先后顺序 for (Map.Entry<String, People> PeopleOneMap : PeopleMap.entrySet()) { People People = PeopleOneMap.getValue(); System.out.println(People.getName() + " " + People.getScore()+ " " + People.getId() ); } } /* * 由于List能够直接使用Collections进行排序 * 但是Map不行。 * 这边所做的操作就是先将Map--》List * 然后对List进行排序 * 然后在讲List--》转换成LinkedHashMap * */ public static Map<String, People> sortMapByValue(Map<String, People> PeopleMap) { if (PeopleMap == null || PeopleMap.isEmpty()) { return null; } // LinkedHashMap是有序的、或者TreeMap都是有序的(这里只能用LinkedHashMap) Map<String, People> sortedMap = new LinkedHashMap<String, People>(); /* Set set=PeopleMap.entrySet(); PeopleMap.entrySet()返回的是一个set集合 * 再讲ArrayList(Collection<? extends E> c) 可以放collection,set集合是其子类,map不行哦 * 这步就是把map集合转为ArrayList集合 */ List<Map.Entry<String, People>> entryList = new ArrayList<Map.Entry<String, People>>(PeopleMap.entrySet()); //这步是关键,进过这步之后,entryList已经是个有序的ArrayList集合了 Collections.sort(entryList, new MapValueComparator()); //通过迭代器取出 Iterator<Map.Entry<String, People>> iter = entryList.iterator(); // Map.Entry<String, People>,就是包装了一个map节点,这个节点封装了key,value值,以及别的值(比如hashmap中哈希码和next指针) Map.Entry<String, People> tmpEntry = null; while (iter.hasNext()) { tmpEntry = iter.next(); sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue()); } return sortedMap; } /** * 主方法 * */ public static void main(String[] args) { // 获取Map Map<String,People> PeopleMap = getPeopleMap(); // 打印未排序的Map show(PeopleMap); System.out.println("-----------before-----------"); // 打印排序完了的Map show(MainSort.sortMapByValue(PeopleMap)); System.out.println("-----------after------------"); } }
3.Comparator方法
package com.test; import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; class MapValueComparator implements Comparator<Map.Entry<String, People>> { @Override public int compare(Entry<String, People> o1, Entry<String, People> o2) { // 获取比较的两个对象 People People1 = o1.getValue(); People People2 = o2.getValue(); // 将成绩映射成具有比较关系的字符1、2、3 Map<String,Integer> tasteLev = new HashMap<>(); tasteLev.put("优秀", 1); tasteLev.put("良好", 2); tasteLev.put("合格", 3); int cr = 0; // 判断成绩 int a = tasteLev.get(People2.getScore())-tasteLev.get(People1.getScore()); if (a!=0) { cr = (a>0) ? -1 : 2; } else { /*其实上面就可以按成绩优秀,良好,合格排序了, *在做一步目的,就是在成绩相同的情况下,在按照学号进行排序 */ // 按照对应的Id排序 a = People2.getId().compareTo(People1.getId()); if (a!=0) { cr = (a>0)? -2 : 1; } } /* 注意上面对一个返回值对应的就是形成比较层次 * 上层 * --> 2 * --> -1 * 下层 * --> 1 * --> -2 */ return cr; } }
最后我们再来看后台输出
Serializable--初解
一 序列化是干什么的?
我们知道,在jvm中引用数据类型存在于栈中,而new创建出的对象存在于堆中。如果电脑断电那么存在于内存中的对象就会丢失。那么有没有方法将对象保存到磁盘(对象持久化存储)或通过网络传输到远处的其他地方呢?
答案是可以,但是我们必须要求所有支持持久化存储的类实现Serializable接口。Serializable就像个通行证,只有持有这个通行证,jvm才让类创建的对象进行持久化。这个接口将类与一个称为serialVersionUID的变量关联起来,这个serialVersionUID就是在反序列化中用来确定由哪个类来加载这个对象。
二、什么情况下需要序列化
a)当你想把的内存中的对象状态保存到一个文件中或者数据库中时候;
b)当你想用套接字在网络上传送对象的时候;
c)当你想通过RMI传输对象的时候;
三、JavaBean为什么要实现java.io.Serializable接口实现序列化?
找了个比较好理解的例子:客户端访问了某个能开启会话功能的资源, web服务器就会创建一个与该客户端对应的HttpSession对象,每个HttpSession对象都要站用一定的内存空间。如果在某一时间段内访问站点的用户很多,web服务器内存中就会积累大量的HttpSession对象,消耗大量的服务器内存,即使用户已经离开或者关闭了浏览器,web服务器仍要保留与之对应的HttpSession对象,在他们超时之前,一直占用web服务器内存资源。
web服务器通常将那些暂时不活动但未超时的HttpSession对象转移到文件系统或数据库中保存,服务器要使用他们时再将他们从文件系统或数据库中装载入内存,这种技术称为Session的持久化。
将HttpSession对象保存到文件系统或数据库中,需要采用序列化的方式将HttpSession对象中的每个属性对象保存到文件系统或数据库中;将HttpSession对象从文件系统或数据库中装载如内存时,需要采用反序列化的方式,恢复HttpSession对象中的每个属性对象。所以存储在HttpSession对象中的每个属性对象必须实现Serializable接口。当然如果不是存储在session中的JavaBean可以不用存储哈。
举个简单例子:
Student
import java.io.Serializable; public class Student implements Serializable { /*serialVersionUID来决定由哪个类来加载存在于文件中的对象 * 如果指定serialVersionUID的数值,那就能使得其不再与类的成员变量相关联 * 不然你已经把对象保存到数据库,这个时候你再给这个对象新增属性,那么反序列化 * 就会报:本地类不匹配的错误,但如果指定serialVersionUID值那就不会报错。 */ private static final long serialVersionUID = -5182532647273106745L; //成员变量写成static的话是不能被持久化的 public static String countryName="china"; private String name; private int age; //如果想对非静态的数据也不想序列化,则需要加入关键字 transient String sex; /* 提供set和get方法,无参和有参方法*/ }
测试类
1 import java.io.*; 2 public class SerializableTest { 3 public static void main(String[] args) { 4 writeObj(); 5 readObj(); 6 } 7 public static void writeObj() 8 { 9 Student student=new Student("小筱", 1, "女"); 10 try { 11 ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d:\\student.txt")); 12 oos.writeObject(student); 13 oos.close(); 14 } catch (IOException e) { 15 e.printStackTrace(); 16 } 17 } 18 public static void readObj() 19 { 20 try { 21 ObjectInputStream ooi=new ObjectInputStream(new FileInputStream("d:\\student.txt")); 22 try { 23 Object obj=ooi.readObject(); 24 Student student=(Student)obj; 25 System.out.println("age:"+student.getAge()+",name:"+student.getName()+",countryName:"+student.countryName+",sex:"+student.getSex()); 26 } catch (ClassNotFoundException e) { 27 e.printStackTrace(); 28 } 29 ooi.close(); 30 } catch (IOException e) { 31 e.printStackTrace(); 32 } 33 } 34 }
第二个小例子我没有亲自测试:用套接字在网络上传送对象
1.首先建立要传输的对象
1 //建立用来持续化的对象 2 import java.io.Serializable; 3 public class ObjectSeri implements Serializable{ 4 5 //成员变量写成static的话是不能被持久化的 6 //private关键字是不能被持久化的,脱离了JVM,成员变量是不在JVM的安全机制之内 7 private String name; 8 private String age; 9 /*set和get方法*/ <span style="color:#333333;"><strong> 10 </strong></span>
2.有了传输的对象,下一步就是建立一个服务端线程来监听socket端口,并且在run方法里面实现读取对象的数据
1 import java.io.IOException; 2 import java.io.ObjectInputStream; 3 import java.net.ServerSocket; 4 import java.net.Socket; 5 //serverTest类继承thread类,监听端口来的信息 6 public class serverTest extends Thread { 7 // private final String serverIP = "127.0.0.1"; 8 private final int serverPort = 3400; 9 private ServerSocket server; 10 public serverTest() { 11 try { 12 // ServerSocket server=new ServerSocket(serverPort); 13 server = new ServerSocket(serverPort); 14 System.out.println("正在监听3400端口"); 15 } catch (IOException e) { 16 e.printStackTrace(); 17 } 18 } 19 public void run() { 20 Socket socket = null; 21 ObjectInputStream in; 22 while (true) { 23 try { 24 synchronized (server) { 25 socket = server.accept(); 26 } 27 System.out.println("当前的连接是:" 28 + socket.getInetAddress().toString()); 29 socket.setSoTimeout(20000); 30 in = new ObjectInputStream(socket.getInputStream()); 31 ObjectSeri data = (ObjectSeri) in.readObject(); 32 System.out.println("The name is:" + data.getName() 33 + "and age is:" + data.getAge()); 34 in.close(); 35 in = null; 36 socket.close(); 37 } catch (IOException | ClassNotFoundException e) { 38 e.printStackTrace(); 39 } 40 } 41 } 42 public static void main(String args[]) { 43 (new serverTest()).start(); 44 }
3.最后,建立一个客户端来测试下
1 import java.io.ObjectOutputStream; 2 import java.net.InetSocketAddress; 3 import java.net.Socket; 4 //建立一个client测试类 5 public class TestClient { 6 private String address = "127.0.0.1"; 7 private int port = 3400; 8 9 public TestClient() { 10 // Prepare the data need to transmit 11 ObjectSeri data = new ObjectSeri(); 12 data.setName("Scott"); 13 data.setAge("34"); 14 Socket client = new Socket(); 15 InetSocketAddress adr = new InetSocketAddress(this.address, this.port); 16 try { 17 client.connect(adr, 10000); 18 ObjectOutputStream out = new ObjectOutputStream( 19 client.getOutputStream()); 20 // send object 21 out.writeObject(data); 22 out.flush(); 23 out.close(); 24 out = null; 25 data = null; 26 client.close(); 27 client = null; 28 } catch (java.io.IOException e) { 29 30 System.out.println("IOException :" + e.toString()); 31 } 32 } 33 public static void main(String[] args) { 34 new TestClient(); 35 } 36 } <span style="color: rgb(51, 51, 51);"> </span>
输出结果如下:
正在监听3400端口
当前的连接是:/127.0.0.1
The name is:Scottand age is:34
今天:2017:12:05 发现自己用到了,就是jquery表单提交,用post提交,这样有个最大的好处,就是我不用一个值一个值提交,而是把表单提交过去
$.post('your url', $("form").serialize(), function(data) { // your code } });
小筱的窝:水滴石穿,成功的速度一定要超过父母老去的速度