美文网首页Java-Python-Django社区程序员
【JavaSE（八）】Java常见对象（下）

【JavaSE（八）】Java常见对象（下）

作者: 苍云横渡 | 来源:发表于2018-05-18 22:48 被阅读38次

原文地址：https://www.cloudcrossing.xyz/post/40/

1 正则表达式

1.1 正则表达式概述

是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。

public class RegexDemo2 {
    public static void main(String[] args) {
        // 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的QQ号码：");
        String qq = sc.nextLine();
        System.out.println("checkQQ:" + checkQQ(qq));
    }

    public static boolean checkQQ(String qq) {
        // String regex ="[1-9][0-9]{4,14}";
        // boolean flag = qq.matches(regex);
        // return flag;

        //return qq.matches("[1-9][0-9]{4,14}");
        return qq.matches("[1-9]\\d{4,14}");
    }
}

上面的代码中，public boolean matches(String regex) 是告知此字符串是否匹配给定的正则表达式。

1.2 常见规则

  • A：字符
    • x：匹配字符x，比如，`a`表示字符a
    • \\：匹配反斜线字符
    • \.：匹配 . 字符
    • \n：匹配换行符 ('\u000A')
    • \r：匹配回车符 ('\u000D')
  • B：字符类
    • [abc]：匹配字符a、b或c（简单类）
    • [^abc]：匹配任意字符，除了a、b或c（否定）
    • [a-zA-Z]：匹配a到z或A到Z，两头的字符包括在内（范围）
    • [0-9]：匹配0-9的字符，两头的字符包括在内（范围）
  • C：预定义类
    • .：匹配任意字符（如果要匹配 . 的话，使用\.）
    • \d：匹配数字0-9，即 [0-9]
    • \w：匹配包括下划线的任何单词字符，即[a-zA-Z_0-9]
  • D：边界匹配器
    • ^：匹配行的开头
    • $：匹配行的结尾
    • \b：匹配单词边界，指单词和非单词之间的位置，并非指字符，比如hello world?haha;xixi
  • E：Greedy数量词
    • X?：匹配前面的子表达式零次或一次
    • X*：匹配前面的子表达式任意次
    • X+：匹配前面的子表达式一次或多次
    • X{n}：匹配前面的子表达式恰好n次
    • X{n,}：匹配前面的子表达式至少n次
    • X{n,m}：匹配前面的子表达式至少n次，但不超过m次

1.3 常见功能

判断功能：String类的public boolean matches(String regex)，根据给定正则表达式的匹配判断此字符串，返回一个布尔值。

public class Demo {
    public static void main(String[] args) {
        // 键盘录入邮箱
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入邮箱：");
        String email = sc.nextLine();

        // 定义邮箱的规则
        // String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";
        String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";

        // 调用功能，判断即可
        boolean flag = email.matches(regex);

        // 输出结果
        System.out.println("flag:" + flag);
    }
}

分割功能：String类的public String[] split(String regex)，根据给定正则表达式的匹配拆分此字符串，返回一个字符串数组。

public class RegexDemo2 {
    public static void main(String[] args) {
        // 定义一个字符串
        String s1 = "aa,bb,cc";
        // 直接分割
        String[] str1Array = s1.split(",");
        for (int x = 0; x < str1Array.length; x++) {
            System.out.println(str1Array[x]);
        }
        System.out.println("---------------------");

        String s2 = "aa.bb.cc";
        String[] str2Array = s2.split("\\.");
        for (int x = 0; x < str2Array.length; x++) {
            System.out.println(str2Array[x]);
        }
        System.out.println("---------------------");

        String s3 = "aa    bb                cc";
        String[] str3Array = s3.split(" +");
        for (int x = 0; x < str3Array.length; x++) {
            System.out.println(str3Array[x]);
        }
        System.out.println("---------------------");
        
        //硬盘上的路径，我们应该用\\替代\
        String s4 = "E:\\JavaSE\\day14\\avi";
        String[] str4Array = s4.split("\\\\");
        for (int x = 0; x < str4Array.length; x++) {
            System.out.println(str4Array[x]);
        }
        System.out.println("---------------------");
    }
}

