15 正则、MATH、Random、System、Date学习

最新推荐文章于 2021-03-30 22:34:46 发布

guoyoubuji

最新推荐文章于 2021-03-30 22:34:46 发布

阅读量449

点赞数

分类专栏： java系统学习

本文链接：https://blog.csdn.net/guoyoubuji/article/details/53236818

版权

java系统学习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

01_常见对象(正则表达式的概述和简单使用)

A:正则表达式
- 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
- 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
B:案例演示
- 需求：校验qq号码.
  - 1:要求必须是5-15位数字
  - 2:0不能开头
  - 3:必须都是数字
- a:非正则表达式实现
- b:正则表达式实现

A
public static void main(String[] args) {

        checkQQ("323");
        checkQQ("32322232");
        checkQQ("323aaaww11");
        checkQQ("023aaaww11");


    }

    public static void checkQQ(String a) {
        if (a.length() > 5 && a.length() < 15) {
            if (!a.startsWith("0")) {
                for (int i = 0; i < a.length(); i++) {
                    if ((a.charAt(i) < '0' || a.charAt(i) > '9')) {
                        System.out.println("不能有字");
                        return;
                    }

                }
                System.out.println("登陆成功");
            } else {
                System.out.println("首位不能不能为0");
            }
        } else {
            System.out.println("你输入的长度不符合");
        }
    }
你输入的长度不符合
登陆成功
不能有字
首位不能不能为0

B     public static void main(String[] args) {
        System.out.println(checkQQ("323"));
        System.out.println(checkQQ("32322232"));
        System.out.println(checkQQ("323aaaww11"));
        System.out.println(checkQQ("023aaaww11"));
    }

    public static boolean checkQQ(String a) {
        String regex="[1-9]\\d{4,14}";
        return(a.matches(regex));
    }
false
true
false
false

02_常见对象(字符类演示)

A:字符类
- [abc] a、b 或 c（简单类）
  可以出现a或b或c的单个字符
- [^abc] 任何字符，除了 a、b 或 c（否定）
  除了a和b和c的单个字符
- [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
  [a-d[m-p]] a到 d 或 m到 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]（减去）
- [0-9] 0到9的字符都包括
- public static void main(String[] args) { matchs("a"); matchs("c"); matchs("ab"); matchs("8"); matchs("z"); matchs("0"); } public static void matchs(String a){ String regex1="[abc]"; String regex2="[^abc]"; String regex3="[a-zA-Z]"; String regex4="[0-9]"; String arr[]={regex1,regex2,regex3,regex4}; for (int i = 0; i < arr.length; i++) { boolean falg=a.matches(arr[i]); System.out.println(a+" "+arr[i]+" "+falg); } } }

03_常见对象(预定义字符类演示)

A:预定义字符类
* . 任何字符。

String regex1="..";
System.out.println("a".matches(regex));   true
System.out.println("ab".matches(regex));  false
System.out.println("a".matches(regex1));  false
System.out.println("ab".matches(regex1));   true

“\”为特殊符号，在这里需要转义，所以代码中一般写成\
* \d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r] (空格、tab空格算，多个空格不算)
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9] （a到Z和0-9和_都可以）
\W 非单词字符：[^\w]

04_常见对象(数量词)

