java校验和_java里如何正确计算检验和

⑴ java密码复杂度校验

qaz，qwer这种都不能通过？这不算连续的吧，要实现这样的你只能把连续的可能性列出来，比如[q,w,e,r,t,y,u,i,o,p]为一组，比如你的密码包含wert四个字母，那你可以把这四个字母拆开，先使用w从数组中开始遍历，发现w与数组中第二个元素相等，那么再取密码的第二个字母w与数组中的第三个元素比较，如果相等再比较下一个，满足有三个字母对应上的就直接返回校验不通过。
如果是要校验0123456789和abcdefg这样的连续的，你可以把密码的拆分成char数组，数组每个元素转成数值其实就是这个字符的ascii码，然后比较相邻的三个元素ascii码是不是连续的就可以判断出来，不过这种方法需要注意一点，比如'@'的ascii为64，'A'的ascii为65也是连续的，需要自己进行筛选。觉得这种方法麻烦的话也可以使用上面的方法把连续的都先列举出来。
我只写一下我的想法，仅供参考。

⑵ java校验json格式及内容

代码如下
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;

public class JsonValidator {

private CharacterIterator it;
private char c;
private int col;

public JsonValidator(){
}

/**
* 验证一个字符串是否是合法的JSON串
*
* @param input 要验证的字符串
* @return true-合法，false-非法
*/
public boolean validate(String input) {
input = input.trim();
boolean ret = valid(input);
return ret;
}

private boolean valid(String input) {
if ("".equals(input)) return true;

boolean ret = true;
it = new StringCharacterIterator(input);
c = it.first();
col = 1;
if (!value()) {
ret = error("value", 1);
} else {
skipWhiteSpace();
if (c != CharacterIterator.DONE) {
ret = error("end", col);
}
}

return ret;
}

private boolean value() {
return literal("true") || literal("false") || literal("null") || string() || number() || object() || array();
}

private boolean literal(String text) {
CharacterIterator ci = new StringCharacterIterator(text);
char t = ci.first();
if (c != t) return false;

int start = col;
boolean ret = true;
for (t = ci.next(); t != CharacterIterator.DONE; t = ci.next()) {
if (t != nextCharacter()) {
ret = false;
break;
}
}
nextCharacter();
if (!ret) error("literal " + text, start);
return ret;
}

private boolean array() {
return aggregate('[', ']', false);
}

private boolean object() {
return aggregate('{', '}', true);
}

private boolean aggregate(char entryCharacter, char exitCharacter, boolean prefix) {
if (c != entryCharacter) return false;
nextCharacter();
skipWhiteSpace();
if (c == exitCharacter) {
nextCharacter();
return true;
}

for (;;) {
if (prefix) {
int start = col;
if (!string()) return error("string", start);
skipWhiteSpace();
if (c != ':') return error("colon", col);
nextCharacter();
skipWhiteSpace();
}
if (value()) {
skipWhiteSpace();
if (c == ',') {
nextCharacter();
} else if (c == exitCharacter) {
break;
} else {
return error("comma or " + exitCharacter, col);
}
} else {
return error("value", col);
}
skipWhiteSpace();
}

nextCharacter();
return true;
}

private boolean number() {
if (!Character.isDigit(c) && c != '-') return false;
int start = col;
if (c == '-') nextCharacter();
if (c == '0') {
nextCharacter();
} else if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
if (c == '.') {
nextCharacter();
if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
}
if (c == 'e' || c == 'E') {
nextCharacter();
if (c == '+' || c == '-') {
nextCharacter();
}
if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
}
return true;
}

private boolean string() {
if (c != '"') return false;

int start = col;
boolean escaped = false;
for (nextCharacter(); c != CharacterIterator.DONE; nextCharacter()) {
if (!escaped && c == '\\') {
escaped = true;
} else if (escaped) {
if (!escape()) {
return false;
}
escaped = false;
} else if (c == '"') {
nextCharacter();
return true;
}
}
return error("quoted string", start);
}

private boolean escape() {
int start = col - 1;
if (" \\\"/bfnrtu".indexOf(c) < 0) {
return error("escape sequence \\\",\\\\,\\/,\\b,\\f,\\n,\\r,\\t or \\uxxxx ", start);
}
if (c == 'u') {
if (!ishex(nextCharacter()) || !ishex(nextCharacter()) || !ishex(nextCharacter())
|| !ishex(nextCharacter())) {
return error("unicode escape sequence \\uxxxx ", start);
}
}
return true;
}

private boolean ishex(char d) {
return "0123456789abcdefABCDEF".indexOf(c) >= 0;
}

private char nextCharacter() {
c = it.next();
++col;
return c;
}

private void skipWhiteSpace() {
while (Character.isWhitespace(c)) {
nextCharacter();
}
}

private boolean error(String type, int col) {
System.out.printf("type: %s, col: %s%s", type, col, System.getProperty("line.separator"));
return false;
}
public static void main(String[] args){
String jsonStr = "{\"website\":\"open-open.com\"}";
System.out.println(jsonStr+":"+new JsonValidator().validate(jsonStr));
}
}