替换功能：String类的public String replaceAll(String regex, String replacement)，使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串，返回一个字符串。

public class RegexDemo {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "helloqq12345worldkh622112345678java";

        // 直接把数字去掉
        String regex = "\\d+";
        String ss = "";

        String result = s.replaceAll(regex, ss);
        System.out.println(result);
    }
}

获取功能：使用Pattern类（模式）和Matcher类（匹配器），记得导包

  • 首先把正则表达式（str）编译成模式对象（Pattern p = Pattern.compile(str)）
  • 然后通过模式对象得到匹配器对象（Matcher m = p.matcher(str1)），这时候需要的是被匹配的字符串（str1）
  • 最后调用匹配器对象的功能（boolean flag = m.find();），在利用（m.group()）获取匹配的字符串
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
    public static void main(String[] args) {
        // 模式和匹配器的典型调用顺序
        // 把正则表达式编译成模式对象
        Pattern p = Pattern.compile("a*b");
        // 通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串
        Matcher m = p.matcher("aaaaab");
        // 调用匹配器对象的功能
        boolean b = m.matches();
        System.out.println(b);
        
        //这个是判断功能，但是如果做判断，这样做就有点麻烦了，我们直接用字符串的方法做
        String s = "aaaaab";
        String regex = "a*b";
        boolean bb = s.matches(regex);
        System.out.println(bb);
    }
}

在来一个例子，获取下面这个字符串中由三个字符组成的单词

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

public class RegexDemo2 {
    public static void main(String[] args) {
        // 定义字符串
        String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
        // 规则
        String regex = "\\b\\w{3}\\b";

        // 把规则编译成模式对象
        Pattern p = Pattern.compile(regex);
        // 通过模式对象得到匹配器对象
        Matcher m = p.matcher(s);
        // 调用匹配器对象的功能
        // 通过find方法就是查找有没有满足条件的子串
        // public boolean find()
        boolean flag = m.find();
        System.out.println(flag);
        // 如何得到值呢?
        // public String group()
        // String ss = m.group();
        // System.out.println(ss);
        // 这样只能得到一次匹配的值

        // 得到所有的值
        while (m.find()) {
            System.out.println(m.group());
        }

        // 注意：一定要先find()，然后才能group()
        // IllegalStateException: No match found
        // String ss = m.group();
        // System.out.println(ss);
    }
}

2 Math类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

成员变量：

  • public static final double PI
  • public static final double E

成员方法：

  • 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)：最大值
  • public static int min(int a,int b)：最小值
  • public static double pow(double a,double b)：a的b次幂
  • public static double random()：随机数 [0.0,1.0)
  • public static int round(float/double a)：四舍五入
  • public static double sqrt(double a)：正平方根
public class MathDemo {
    public static void main(String[] args) {
        // public static final double PI
        System.out.println("PI:" + Math.PI);
        // public static final double E
        System.out.println("E:" + Math.E);
        System.out.println("--------------");

        // public static int abs(int a)：绝对值
        System.out.println("abs:" + Math.abs(10));
        System.out.println("abs:" + Math.abs(-10));
        System.out.println("--------------");

        // public static double ceil(double a):向上取整
        System.out.println("ceil:" + Math.ceil(12.34));
        System.out.println("ceil:" + Math.ceil(12.56));
        System.out.println("--------------");

        // public static double floor(double a):向下取整
        System.out.println("floor:" + Math.floor(12.34));
        System.out.println("floor:" + Math.floor(12.56));
        System.out.println("--------------");

        // public static int max(int a,int b):最大值
        System.out.println("max:" + Math.max(12, 23));
        System.out.println("--------------");

        // public static double pow(double a,double b):a的b次幂
        System.out.println("pow:" + Math.pow(2, 3));
        System.out.println("--------------");

        // public static double random():随机数 [0.0,1.0)
        System.out.println("random:" + Math.random());
        // 获取一个1-100之间的随机数
        System.out.println("random:" + ((int) (Math.random() * 100) + 1));
        System.out.println("--------------");

        // public static int round(float a) 四舍五入
        System.out.println("round:" + Math.round(12.34f));
        System.out.println("round:" + Math.round(12.56f));
        System.out.println("--------------");
        
        //public static double sqrt(double a):正平方根
        System.out.println("sqrt:"+Math.sqrt(4));
    }
}