A:Greedy 数量词（a.matches（“avc”）是avc中的3个数在a中出现的次数，而不是，a在avc中出现的次数。如案例8和a）
- X? X，一次或一次也没有 <=1
- X* X，零次到多次
- X+ X，一次或多次 >=1
- X{n} X，恰好 n 次 ==n
- X{n,} X，至少 n 次 >=n
- X{n,m} X，至少 n 次，但是不超过 m 次 m> >n
- public static void main(String[] args) { matchs("a"); matchs("c"); matchs("ab"); matchs("8"); matchs("z"); matchs("aab"); } public static void matchs(String a){ String regex1="[abc]?"; String regex2="[abc]*"; String regex3="[abc]+"; String regex4="[aabc]{2}"; String regex5="[aabc]{3,}"; String regex6="[aabc]{3,5}"; String arr[]={regex1,regex2,regex3,regex4,regex5,regex6}; for (int i = 0; i < arr.length; i++) { boolean falg=a.matches(arr[i]); System.out.println(a+" "+arr[i]+" "+falg); } } } a [abc]? true a [abc]* true a [abc]+ true a [aabc]{2} false a [aabc]{3,} false a [aabc]{3,5} false c [abc]? true c [abc]* true c [abc]+ true c [aabc]{2} false c [aabc]{3,} false c [aabc]{3,5} false ab [abc]? false ab [abc]* true ab [abc]+ true ab [aabc]{2} true ab [aabc]{3,} false ab [aabc]{3,5} false 8 [abc]? false 8 [abc]* false 8 [abc]+ false 8 [aabc]{2} false 8 [aabc]{3,} false 8 [aabc]{3,5} false z [abc]? false z [abc]* false z [abc]+ false z [aabc]{2} false z [aabc]{3,} false z [aabc]{3,5} false aab [abc]? false aab [abc]* true aab [abc]+ true aab [aabc]{2} false aab [aabc]{3,} true aab [aabc]{3,5} true

05_常见对象(正则表达式的分割功能)

A:正则表达式的分割功能
- String类的功能：public String[] split(String regex)
B:案例演示
- 正则表达式的分割功能
  public static void main(String[] args) {
  String s=”金三胖.过么没.李坦亿”;
  //String []arr=s.split(“.”); 点代表所有，没有意义
  //String []arr=s.split(“.”);
  String []arr=s.split(“\.”);//转义之后可以使用
  for (int i = 0; i < arr.length; i++) {
  System.out.println(arr[i]);
  }
  }
  }

06_常见对象(把给定字符串中的数字排序)

A:案例演示
- 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
  self

public static void main(String[] args) {

        String a = "91 27 46 38 50";
        String[] l = a.split(" ");

        for (int i = 0; i < l.length; i++) {
            for (int j = i + 1; j < l.length; j++) {

                if (Integer.parseInt(l[i]) > Integer.parseInt(l[j])) {
                    String temp = l[i];
                    l[i] = l[i + 1];
                    l[i + 1] = temp;

                }
            }

        }
        for (int k = 0; k < l.length; k++) {
            System.out.print(l[k] + "\t");
       问题1， 这种只是一个个字符串分别输出，没有拼接
       问题2， 我用的是选择排序，而真正的用法是要用数组的工具类Arrays.sort();
        }
    }

修改后：

public static void main(String[] args) {

        String a = "91 27 46 38 50";
        String[] l = a.split(" ");
        int n[]=new int[l.length];
        for (int i = 0; i < l.length; i++) {
            n[i]=Integer.parseInt(l[i]);
        }

        Arrays.sort(n);

        String m="";
        for (int k = 0; k < n.length; k++) {
            if(k<n.length-1){
            m=m+n[k]+" ";}
            else{
                m=m+n[k];
            }

        }
        System.out.println(m);
    }
    问题：上面的拼接方法，会产生很多的垃圾，每次新的m=什么之后，就会产生垃圾，建议用StringBuffer

终结

    public static void main(String[] args) {

        String a = "91 27 46 38 50";
        String[] l = a.split(" ");
        int n[]=new int[l.length];
        for (int i = 0; i < l.length; i++) {
            n[i]=Integer.parseInt(l[i]);
        }

        Arrays.sort(n);


        StringBuffer sb=new StringBuffer();

        for (int k = 0; k < n.length; k++) {
            if(k<n.length-1){
            sb.append(n[k]+" ");}
            else{
                sb.append(n[k]);
            }

        }
        System.out.println(sb);
    }

07_常见对象(正则表达式的替换功能)

A:正则表达式的替换功能
- String类的功能：public String replaceAll(String regex,String replacement)
B:案例演示
- 正则表达式的替换功能

String s="javacainiao";
String regex="cainia";
String s1=s.replaceAll(regex, "daniu");
    System.out.println(s1);
    }
}
javadaniuo

08_常见对象(正则表达式的分组功能)