⑶ java里如何正确计算检验和

importjava.security.MessageDigest;

publicclassMD5HashingExample
{
publicstaticvoidmain(String[]args)throwsException
{
	Stringpassword="123456";

MessageDigestmd=MessageDigest.getInstance("MD5");
md.update(password.getBytes("UTF-8"));//orGBK

bytebyteData[]=md.digest();

//
StringBuffersb=newStringBuffer();
for(inti=0;i<byteData.length;i++){
sb.append(Integer.toString((byteData[i]&0xff)+0x100,16).substring(1));
}

System.out.println("Digest(inhexformat)::"+sb.toString());

//
StringBufferhexString=newStringBuffer();
	for(inti=0;i<byteData.length;i++){
		Stringhex=Integer.toHexString(0xff&byteData[i]);
		if(hex.length()==1)hexString.append('0');
		hexString.append(hex);
	}
	System.out.println("Digest(inhexformat)::"+hexString.toString());
}
}

⑷ JAVA中前台校验和后台校验哪个安全,如果后台校验安全为什么不取消前台校验

前台的验证一般是通过Javascript，js代码是可以被禁用和篡改的，所以相对后台检验而言，安全性会低一些。

前台校验不需要服务器返回数据的选项，例如密码为空啊，邮箱不合法啊，但是也需要后台校验，例如用户名重复校验，必须提交后台查询数据库，返回是否重复。原则就是能前台JS校验的就前台校验，一来快捷，二来减少服务器的压力。

⑸ java文件中校验日期和时间格式，急求解答

SimpleDateFormatsdf=newSimpleDateFormat(format);
字符串的话判断
try{
returnstr!=null&&sdf.format(sdf.parse(str)).equals(str);
}catch(e){
returnfalse;
}

日期的话
try{
returndate!=null&&sdf.parse(sdf.format(str)).getTime()==date.getTime()
}catch(e){
returnfalse;
}

⑹ java中如何进行密码校验

一般有2种
办法，
一是用正则表达式匹配法；二就是要你自己写校验字符串的
java代码

⑺ 如何使用java validation api进行参数校验

JAVA中通过Hibernate-Validation进行参数验证
在开发JAVA服务器端代码时，我们会遇到对外部传来的参数合法性进行验证，而hibernate-validator提供了一些常用的参数校验注解，我们可以拿来使用。
1.maven中引入hibernate-validator对应的jar：
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>4.3.1.Final</version>
</dependency>

2.在Model中定义要校验的字段（即该字段不能为空，并且最大长度为14）：

import javax.validation.constraints.Size;
import org.hibernate.validator.constraints.NotEmpty;

public class PayRequestDto {

/**
* 支付完成时间
**/
@NotEmpty(message="支付完成时间不能空")
@Size(max=14,message="支付完成时间长度不能超过{max}位")
private String payTime;

public String getPayTime() {
return payTime;
}

public void setPayTime(String payTime) {
this.payTime = payTime;
}
}

3.定义Validation工具类：

import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import org.hibernate.validator.HibernateValidator;
import com.atai.framework.lang.AppException;