设计一个方法，可以实现获取任意范围内的随机数。

public static int getRandom(int start, int end) {
        // 回想我们讲过的1-100之间的随机数
        // int number = (int) (Math.random() * 100) + 1;
        // int number = (int) (Math.random() * end) + start;
        int number = (int) (Math.random() * (end - start + 1)) + start;
        return number;
}

3 Random类

用于产生随机数的类。

构造方法：

  • public Random()：没有给种子，用的是默认种子，是当前时间的毫秒值
  • public Random(long seed)：给出指定的种子，给定种子后，每次得到的随机数是相同的。

成员方法：

  • public int nextInt()：返回的是int范围内的随机数
  • public int nextInt(int n)：返回的是[0,n)范围的内随机数
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        // 创建对象
        // Random r = new Random();
        Random r = new Random(1111);

        for (int x = 0; x < 10; x++) {
            // int num = r.nextInt();
            int num = r.nextInt(100) + 1;
            System.out.println(num);
        }
    }
}

4 System类

System类包含一些有用的类字段和方法。它不能被实例化。

方法：

  • public static void gc()：运行垃圾回收器，，调用的是Runtime类中的gc方法
  • public static void exit(int status)：终止当前正在运行的 Java 虚拟机；参数用作状态码，根据惯例，非 0 的状态码表示异常终止
  • public static long currentTimeMillis()：返回以毫秒为单位的当前时间
  • public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
public class SystemDemo {
    public static void main(String[] args) {
        // 要求：统计这段程序的运行时间
        long start = System.currentTimeMillis();
        for (int x = 0; x < 100000; x++) {
            System.out.println("hello" + x);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
}

import java.util.Arrays;

public class SystemDemo {
    public static void main(String[] args) {
        // 定义数组
        int[] arr = { 11, 22, 33, 44, 55 };
        int[] arr2 = { 6, 7, 8, 9, 10 };

        // 将arr中从索引为1开始的元素，复制到arr2中索引为2的位置，复制长度为2（覆盖）
        System.arraycopy(arr, 1, arr2, 2, 2);

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr2));
    }
}

//运行结果：
//[11, 22, 33, 44, 55]
//[6, 7, 22, 33, 10]

5 BigInteger类

BigInteger类可以让超过Integer类范围内的数据进行运算。

构造方法：BigInteger(String val) 。

import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        // Integer最大的值为2147483647，定义2147483648会报错
        System.out.println(Integer.MAX_VALUE);
        Integer ii = new Integer("2147483647");
        System.out.println(ii);
        // Integer iii = new Integer("2147483648"); // NumberFormatException
        // System.out.println(iii);

        // 通过大整数来创建对象
        BigInteger bi = new BigInteger("2147483648");
        System.out.println("bi:" + bi);
    }
}

成员方法：

  • 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)：返回商和余数的数组
import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("100");
        BigInteger bi2 = new BigInteger("50");

        // public BigInteger add(BigInteger val):加
        System.out.println("add:" + bi1.add(bi2));
        // public BigInteger subtract(BigInteger val):加
        System.out.println("subtract:" + bi1.subtract(bi2));
        // public BigInteger multiply(BigInteger val):加
        System.out.println("multiply:" + bi1.multiply(bi2));
        // public BigInteger divide(BigInteger val):加
        System.out.println("divide:" + bi1.divide(bi2));

        // public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
        BigInteger[] bis = bi1.divideAndRemainder(bi2);
        System.out.println("商：" + bis[0]);
        System.out.println("余数：" + bis[1]);
    }
}