A:正则表达式的分组功能
- 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
```
1     ((A)(B(C))) 
2     (A 
3     (B(C)) 
4     (C) 

组零始终代表整个表达式。
```
B:案例演示
a:切割
需求：请按照叠词切割： “sdqqfgkkkhjppppkl”;
b:替换
需求：我我….我…我.要…要要…要学….学学..学.编..编编.编.程.程.程..程
将字符串还原成:“我要学编程”。

public class Replace {
    public static void main(String[] args) {
    String s="我我.........我我我我....说说说不不不不不不不出口口...口";
    //请输出我说不出口
    String regex="\\.+";   //表示.出现一次或多次    此处的点就是指点，不指任何其它的东西
   String s1=s.replaceAll(regex, "");
   String regex1="(.)\\1+";         //表示任何出现超过一次的词
   System.out.println(s1.replaceAll(regex1, "$1"));   //$1表示第一组的词

    }
}我说不出口

09_常见对象(Pattern和Matcher的概述)

A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
- 通过JDK提供的API，查看Pattern类的说明
- 典型的调用顺序是
- Pattern p = Pattern.compile(“a*b”);
- Matcher m = p.matcher(“aaaaab”);
- boolean b = m.matches();

10_常见对象(正则表达式的获取功能)

A:正则表达式的获取功能
- Pattern和Matcher的结合使用
B:案例演示
- 需求：把一个字符串中的手机号码获取出来

package Factory;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.omg.Messaging.SyncScopeHelper;

public class PatternMatcher {
    public static void main(String[] args) {
        // demo();
        FindTellMail();

    }

    public static void FindTellMail() {
        String a = "答复  13439958738斯蒂芬森斯蒂芬斯蒂芬15323345622fghhf看看442073568@qq.com ";
        String regex1 = "1[13578]\\d{9}";
        // String
        // regex2="^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
        // String
        // regex2="^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        String regex2 = "[\\w]+@[\\w]+\\.[com|net|cn]";
        Pattern p = Pattern.compile(regex1);
        Pattern p1 = Pattern.compile(regex2);

        Matcher m = p.matcher(a);
        Matcher m1 = p1.matcher(a);
        System.out.println(m1.find());
        System.out.println(m1.group());
        /*
         * System.out.println(m.find()); System.out.println(m.group());
         * System.out.println(m.find()); System.out.println(m.group());
         */
        while (m.find())
            System.out.println(m.group());
    }

    public static void demo() {
        String a = "aaaaab";
        String b = "aaa";
        String regex = "a*b";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(a);
        Matcher m1 = p.matcher(b);

        System.out.println(m.matches());
        System.out.println(m1.matches());
    }

}
true
442073568@qq.c
13439958738
15323345622

11_常见对象(Math类概述和方法使用)

A:Math类概述
- Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
B:成员方法
- public static int abs(int a)
- public static double ceil(double a)
- public static double floor(double a)
- public static int max(int a,int b) min自学
- public static double pow(double a,double b)
- public static double random()
- public static int round(float a) 参数为double的自学
- public static double sqrt(double a)

12_常见对象(Random类的概述和方法使用)

A:Random类的概述
- 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
- public Random()
- public Random(long seed)
C:成员方法
- public int nextInt()
- public int nextInt(int n)(重点掌握)

13_常见对象(System类的概述和方法使用)

A:System类的概述
- System 类包含一些有用的类字段和方法。它不能被实例化。
B:成员方法
- public static void gc()
- public static void exit(int status)
- public static long currentTimeMillis()
- pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
C:案例演示
- System类的成员方法使用

14_常见对象(BigInteger类的概述和方法使用)

A:BigInteger的概述
- 可以让超过Integer范围内的数据进行运算
B:构造方法
- public BigInteger(String val)
C:成员方法
- public BigInteger add(BigInteger val)
- public BigInteger subtract(BigInteger val)
- public BigInteger multiply(BigInteger val)
- public BigInteger divide(BigInteger val)
- public BigInteger[] divideAndRemainder(BigInteger val)

15_常见对象(BigDecimal类的概述和方法使用)

