java编程基础 正则表达式
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java编程基础 正则表达式相关的知识,希望对你有一定的参考价值。
急救,各位大神,为什么我写的几个正则表达式都有问题,除了验证密码的。外本人小菜鸟,正在做一个ATM自动取款机的程序,正则表达式程序如下:
//判断用户名是否符合规则(必须十一位数,包括数字和字母,且以字母开头;)
public static boolean judgeName(String name)
Pattern pattern = Pattern.compile("^[a-z][a-zA-Z0-9]10|[A-Z][a-zA-Z0-9]10$");//将给定的正则表达式编译到模式中
Matcher matcher = pattern.matcher(name);//创建匹配给定输入与此模式的匹配器
return matcher.find();//当且仅当输入序列的子序列匹配此匹配器的模式时才返回 true
//判断输入的密码是否合法(由六位纯数字组成)这个刚刚试了没有问题
public static boolean judgeCode(String code)
Pattern pattern = Pattern.compile("^[0-9]6$");//将正则表达式编译到模式中
Matcher matcher = pattern.matcher(code);//创建给定输入与此模式匹配的匹配器
return matcher.find();//当且仅当输入序列的子序列匹配此匹配器的模式时才返回true
//判读存款金额是否合法(单次存款金额不超过10000元(包括),且必须是100的整数倍)
public static boolean depositAmount(String money)
Pattern pattern = Pattern.compile("^[0-9]00|[0-9]200$");
Matcher matcher = pattern.matcher(money);
return matcher.find();
//判断取款金额是否合法(单次取款金额不超过3000(包括)元,且必须是100的整数倍.)
public static boolean withdrawAmount(String money)
Pattern pattern = Pattern.compile("^[0-9]00|[0-2][0-9]00$");
Matcher matcher = pattern.matcher(money);
return matcher.find();
望大神指点迷津。
//必须十一位数,包括数字和字母,且以字母开头
Pattern pattern = Pattern.compile("^[a-zA-Z][a-zA-Z0-9]10$");//将给定的正则表达式编译到模式中
//判读存款金额是否合法(单次存款金额不超过10000元(包括),且必须是100的整数倍)
Pattern pattern = Pattern.compile("^[1-9][0-9]0,100$|^10000$");
//判断取款金额是否合法(单次取款金额不超过3000(包括)元,且必须是100的整数倍.)
Pattern pattern = Pattern.compile("^[1-3][0-9]0,100$"); 参考技术A
//判断用户名是否符合规则(必须十一位数,包括数字和字母,且以字母开头;)
Pattern pattern = Pattern.compile("^[a-zA-Z]|[a-zA-Z0-9]10$");//将给定的正则表达式编译到模式中
//判读存款金额是否合法(单次存款金额不超过10000元(包括),且必须是100的整数倍)
Pattern pattern = Pattern.compile("^[1-9][0-9]0,100$|^10000$");
//判断取款金额是否合法(单次取款金额不超过3000(包括)元,且必须是100的整数倍.)
Pattern pattern = Pattern.compile("^3000$|^[3-9]00$|^[1][0-9]0,100$|^[2][0-9]0,100$");
参考技术B 现在都是信息化的时代,没有一门好的技术是难以在社会之中立足的,现在的电脑技术飞速增长,每家公司都需要电脑人才,你可以去学习电脑专业,
在这个领域中还是有很大的发展空间的,只要自己好好学习,以后的前景不可限量。
Java基础
Java概述
应用场景
学习路线
-
JavaSE(18-20天)
计算机基础
博客的重要性
Java基础语法
流程控制和方法
数组
面向对象
异常
常用类
集合框架
IO
多线程
GUI(可选,纯桌面端像qq这样的应用,爬虫)
网络编程
注解和反射
JUC编程(高并发编程)
JVM探究
[拓展]23种设计模式
[拓展]XML
[拓展]数据结构和算法
[拓展]正则表达式
-
数据库(4天)
MySQL
JDBC
UML类图
数据库设计
-
前端(7天)
HTML
CSS
JS
jQuery
Layui/BootStrap
Vue
- JavaWeb(7天)
Tomcat
Http
Maven
Servlet
Session,Cookie
JSP
三层架构
过滤器
监听器
文件上传
邮件收发
[拓展] 富本编辑器
学完上面四个阶段可基本搭建网站了,但是过程比较繁琐。
- SSM框架(9天)
Git
MyBatis
Spring
SpringMVC
学完SSM,常规企业开发没有问题。
- Linux(7天)
Linux基础
Redis
Nginx
Docker
Linux几乎将所有大型公司的服务器市场都占领了。
以上6各阶段是作为JAVA程序员进入小公司的基本要求。
以下是微服务学习阶段
- SpringBoot(8天)
SpringBoot基础
SpringBoot配置及原理
SpringBoot持久层操作
SpringBoot Web开发
SpringBoot 缓存
SpringBoot 消息
SpringBoot 检索
SpringBoot 任务
SpringBoot 安全
Dubbo+Zookeeper 分布式开发
- SpringCloud(8天)
微服务即及微服务架构
SpringCloud
Eureka服务注册与发现
Feign,Ribbon负载均衡
Hystrix熔断机制
Zuul路由网关
SpringCloud Config配置中心
- Hadoop(8天)
大数据时代
Hadoop简介
Hadoop环境搭建
HDFS
MapReduce
Yarn
Hive
Hbase
博客重要性
总结和思考,逻辑思维文笔组织能力。
wordpress
typecho
Markdown基础语法
划线,斜体,加粗,分割线;
哈哈哈哈
哈哈
哈哈哈
计算机预科
计算机硬件,软件
一些物理装置按照系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
冯诺依曼体系结构
快捷键
window+E 打开我的电脑;
Dos命令
cmd 在资源路径地址栏
dir 查看目录文件
cd … 上一级
cls 清理
exit 退出
cd /d 路径 跳到当前路径
md 创建文件夹
rd 删除目录
cd> 创建文件
del 删除文件
计算机发展史
二进制->汇编->高级语言->、、、
大体分为面向过程和对象:C是面向过程,C++和JAVA是面向对象。
Java三大版本
write once ,run anywhere…JVM使其可移植跨平台
标准版、嵌入式开发、E企业级开发
JavaSE、JavaME、JavaEE
Java2标准版(J2SE):桌面,控制台开发
Java2移动版(J2ME):手机,小家电
Java2企业版(J2EE):服务器,web端
3高:高可用,高性能,高并发。
Java特性和优势
简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性
JDK,JRE,JVM
JDK->JRE->JVM 由外到里具有包含关系
JDK:java develpoment kit
JRE:java run environment
JVM:java virtual machine
Java运行机制
编译型,解释型
Java基础语法
数据类型
强类型语言(Java):所有变量使用严格符合规定
弱类型语言(JavaScript)
Java数据类型分为2大类
基本类型 (primitive type)
引用类型 (reference type)
8个基本类型:
整数类型
byte:1字节
short:2字节
int:4字节
long:8字节
浮点类型
float:4字节
double:8字节
字符串类型
char:2字节
boolean类型
boolean:1字节
long num4=30L;//long类型需要在后面加个L
float num5=50.1F;
String不是一个关键字是一个类。
数据类型拓展及面试题讲解
整数拓展
二进制0b
八进制0
十进制
十六进制0x
int i1=10;
int i2=010;
int i3=0x10;
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
//输出
10
8
16
浮点数拓展
银行业务怎么表示?
用float和double是有问题的。。。
float f=0.1f;
double d=1.0/10;
System.out.println(f==d);
//
flase?
float f1=233333322222f;
float f2=f1+1;
System.out.println(f1==f2);
//
true?
float 有限 离散 舍入误差
String s1=new String("hello world");
String s2=new String("hello world");
System.out.println(s1==s2);
String s3="hello world";
String s4="hello world";
System.out.println(s3==s4);
//
false
true
String 对象,从内存分析
StringBuffer和StringBuilder
StringBuffer:可变长,append(),多线程数据量较大,效率低安全;
StringBuilder:可变长,append(),单线程数据量较大,效率高不安全;
最好不使用浮点数进行比较!!!
推荐使用大数类型:BigDecimal 数学工具类
字符拓展
强制类型转换
char c1='a';
char c2='中';
System.out.println(c1);
System.out.println(c2);
System.out.println((int)c1);
System.out.println((int)c2);
//
a
中
97
20013
所有字符本子还是数字
编码 Unicode 表: 2字节 0-66536 Excel表格最长2^16
U0000 UFFFF
char c='\\u0061';
System.out.println(c);
//
a
转义字符
\\t 制表符4空格
\\n 换行
类型装换
自动转换:低->高
运算过程中不同类型运算先转同一类型然后进行运算
byte->short->int->long->float->double
强制转换:高->低
问题
不能对布尔值进行转哈
转换是可能存在内存溢出和精度损失
int a=10_0000_0000;
System.out.println(a);
//JDk7新特性可以用下划线分割数字
操作比较大的数时候注意溢出问题
int a=10_0000_0000;
int b=20;
int total1=a*b;
System.out.println(total1);
long total2=a*b;//转换之前已经存在问题了?
System.out.println(total2);
//
-1474836480
-1474836480
long total3=a*((long)b);
System.out.println(total3);
//
20000000000
变量
局部变量:必须声明和初始化
实例变量:从属对象,不进行初始化默认为0 null false
类变量:static 从属类,随着类一起存在或消失
常量:final 一般使用大写字符 MAX_VALUE
变量:驼峰命名规则
类型:首字母大写GoodMan或者驼峰原则
方法名:首字母小写和驼峰原则
运算符
短路运算
int c=5;
boolean d=(c<4)&&(c++<4);
System.out.println(c);
System.out.println(d);
//
5
false
位运算
& | ^ ~ >> <<
拼接前后问题
int a=10;
int b=20;
System.out.println(a+b+"");
System.out.println(""+a+b);
//
30
1020
包机制
一般利用公司域名倒置作为包名 www.bai.com com.baidu.www
通配符:com.baidu.*
JavaDoc
javadoc命令是用来生成自己API文档的
@author作者名
@version版本号
@since指明需要最早使用的jdk版本
@param参数名
@return返回值情况
@throws异常抛出情况
/****回车生成注释
进入代码路径然后 cmd
javadoc -encoding UTF-8 -charset UTF-8 XXX.java
会生成一个index.html文档类开发文档。
Java流程控制
scanner
hashNext()和hasNextLine()判断是否还有输入的数据
增强for循环
for(声明语句:表达式){
//
}
打印三角形:
//打印三角形:分解为4部分
for(int i=1;i<=5;i++){
//打印左半三角形:
//第1部分用空格填充
for(int j=5;j>=i;j--){
System.out.print(" ");
}
//第2部分用*填充
for(int j=1;j<=i;j++){
System.out.print("*");
}
//打印做右半三角形:
for(int j=1;j<i;j++){
System.out.print("*");
}
System.out.println();
}
Java方法
设计方法的原则:方法的本意是功能块,就是实现某个功能的语句的集合,我们设计方法的时候,最好保持方法的原子性:就是一个方法只完成1个功能,这样利于我们后期拓展。
方法的重载
重载就是在一个类中,有相同的函数名称,但形参不同的函数。
方法的重载规则:
方法名称必须相同;
参数列表必须不同(个数,类型,排列顺序);
返回类型可同可不同,但仅仅返回类型不同不足以成为方法的重载。
命令行传参
package LeetCode;
public class Main {
public static void main(String[] args) {
//遍历参数
for (int i = 0; i < args.length; i++) {
System.out.println("args["+i+"]:"+args[i]);
}
}
}
注意路径问题:
可变参数,不定向参数
参照命令行传参,解决重载出现过多方法问题。
- JDK1.5开始,Java支持传递同类型的可变参数给一个方法;
- 在声明方法中,在指定参数类型后加一个省略号(…);
- 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。
可变长参数本质就是一个数组:
public class Main {
public static void text(int... i){//表明有多个i
for(int j=0;j<i.length;j++)
System.out.println(i[j]);
}
public static void main(String[] args) {
text(1,2,3,44,22);
System.out.println("===================");
text(new int[]{1,2,3,44,22}); //可变参数本质还是一个数组
}
}
递归
public class Main {
public static int f(int n){
if(n==1) return 1;
return n*f(n-1);
}
public static void main(String[] args) {
System.out.println(f(3));
}
}
数组
Java内存分析
静态初始化,创建+赋值;
动态初始化(包含默认初始化);
int[] a={0,1,2,3};
int[] b=new int[10];
数组对象本身是保存在堆中
Arrays.for
Arrays工具类
查看JDK帮助文档
Arrays类中方法都是static静态方法,可以直接使用类型进行调用,不用使用对象调用。
通常具有以下常用功能:
fill赋值
sort排序
equals比较
binarySearch方法能对排序好的数组进行二分查找操作
int[] a={1,3,10,2,333,6};
System.out.println(a);//[I@5d22bbb7
//打印数组元素
System.out.println(Arrays.toString(a));
//数组排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//数组部分填充
System.out.println(Arrays.toString(a));
Arrays.fill(a, 1, 2, 300);//[1,2) 左闭右开
System.out.println(Arrays.toString(a));
冒泡排序
public static void sort(int[] a){
for(int i=0;i<a.length;i++){
//内层循环,大数往上冒
for(int j=0;j<a.length-1-i;j++){
if(a[j+1]<a[j]){
int temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
}
}
O(n^2)
假设内部部分已经有序,如何优化?加个标记记录是否有交换若无提前结束for
public static void sort(int[] a){
for(int i=0;i<a.length;i++){
boolean isOrder=false;
//内层循环,大数往上冒
for(int j=0;j<a.length-1-i;j++){
if(a[j+1]<a[j]){
int temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
isOrder=true;
}
}
//如果这轮没有进行交换操作,表明全部已经有序
if(!isOrder) break;
}
}
数组压缩-----稀疏数组
当一个数组中大部分元素为0,或者为同一值的时候,可以使用稀疏数组来保存该数组。
处理方式:
- 记录数组一共几行几列,有多少个不同值;
- 把具有不同值元素和行列及值记录在一个小规模的数组中从而压缩。
6行7列有效值为8个
创建一个二维数组
输出原始数组
转换为稀疏数组保存
获取有效值的个数
创建稀疏数组 int[][] a2=new int[sum+1][3]
遍历二维数组,将非零值存放入稀疏数组 a2[count++][0]=i...
输出稀疏数组
读取稀疏数组 int[][] a3=new int[a2[0][0]][a[0][1]]
给其中元素还原
面向对象
核心思想就是OOP。
面向对象的本质:以类的方式组织代码,以对象封装数据。
3大特性:继承、封装、多态。
值传递和引用传递(对象)
构造方法
必须与类名相同,不能有返回值,也不能是void类型。
作用:1.使用neew关键本质是调用有构造器,2. 实例化初始值
注意:一旦定义有参构造就必须显示定义无参构造。
创建内存分析
封装
高内聚,低耦合;
封装(数据的隐藏)private->属性私有:get/set
作用:
1.提高程序的安全性,保护数据;
2.隐藏代码的实现细节;(数据验证)
3.统一接口;
4.系统可维护性。
继承
Java中类只有单继承没有多继承;
Object类;java中所有类都默认继承Object类
super类;(与this对比)
方法重写—>多态
Ctrl+h打开继承树
public class Person {
protected String name="mafu_person";
public void print(){
System.out.println("person!");
}
}
public class Student extends Person{
private String name="mafu_student";
public void test1(){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void test2(){
print();
this.print();
super.print();
}
public void print(){
System.out.println("student!");
}
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test1();
}
}
隐藏代码:构造器执行。
Super注意点:
super调用必须在构造方法第一个
Super和this不能同时调用构造方法
Super VS this
代表的对象不同:
this:不同调用者这个对象
super:代表父类对象的引用
重写
静态text方法:方法的调用只和左边数据类型有关,不算重写
A a=new A();
B b=new A();父类的引用指向了子类
a.text();//a
b.text();//b
非静态:重写只和非静态方法有关,public
方法的调用只和右边数据类型有关
对象执行那些方法之和左边有关
//a
//a
静态方法和非静态方法区别很大。
重写:
修饰符:范围可以扩大但不能缩小:public->protected->Default->private;
抛出异常:范围,可以被缩小,,但不能被放大
instanceof和类型转换
有关系的类型才能进行instanceof判断
x instanceof y 存在父子关系,才能编译通过。
强制转换,后调用子类方法;子类转父类可能丢失一些方法
Person student=new Student();
((Student) student).go()
1.父类引用指向子类对象;
2.子类转换父类,向上转型;
3.父类向下转子类,强制转型;
4.方便方法调用,减少重复代码。
static 详解
静态代码块,跟类加载只执行一次,赋初始值。
static {
}
抽象类
abstract extends 类单继承
public abstract class Action{
//抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
}
抽象类的所有方法,子类必须实现。
1.不能new这个抽象类,只能由子类去实现它。
2.抽象类中也可以写普通方法。
intereface impelments 接口伪多继承
专业的抽象,约束和实现分离,面向接口编程。
接口本质是契约,面向对象的精髓。
接口中方法都是抽象的public abstract 不用写。
内部类
通过外部类来实例化内部类~
Outer outer=new Outer();
Outer.Inner inner=new Outer.new Inner();
内部类可以访问外部类私有变量。
静态内部类
一个Java类中可以有多个Class(可以有main方法方便测试),单是只能有一个public class
匿名实例类
异常erro和exception
异常3种类型:
检查性异常
运行时异常
错误error
Throwable异常体系结构:
快捷键:Ctrl+alt+t
异常处理机制:try catch finally throw throws
捕获异常
抛出异常
try{//监控
if(){
// throws 用在更高级方法名中抛出
throw new ArithmeticException()//主动抛出异常
}
}catch(Error ){//捕获,想要捕获的异常类型
}catch(Exception e){//捕获多个异常
//尽量去处理异常
e.printStackTrace()//打印异常栈信息
}finally{//善后,可有可无
//释以上是关于java编程基础 正则表达式的主要内容,如果未能解决你的问题,请参考以下文章