6 BigDecimal类

public class BigDecimalDemo {
    public static void main(String[] args) {
        System.out.println(0.09 + 0.01); //0.09999999999999999
        System.out.println(1.0 - 0.32); //0.6799999999999999
        System.out.println(1.015 * 100); //101.49999999999999
        System.out.println(1.301 / 100); //0.013009999999999999
        System.out.println(1.0 - 0.12); //0.88
    }
}

出现以上结果，是因为float类型的数据存储和整数不一样导致的。它们大部分的时候，都是带有有效数字位。

由于在运算的时候，float和double很容易丢失精度。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal类。

BigDecimal类：不可变的、任意精度的有符号十进制数，可以解决数据丢失问题。

构造方法：public BigDecimal(String val)。

成员方法：

  • public BigDecimal add(BigDecimal augend)：加
  • public BigDecimal subtract(BigDecimal subtrahend)：减
  • public BigDecimal multiply(BigDecimal multiplicand)：乘
  • public BigDecimal divide(BigDecimal divisor)：除
  • public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)：商，scale表示几位小数，roundingMode表示如何舍取
import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        // System.out.println(0.09 + 0.01);
        // System.out.println(1.0 - 0.32);
        // System.out.println(1.015 * 100);
        // System.out.println(1.301 / 100);

        BigDecimal bd1 = new BigDecimal("0.09");
        BigDecimal bd2 = new BigDecimal("0.01");
        System.out.println("add:" + bd1.add(bd2)); //add:0.10
        System.out.println("-------------------");

        BigDecimal bd3 = new BigDecimal("1.0");
        BigDecimal bd4 = new BigDecimal("0.32");
        System.out.println("subtract:" + bd3.subtract(bd4)); //subtract:0.68
        System.out.println("-------------------");

        BigDecimal bd5 = new BigDecimal("1.015");
        BigDecimal bd6 = new BigDecimal("100");
        System.out.println("multiply:" + bd5.multiply(bd6)); //multiply:101.500
        System.out.println("-------------------");

        BigDecimal bd7 = new BigDecimal("1.301");
        BigDecimal bd8 = new BigDecimal("100");
        System.out.println("divide:" + bd7.divide(bd8)); //divide:0.01301
        System.out.println("divide:" + bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP)); //divide:0.013
        System.out.println("divide:" + bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP)); //divide:0.01301000
    }
}

7 Date/DateFormat类（理解）

7.1 Date类

Date类表示特定的瞬间，精确到毫秒。

构造方法：

  • Date()：根据当前的默认毫秒值创建日期对象------（JDK8中已过时）
  • Date(long time)：根据给定的毫秒值创建日期对象
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        // 创建对象
        // long time = System.currentTimeMillis();
        long time = 1000 * 60 * 60; // 1小时
        Date d2 = new Date(time);
        System.out.println("d2:" + d2);
    }
}

成员方法：

  • public long getTime()：获取时间，以毫秒为单位------（JDK8中已过时）
  • public void setTime(long time)：设置时间
public class DateDemo {
    public static void main(String[] args) {
        // 创建对象
        Date d = new Date(System.currentTimeMillis());

        // 获取时间
        long time = d.getTime();
        System.out.println(time);
        // System.out.println(System.currentTimeMillis());

        System.out.println("d:" + d);
        // 设置时间
        d.setTime(1000);
        System.out.println("d:" + d);
    }
}

7.2 DateForamt类

DateForamt：可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。

  • Date --> String(格式化)：public final String format(Date date)
  • String --> Date(解析)：public Date parse(String source)