A:BigDecimal的概述
- 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
- 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
- 不可变的、任意精度的有符号十进制数。
B:构造方法
- public BigDecimal(String val)
C:成员方法
- public BigDecimal add(BigDecimal augend)
- public BigDecimal subtract(BigDecimal subtrahend)
- public BigDecimal multiply(BigDecimal multiplicand)
- public BigDecimal divide(BigDecimal divisor)
D:案例演示
- BigDecimal类的构造方法和成员方法使用

16_常见对象(Date类的概述和方法使用)(掌握)

A:Date类的概述
- 类 Date 表示特定的瞬间，精确到毫秒。
B:构造方法
- public Date()
- public Date(long date)
C:成员方法
- public long getTime()
- public void setTime(long time)

17_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)(掌握)

A:DateFormat类的概述
- DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
B:SimpleDateFormat构造方法
- public SimpleDateFormat()
- public SimpleDateFormat(String pattern)
C:成员方法
- public final String format(Date date)
- public Date parse(String source)

这里写图片描述

public class SimpleDateF {
    public static void main(String[] args) {
        instance();
        Demo1();  //日期格式化
    StrCDate();    //字符串转日期


    }

    public static void StrCDate() {
        String str="1999/9/19 09:09:09";

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/M/d HH:mm:ss");

        try {
            Date d=sdf.parse(str);
            System.out.println(d);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void Demo1() {
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat ("yyyy/M/d");
    System.out.println(sdf.format(d));
    }

    public static void instance() {
        // DateFormat df=new DateFormat();抽象类不能实例化
        DateFormat df1=DateFormat.getDateInstance();
    }


}

18_常见对象(你来到这个世界多少天案例)(掌握)

A:案例演示
- 需求：算一下你来到这个世界多少天?

public static void main(String[] args) {
    Date d=new Date();
    Scanner s=new Scanner(System.in);
    System.out.println("请输入你的出生日期");
    String a=s.nextLine();
    SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMdd");
    System.out.println(d);

    try {
        Date d1=sdf.parse(a);
        System.out.println(d1);
        long time =d.getTime()-d1.getTime();
        int t=(int) (time/1000/60/60/24);
        System.out.println(time);
        System.out.println(t);
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

19_常见对象(Calendar类的概述和获取日期的方法)(掌握)

A:Calendar类的概述
- Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
B:成员方法
- public static Calendar getInstance()
- public int get(int field)

public class Calender {
    public static void main(String[] args) {
        Calendar d=Calendar.getInstance();        
        System.out.println(d.get(Calendar.YEAR)+"年"+getMonth(d.get(Calendar.MONTH))+"月"+d.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(d.get(Calendar.DAY_OF_WEEK)));     
    }
    public static String getWeek(int a) {
        String week[]={"星期","星期日","星期一","星期二","星期三","星期四","星期五","星期六"}; 
        System.out.println(week[a]);
            return week[a];     
    }   
    public static int getMonth(int b){
        return b+1;
    }
}

20_常见对象(Calendar类的add()和set()方法)(掌握)

A:成员方法
- public void add(int field,int amount)
- public final void set(int year,int month,int date)
B:案例演示
- Calendar类的成员方法使用

21_常见对象(如何获取任意年份是平年还是闰年)(掌握)

A:案例演示
- 需求：键盘录入任意一个年份，判断该年是闰年还是平年

public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("请你输入一个年份");
        int a=s.nextInt();
        Calendar c=Calendar.getInstance();

        c.set(a,2,1);
        YearTest.ViewDate(c);
        c.add(Calendar.DAY_OF_MONTH, -1);
        int d=c.get(Calendar.DAY_OF_MONTH);
        //System.out.println(d);
        if(d==29){
            System.out.println("闰年");
        }else{
            System.out.println("平年");
        }


    }

guoyoubuji

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
15 正则、MATH、Random、System、Date学习

01_常见对象正则表达式的概述和简单使用02_常见对象字符类演示03_常见对象预定义字符类演示04_常见对象数量词05_常见对象正则表达式的分割功能06_常见对象把给定字符串中的数字排序07_常见对象正则表达式的替换功能08_常见对象正则表达式的分组功能09_常见对象Pattern和Matcher的概述10_常见对象正则表达式的获取功能11_常见对象Math类概述和方法使用12
复制链接

扫一扫