正则表达式
正则表达式通常被用于判断语句中,用来检查某一字符串是否满足某一格式。正则表达式是含有一些特殊意义的字符串,这些特殊字符串称为正则表达式。例如:“\d”表示数字0-9中的任何一个,“\d”就是元字符。
在正则表达式中“.”代表任何一个字符,因此在正则表达式中如果使用普通的点字符”.”,必须使用转义字符“\”。
在正则表达式中可以使用方括号括起若干个字符表示一个元字符。例如:reg=“[abc]4”,这样的字符a4,b4,c4都是和正则表达式匹配的字符串。
验证手机号13 15 18 17 总计11位
验证身份证号 18位最后一位可能为X
验证密码8~16位数字或字母组合
import java.util.Scanner;
import java.util.regex.Matcher;
/*
* 验证手机号13 15 18 17 总计11位
* 验证身份证号 18位最后一位可能为X
* 验证密码8~16位数字或字母组合
*/
import java.util.regex.Pattern;
public class RegexTest {
public static void main(String[] args) {
Pattern p=Pattern.compile("(13|15|18|17)[0-9]{9}");
Pattern p1=Pattern.compile("\\d{17}[0-9[x|X]]");
Pattern p2=Pattern.compile("[0-9[a-z]]{8,16}");
Scanner scanner=new Scanner(System.in);
System.out.println("请输入手机号:");
String s=scanner.nextLine();
Matcher m=p.matcher(s);
panduan(m);
System.out.println("请输入身份证号:");
String s1=scanner.nextLine();
Matcher m1=p1.matcher(s1);
panduan(m1);
System.out.println("请输入密码:");
String s2=scanner.nextLine();
Matcher m2=p2.matcher(s2);
panduan(m2);
}
public static void panduan(Matcher m){
if (m.matches()) {
System.out.println("格式正确");
}else{
System.out.println("格式不正确");
}
}
}
线程
定义:Windows操作系统是一多任务操作系统,以进程为单位,每个独立进行的程序都称为进程,也就是正在执行的程序。一个线程就是进程中的执行流程,一个进程中可以同时包括多个线程,每个线程可以得到一段程序的执行时间,这样一个进程就可以多个并发执行的线程。
实现:实现Java线程的方式有两种,一种是继承java.lang.Thread类,另为一种Java.lang.Runnable接口。
例如:继承Thread类:
public class Summer extends Thread{
}
完成线程的真正功能是在类run()方法中,当一个类继承Thread后,就可以覆盖run()方法,将实现该功能的代码写入run()中。
public void run() {
}
启动线程需要在主线程也就是main方法中调用:
public class ThreadTest {
public static void main(String[] args) {
new ThreadTest().start();
}
}
public class Summer extends Thread{
private String name;
public Summer(String name){
this.name=name;
}
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<10;i++){
try {
Thread.sleep(00);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.print(name+"第"+i+"天值日 ");
if (i%2==0) {
System.out.println();
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
Summer s1=new Summer("小明");
Summer s2=new Summer("小红");
s1.start();
s2.start();
}
}
运行结果;
小红第0天值日
小红第1天值日 小红第2天值日
小红第3天值日 小红第4天值日
小红第5天值日 小红第6天值日
小红第7天值日 小红第8天值日
小红第9天值日 小明第0天值日
小明第1天值日 小明第2天值日
小明第3天值日 小明第4天值日
小明第5天值日 小明第6天值日
小明第7天值日 小明第8天值日
小明第9天值日
实现Runnable接口,实现Runnable接口的程序会创建一个Thread对象,并将Runnable对象与Thread对相关联。
线程间共享数据
public class ShareDate implements Runnable{
int s=0;
@Override
public void run() {
// TODO Auto-generated method stub
while(s<100){
System.out.println("第"+s+"张票");
s++;
}
}
}
public class RunableTest {
public static void main(String[] args) {
ShareDate sd=new ShareDate();
Thread t1=new Thread(sd);
Thread t2=new Thread(sd);
Thread t3=new Thread(sd);
Thread t4=new Thread(sd);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
运行结果:
第0张票
第1张票
第2张票
第3张票
第4张票
第5张票
第6张票
第7张票
第8张票
第9张票
第10张票
线程的同步synchronized
同步方法的锁是调用该方法的对象
public class Symain implements Runnable{
int money=100;
@Override
public void run() {
// TODO Auto-generated method stub
while (money>0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
takeMoney();
}
}
public synchronized void takeMoney(){
if(money>0){
System.out.println(Thread.currentThread()+"取走了"+money);
money--;
}
}
}
public class SymainTest {
public static void main(String[] args) {
Symain money=new Symain();
Thread t1=new Thread(money);
Thread t2=new Thread(money);
Thread t3=new Thread(money);
t1.start();
t2.start();
t3.start();
}
}
运行结果:
Thread[Thread-1,5,main]取走了10
Thread[Thread-2,5,main]取走了9
Thread[Thread-0,5,main]取走了8
Thread[Thread-1,5,main]取走了7
Thread[Thread-2,5,main]取走了6
Thread[Thread-0,5,main]取走了5
Thread[Thread-1,5,main]取走了4
Thread[Thread-2,5,main]取走了3
Thread[Thread-0,5,main]取走了2
Thread[Thread-2,5,main]取走了1
死锁
public class DeadLock implements Runnable {
private String s1;
private String s2;
public DeadLock(String obj1,String obj2){
this.s1=obj1;
this.s2=obj2;
}
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (s1) {
System.out.println("持有锁"+s1);
sleep();
synchronized (s2) {
System.out.println("等待锁"+s2);
sleep();
}
}
}
public void sleep(){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public class DeadLockTest {
public static void main(String[] args) {
String s1="abc";
String s2="def";
String s3="ghi";
DeadLock dl1=new DeadLock(s1,s2);
DeadLock dl2=new DeadLock(s2,s3);
DeadLock dl3=new DeadLock(s3,s1);
Thread t1=new Thread(dl2);
Thread t2=new Thread(dl3);
Thread t3=new Thread(dl1);
t1.start();
t2.start();
t3.start();
}
}
Lock锁
public class Lock implements Runnable{
int i=10;
String s="abc";
@Override
public void run() {
// TODO Auto-generated method stub
while(i>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (s) {
if (i>0) {
System.out.println(Thread.currentThread().toString()+i);
i--;
}
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Lock l1=new Lock();
Thread t1=new Thread(l1);
Thread t2=new Thread(l1);
Thread t3=new Thread(l1);
Thread t4=new Thread(l1);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
运行结果:
Thread[Thread-1,5,main]10
Thread[Thread-3,5,main]9
Thread[Thread-2,5,main]8
Thread[Thread-0,5,main]7
Thread[Thread-2,5,main]6
Thread[Thread-0,5,main]5
Thread[Thread-1,5,main]4
Thread[Thread-3,5,main]3
Thread[Thread-2,5,main]2
Thread[Thread-0,5,main]1
Join的使用
public class JoinThread1 implements Runnable{
int money=100;
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("线程一开始");
while (money>0) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
money--;
}
System.out.println("线程一结束");
}
}
public class JoinTread2 implements Runnable{
int money=100;
public void run() {
// TODO Auto-generated method stub
System.out.println("线程二开始");
while (money>0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
money--;
}
System.out.println("线程二结束");
}
}
package jie0727;
public class JoinThreadTest {
public static void main(String[] args) {
JoinThreadTest jtt=new JoinThreadTest();
JoinThread1 jt1=new JoinThread1();
JoinTread2 jt2=new JoinTread2();
Thread t1=new Thread(jt1);
Thread t2=new Thread(jt2);
t2.start();
try {
t2.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t1.start();
}
}
运行结果:
线程二开始
线程二结束
线程一开始
线程一结束
Wait()与notify()
例如:生产者与消费者之间的关系
生产者
public class CreatProtect implements Runnable{
private Protect protect;
public CreatProtect(Protect protect) {
// TODO Auto-generated constructor stub
this.protect=protect;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
protect.CreatProet();
}
}
}
消费者
public class CosumerProtect implements Runnable{
private Protect protect;
public CosumerProtect(Protect protect) {
this.protect=protect;
// TODO Auto-generated constructor stub
}
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
protect.CosumerPortect();
}
}
}
产品
public class Protect {
public boolean isHave=false;
public synchronized void CreatProet(){
if (isHave) {
try {
System.out.println("生产者释放锁");
wait();
System.out.println("生产者被唤醒");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("开始生产产品");
System.out.println("生产了一件产品");
isHave=true;
notify();
}
public synchronized void CosumerPortect(){
System.out.println("消费前");
if (!isHave) {
try {
System.out.println("等待生产产品");
System.out.println("消费者释放锁");
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("生产了一件产品");
isHave=true;
System.out.println("开始消费产品");
System.out.println("--------");
notify();
}
}
Test
public class ProtectTest {
public static void main(String[] args) {
Protect protect=new Protect();
CreatProtect creatRun=new CreatProtect(protect);
CosumerProtect cosumerRun=new CosumerProtect(protect);
Thread thread1=new Thread(cosumerRun);
Thread thread2=new Thread(creatRun);
thread1.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
thread2.start();
}
}