SimpleDateFormat的构造方法：

  • SimpleDateFormat()：默认模式
  • SimpleDateFormat(String pattern)：给定的模式
    • 年 y、月 M、日 d、时 H、分 m、秒 s
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo {
    public static void main(String[] args) throws ParseException {
        // Date -- String
        Date d = new Date(System.currentTimeMillis());
        // 创建格式化对象，给定模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        // public final String format(Date date)
        String s = sdf.format(d);
        System.out.println(s);
        
        
        //String -- Date
        String str = "2008-08-08 12:12:12";
        //在把一个字符串解析为日期的时候，请注意格式必须和给定的字符串格式匹配
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // public Date parse(String source)
        Date dd = sdf2.parse(str);
        System.out.println(dd);
    }
}

//运行结果：
//2018年05月18日 22:21:53
//Fri Aug 08 12:12:12 CST 2008

8 Calendar类

Calendar类（日历类）是一个抽象类，封装了所有的日历字段值（诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等），通过统一的方法根据传入不同的日历字段可以获取值。

  • public static Calendar getInstance()：使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间。
  • public int get(int field)：返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。
import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        // 创建一个日历对象
        // 其日历字段已由当前日期和时间初始化：
        Calendar rightNow = Calendar.getInstance(); // 返回的是子类对象

        // 获取年
        int year = rightNow.get(Calendar.YEAR);
        // 获取月
        int month = rightNow.get(Calendar.MONTH);
        // 获取日
        int date = rightNow.get(Calendar.DATE);

        System.out.println(year + "年" + (month + 1) + "月" + date + "日");
    }
}
  • public void add(int field, int amount)：根据给定的日历字段和对应的时间，来对当前的日历进行操作（正负数确定是添加还是减去对应日历字段的值）
  • public final void set(int year, int month, int date)：设置当前日历的年月日
import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        // 获取当前的日历时间
        Calendar c = Calendar.getInstance();

        // // 三年前的今天
        // c.add(Calendar.YEAR, -3);
        // // 获取年
        // year = c.get(Calendar.YEAR);
        // // 获取月
        // month = c.get(Calendar.MONTH);
        // // 获取日
        // date = c.get(Calendar.DATE);
        // System.out.println(year + "年" + (month + 1) + "月" + date + "日");

        // 5年后的10天前
        c.add(Calendar.YEAR, 5);
        c.add(Calendar.DATE, -10);
        // 获取年
        year = c.get(Calendar.YEAR);
        // 获取月
        month = c.get(Calendar.MONTH);
        // 获取日
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + (month + 1) + "月" + date + "日");
        System.out.println("--------------");

        c.set(2011, 11, 11);
        // 获取年
        year = c.get(Calendar.YEAR);
        // 获取月
        month = c.get(Calendar.MONTH);
        // 获取日
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + (month + 1) + "月" + date + "日");
    }
}

案例：获取任意一年的二月有多少天。

分析：

  • A：键盘录入任意的年份
  • B：设置日历对象的年月日
    • 年就是A输入的数据
    • 月是2
    • 日是1
  • C：把时间往前推一天，就是2月的最后一天
  • D：获取这一天输出即可
import java.util.Calendar;
import java.util.Scanner;

public class CalendarTest {
    public static void main(String[] args) {
        // 键盘录入任意的年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = sc.nextInt();

        // 设置日历对象的年月日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1); // 其实是这一年的3月1日
        // 把时间往前推一天，就是2月的最后一天
        c.add(Calendar.DATE, -1);

        // 获取这一天输出即可
        System.out.println(c.get(Calendar.DATE));
    }
}

相关文章

网友评论

    本文标题：【JavaSE（八）】Java常见对象（下）

    本文链接：https://www.haomeiwen.com/subject/jiwgdftx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    Java-Python-Django社区

    程序员

    关于我们|服务条款|联系我们|【JavaSE（八）】Java常见对象（下）|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！