Java学习之路0727（十一）（正则表达式、线程）

最新推荐文章于 2023-06-29 17:46:09 发布

wujie5201

最新推荐文章于 2023-06-29 17:46:09 发布

阅读量381

点赞数

分类专栏： java学习

本文链接：https://blog.csdn.net/wujie5201/article/details/47109419

版权

java学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些特殊意义的字符串，这些特殊字符串称为正则表达式。例如：“\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();
    }
}

wujie5201

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习之路0727（十一）（正则表达式、线程）

正则表达式正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些特殊意义的字符串，这些特殊字符串称为正则表达式。例如：“\d”表示数字0-9中的任何一个，“\d”就是元字符。在正则表达式中“.”代表任何一个字符，因此在正则表达式中如果使用普通的点字符”.”,必须使用转义字符“\”。在正则表达式中可以使用方括号括起若干个字符表示一个元字符。例如：reg=“[abc]4
复制链接

扫一扫