public class ValidationUtils {

/**
* 使用hibernate的注解来进行验证
*
*/
private static Validator validator = Validation
.byProvider(HibernateValidator.class).configure().failFast(true).buildValidatorFactory().getValidator();

/**
* 功能描述: <br>
* 〈注解验证参数〉
*
* @param obj
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
public static <T> void validate(T obj) {
Set<ConstraintViolation<T>> constraintViolations = validator.validate(obj);
// 抛出检验异常
if (constraintViolations.size() > 0) {
throw new AppException("0001", String.format("参数校验失败:%s", constraintViolations.iterator().next().getMessage()));
}
}
}

4.在代码中调用工具类进行参数校验：
ValidationUtils.validate(requestDto);

以下是对hibernate-validator中部分注解进行描述：
@AssertTrue 用于boolean字段，该字段只能为true
@AssertFalse 该字段的值只能为false
@CreditCardNumber 对信用卡号进行一个大致的验证
@DecimalMax 只能小于或等于该值
@DecimalMin 只能大于或等于该值
@Digits(integer=,fraction=) 检查是否是一种数字的整数、分数,小数位数的数字
@Email 检查是否是一个有效的email地址
@Future 检查该字段的日期是否是属于将来的日期
@Length(min=,max=) 检查所属的字段的长度是否在min和max之间,只能用于字符串
@Max 该字段的值只能小于或等于该值
@Min 该字段的值只能大于或等于该值
@NotNull 不能为null
@NotBlank 不能为空，检查时会将空格忽略
@NotEmpty 不能为空，这里的空是指空字符串
@Null 检查该字段为空
@Past 检查该字段的日期是在过去
@Pattern(regex=,flag=) 被注释的元素必须符合指定的正则表达式
@Range(min=,max=,message=) 被注释的元素必须在合适的范围内
@Size(min=, max=) 检查该字段的size是否在min和max之间，可以是字符串、数组、集合、Map等
@URL(protocol=,host,port) 检查是否是一个有效的URL，如果提供了protocol，host等，则该URL还需满足提供的条件
@Valid 该注解主要用于字段为一个包含其他对象的集合或map或数组的字段，或该字段直接为一个其他对象的引用，这样在检查当前对象的同时也会检查该字段所引用的对象

⑻ java 方法参数怎么优雅校验

建议参考validation框架，比较常用的实现hibernate-validation，使用@annatation进行声明式校验，并且校验代码可以复用，同时约束应用框架的数据标准。

⑼ java 如何计算校验和，比如如下这段代码如何修改

您好，1、编写一个计算机程序用来计算一个文件的16位效验和。最快速的方法是用一个32位的整数来存放这个和。记住要处理进位（例如，超过16位的那些位），把它们加到效验和中。
要求：1）以命令行形式运行：check_sum infile
其中check_sum为程序名，infile为输入数据文件名。
2）输出：数据文件的效验和
附：效验和（checksum)
 原理：把要发送的数据看成二进制整数序列，并计算他们的和。若数据字节长度为奇数，则在数据尾部补一个字节的0以凑成偶数。
 例子：16位效验和计算，下图表明一个小的字符串的16位效验和的计算。
为了计算效验和，发送计算机把每对字符当成16位整数处理并计算效验和。如果效验和大于16位，那么把进位一起加到最后的效验和中。

⑽ 在java web中对输入数据进行校验的方式有多少种分别都是什么

要用JavaScript，使用下面的标记：
script language="javascript"
//JavaScript代码
/script
要写方法
function check(){
}
方法可以不用定义返回值，但是可以有返回值
获取用户输入的值：
document.form1.username.value
document表示当前文档，form1表示表单的名字，username表示该表单中表单元素的名字，value表示得到值
把表单提交与方法关联：可以使用表单的onSubmit事件。
onSubmit="return check();"
例：
script language="javascript"
function check(){
username = document.form1.username.value;
if(username.length6 || username.length8){
alert("用户名长度不合适!");
return false;
}else{
return true;
}
}
/script
使用button的onClick事件进行验证：
首先要把提交按钮修改成普通按钮;
在普通按钮上增加事件：onClick="javascript:check()"
在验证成功的时候，提交表单：document.form1.submit();

导航:首页 > 编程语言 > java校验和

java校验和

与java校验和相关的资料