Random、Date、BigDecimal、Calender、Math类、模式器、匹配器

最新推荐文章于 2021-07-31 11:06:23 发布

qq_42667840

最新推荐文章于 2021-07-31 11:06:23 发布

阅读量162

点赞数

本文链接：https://blog.csdn.net/qq_42667840/article/details/107050292

版权

1 Random类

package Random类;

import java.util.Random;

public class Test {
    public static void main(String[] args) {
//        Random() 创建一个新得随机数生成器
        Random random = new Random();
//        nextInt()
//          返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
        for (int i = 0; i < 10; i++) {
            int i1 = random.nextInt();//无参的这个方法表示生成int范围内的随机数
            System.out.println(i1);
            int i2 = random.nextInt(100);//有参的方法表示从100的范围内最大的生成随机数,其范围为0-99
            System.out.println(i2);
        }
        for (int i = 0; i < 100; i++) {
            double v = random.nextDouble();//生成随机小数0-1范围内
            System.out.println(v);
        }
        for (int i = 0; i < 20; i++) {
            boolean b = random.nextBoolean();
            System.out.println(b);
        }

    }
}

package Random类;

import java.util.Arrays;
import java.util.Random;

public class Test1 {
    public static void main(String[] args) {
//        nextBytes(byte[] bytes)
//          生成随机字节并将其置于用户提供的 byte 数组中。
        byte[] bytes=new byte[10];
        Random random = new Random();
        random.nextBytes(bytes);//这一步把数组放进去之后，就直接填充了数据了
        for (int i = 0; i < 10; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println(Arrays.toString(bytes));//Arrays.toString可以将数组直接变成String字符串的形式，一定要记住啊！
        String sss=new String(bytes);//此表示的是将byte中的数字按照ASKII码表转换成String类型的对应字符串，两者要区分
        String s=new String("booleann");
        System.out.println(s);
//        Arrays中有copyof，equals，sort，toString方法，其中sort和toString这个方法很重要，sort中有个比较器，采用匿名内部类的方式

    }
}

package Random类;

import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
//        Random()
//          创建一个新的随机数生成器。
//Random(long seed)
//          使用单个 long 种子创建一个新的随机数生成器。
        Random random = new Random();//括号里面就是种子，其实就是有无参数，无参就是没种子，代表每次生成随机数不一样
        for (int i = 0; i < 5; i++) {
            int i1 = random.nextInt(10);
            System.out.println(i1);
        }
        System.out.println("===============================");
        Random random1 = new Random(10L);//括号里面有种子了，就会根据种子去算一个固定的随机数，每次的生成的都是一样的
        for (int i = 0; i < 5; i++) {
            int i1 = random1.nextInt(10);
            System.out.println(i1);
        }
    }
}

2 Date日期类


import java.util.Date;

public class Trst1 {
    public static void main(String[] args) {
//        Date日期类，能精确到毫秒
//        月份由从0至11的整数表示，0为1月，1为2月，以此类推。
//        日期由1到31来表示
        Date date = new Date();
        System.out.println(date);//重写了toString，按照西方的格式输出日期
//        Date(long date)
//          分配 Date 对象并初始化此对象，
// 以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
        System.out.println("========================");
        Date date1 = new Date(1000 * 60 * 60);//此表示给计算机元年增加相应的毫秒值,只要里面有参就表示为从计算机元年开始
        System.out.println(date1);
    }
}

package 日期类;

import java.util.Date;
@Deprecated
public class Test2 {
    public static void main(String[] args) {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//获取1979年1月1日到现在的毫秒值
//        或者用Systyem自带的方法也可以
        long l = System.currentTimeMillis();
        System.out.println(l);
        System.out.println("===========================================");
        Date date1 = new Date();
        date1.setTime(1000 * 60 * 60 * 24);//在这相当于给元年的日期加了一天（里面的方法肯定是用date1这个引用了，不然
        //调用完这个方法之后，date1里面的数据不会改变 ）
//        这里其实跟有参构造一样 new Date（1000 * 60 * 60 * 24）；
        System.out.println(date1);
//  注意：如果想标注一个类或者一个方法过时的话，可以用@Deprecated标注，标注过后的类或方法就会中间有一条横线

    }
}

package 日期类;

import java.util.Date;

public class Test4 {
public static void main(String[] args) {
    //    Date 到Long的转换
//      Date到Long类型转换
    Date date = new Date();
    long time = date.getTime();
//    long到Date的转换
    Date date1 = new Date(1000 * 60);//(1)方式1，有参里面的形参为long类型
    Date date2 = new Date();
    date2.setTime(1000*60);//与1的形参一样
    System.out.println(date2);//（2）方式2

}
}

package 日期类;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test5 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
//        默认的日期展示格式咱们看着不习惯
//        下面变换成咱们习惯的方式
//        通过日期类格式化，把日期变成我们想要的式子
//        用下面这个类：
//        使用空参构造，按照默认格式来格式化：
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        //        日期格式化：一定记住
        String format = simpleDateFormat.format(date);
        System.out.println(format);
        System.out.println("=========================");
//        按照我们指定的格式来格式化日期：
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = simpleDateFormat1.format(date);
        System.out.println(format1);
//字母  日期或时间元素  表示  示例
//G  Era 标志符  Text  AD
//y  年  Year  1996; 96
//M  年中的月份  Month  July; Jul; 07
//w  年中的周数  Number  27
//W  月份中的周数  Number  2
//D  年中的天数  Number  189
//d  月份中的天数  Number  10
//F  月份中的星期  Number  2
//E  星期中的天数  Text  Tuesday; Tue
//a  Am/pm 标记  Text  PM
//H  一天中的小时数（0-23）  Number  0
//k  一天中的小时数（1-24）  Number  24
//K  am/pm 中的小时数（0-11）  Number  0
//h  am/pm 中的小时数（1-12）  Number  12
//m  小时中的分钟数  Number  30
//s  分钟中的秒数  Number  55
//S  毫秒数  Number  978
//z  时区  General time zone  Pacific Standard Time; PST; GMT-08:00
//Z  时区  RFC 822 time zone  -0800
//        其中字母是固定的，必须这样写，但是拼接符可以自己定义
//      如：  yyyy-MM-dd HH:mm:ss 可写成yyyy年MM月dd日 HH：mm：ss，自己定义好就可以
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy年MM月dd日 HH：mm:ss 星期F");
        String format2 = simpleDateFormat2.format(date1);
        System.out.println(format2);
    }
}

package 日期类;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test6 {
    public static void main(String[] args) throws ParseException {
//        把一个日期字符串，格式化成一个日期对象。 String---》 Date
//        日期字符串
        String s="2020-06-25 16:21:32";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //这里一定要与上面的s里面的字符串对应一致,一定要对应一致，一定要对应一致！！！！


//        把日期字符串解析成日期对象
        Date parse = simpleDateFormat.parse(s);
        System.out.println(parse);

    }
}

3 Calendar日期类

package 日期类;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test6 {
    public static void main(String[] args) throws ParseException {
//        把一个日期字符串，格式化成一个日期对象。 String---》 Date
//        日期字符串
        String s="2020-06-25 16:21:32";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //这里一定要与上面的s里面的字符串对应一致,一定要对应一致，一定要对应一致！！！！


//        把日期字符串解析成日期对象
        Date parse = simpleDateFormat.parse(s);
        System.out.println(parse);

    }
}

package Calendar日期类;

import java.util.Calendar;
import java.util.Scanner;

public class MyTest2 {
    public static void main(String[] args) {
//        或者去用Calendar的日期类对象去获取今年的2月份有多少天
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份");
        int i = scanner.nextInt();
        Calendar instance = Calendar.getInstance();
//        instance.set(Calendar.YEAR,i);
//        instance.set(Calendar.MONTH,2);
//        instance.set(Calendar.DAY_OF_MONTH,1);
//        上面这样写太麻烦了，可以直接一步设置
        instance.set(i,3,1);//这里就是一步设置了，可以把年月日时分秒全部设置出来，也可以设置其中一部分
        instance.add(Calendar.DAY_OF_MONTH, -1);
        System.out.println(i+"年的2月份有"+instance.get(Calendar.DAY_OF_MONTH)+"天");
    }
}

package Calendar日期类;

import java.util.Calendar;
//Calendar类就是用来替代Date中过时的方法,这里讲的是获取日期的方法
public class Test {
    public static void main(String[] args) {
//        Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等
//       日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
//        其是抽象类，通过new对象无法直接调这个类，但是这个类里面有静态方法，可以通过其内的静态方法去调用这个类
        Calendar instance = Calendar.getInstance();
//        Calendar.getInstance();调用的最后是其子类，这里还是用的多态
        System.out.println(instance);
        int i = instance.get(Calendar.YEAR);//用来获取年份
        int i1 = instance.get(Calendar.MONTH);//月,括号里面可以写数字，但是这样不好
        int i2 = instance.get(Calendar.DAY_OF_MONTH);//日
        int i3 = instance.get(Calendar.HOUR);//时（12小时制）
        int i4 = instance.get(Calendar.HOUR_OF_DAY);//时（24时制）//一般用这个
        int i5 = instance.get(Calendar.MINUTE);//分
        int i6 = instance.get(Calendar.SECOND);//秒


    }
}

package Calendar日期类;

import java.util.Calendar;

import static java.util.Calendar.*;

public class Test2 {
    public static void main(String[] args) {
//        这里讲的是设置日期的方法
        Calendar instance = Calendar.getInstance();
        instance.set(Calendar.YEAR, 2000);//将年份设置为2000年
        int i = instance.get(Calendar.YEAR);//这里获取到的就是2000年了
        System.out.println(i);
        System.out.println("====================");
//        一次性设完
        instance.set(1998,01,01,13,25,11);//注意，这里的月份
//        范围是0-11的，也就是说01表示的是2月了，set，get都是这个意思
        System.out.println(instance.get(Calendar.MONTH));


    }
}

package Calendar日期类;

import java.util.Calendar;

public class Test3 {
    public static void main(String[] args) {
//        给某个日期对象加上或减去相应的日期
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.MONTH,2);//给现在对应的月份加上两个月
        instance.add(Calendar.YEAR,10);//给现在对应的年份加上10年，以此类推
//        注意：这里没有对应的减的方法，所以只能amount为负数的时候，对应的为减法
        instance.add(Calendar.DAY_OF_MONTH,-10);//对应当前日期减五天，而且其会计算减5天后对应月份的日期，
//        比如 这个月为4月1号，我减10，那么他就会对应计算减10之后的上一个月的日期号，为22
        System.out.println(instance.get(Calendar.DAY_OF_MONTH));
    }
}

4 BigDecimal 类

package BigDecimal类;

import java.math.BigDecimal;

public class Test {
    public static void main(String[] args) {
        double a=2.12424214;
        double b=3.41241241421241;
        System.out.println(a*b);//这样算精度达不到很高
//        如果对精度很高，double类型就不能满足了
//        JAVA给我们提供了相应的类来满足精度要求
        BigDecimal bigDecimal = new BigDecimal("2.12424214");
        BigDecimal bigDecimal1 = new BigDecimal("3.41241241421241");//注意里面是字符串类型就行了
        BigDecimal multiply = bigDecimal.multiply(bigDecimal1);
        System.out.println(multiply);//乘
        BigDecimal add = bigDecimal.add(bigDecimal1);
        System.out.println(add);//加
        BigDecimal subtract = bigDecimal.subtract(bigDecimal1);
        System.out.println(subtract);//减
        BigDecimal divide = bigDecimal.divide(bigDecimal1,20,BigDecimal.ROUND_CEILING);
        System.out.println(divide);//除法                （1）不能整除的情况
//        需声明小数点后面需保留多少位，以及取舍模式,如上所示,取舍模式可以查看文档
        BigDecimal bigDecimal2 = new BigDecimal("10");
        BigDecimal bigDecimal3 = new BigDecimal("2");
        BigDecimal divide1 = bigDecimal2.divide(bigDecimal3);
        System.out.println(divide1);//（2）可以整除的情况下，没有什么多说的


    }
}

package BigDecimal类;

import java.math.BigInteger;
// BigInteger也是对高精度要求所提出来的类
public class Test1 {
    public static void main(String[] args) {
//        注意：打断点的话一般都是在第一行打断点
        long maxValue = Long.MAX_VALUE;//这是个包装类，获取了其long类型的最大值
        BigInteger bigInteger = new BigInteger(maxValue + "");//形参表示为字符串类型
        BigInteger bigInteger1 = new BigInteger("22");
        System.out.println(bigInteger.add(bigInteger1));//跟BigDecimal类的方法一样，且形参都为字符串类型
//        当然也可以选多个断点，按F9可以从上一个断点调到下一个断点，或者点类似播放键的那个就可以到下一个断点，想从这个断点出来的
//        的话就点类似窗口关闭的那个按钮，就出来了，播放的那个按钮可以和窗口关闭的那个按钮可以交替使用
//        类似窗口关闭的那个按钮是从当前断点出去，但是出去的时候依旧回到的是之前执行到的那个语句，如果按向上的箭头的话
//        JAVA就认为这个语句你已经看完了，直接跳到了下一个执行语句上了就
//        利用Alt+F8或者类似计算器的东西可以自己设置计算表达式，就是你可以设置从哪个数开始看（例如循环的时候），就不用从头开始看了
//        Alt+F9 或者计算表达式旁边那个就是可以直接一步到光标点到的位置进行debug，但是每一步只能用一次，除非你跳出去在进来可以在用一次
    }
}

5 模式器、匹配器

package Pattern模式器和Matcher匹配器;

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

public class Test {
    public static void main(String[] args) {
//        Pattern模式器就是封装一个正则表达式
//        即正则表达式的编译形式
//        如：
        Pattern p=Pattern.compile("a*b");
//        通过模式器封装一个正则表达式
//        通过模式器获得一个匹配器Matcher，并把待匹配的字符串传入，如：
        Matcher m=p.matcher("aaaab");
//        调用匹配器中的匹配方法进行匹配，如：
        boolean a=m.matches();
        System.out.println(a);
// 如果只是用匹配功能这个要求，不需要用这两个类中这么复杂的方法，只需要用以前的正则表达式匹配的就可以，但这两个类中远不
//        止这两个方法。
    }
}

package Pattern模式器和Matcher匹配器;

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

public class Test2 {
    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 s1 = s.replaceAll("\\,|\\?+", " ");
        System.out.println(s1);
        String[] split = s1.split("\\s+");
        for (int i = 0; i < split.length; i++) {
            if (split[i].length()==3){
                System.out.println(split[i]);
            }
        }
        System.out.println("====================================================");
//pattern 与matcher方法：
//        1.我们定义一个正则表达式
        String regx="\\b[a-z]{3}\\b";//这个时候要注意，要加上单词边界，不然他就把空格也算上了
//        2.把正则表达式封装到模式器中
        Pattern compile = Pattern.compile(regx);
//        3.通过模式器，获取匹配器
        Matcher matcher = compile.matcher(s);

//   boolean find()
//       尝试查找与该模式匹配的输入序列的下一个子序列
//        String group()
//        返回由以前匹配操作所匹配的输入子序列
//        上述两个方发是先找有没有，才去在截，有才调用group，没有就不调用
//        4.先用查找的方法，再去匹配
//         boolean bb=matcher.find();
         while (matcher.find()){
             String group = matcher.group();
             System.out.println(group);//这个功能只能一次找一个，所以得用循环才能全部找完
         }



    }
}

6 Math 类

package Math类;

public class Test {
    public static void main(String[] args) {
//        Math类包含了用于执行基本数学得方法，如初等指数，对数，平方和三角函数等
        double pi=Math.PI;
        double e=Math.E;
        System.out.println(e);
        System.out.println(pi);
        System.out.println(Math.abs(-1));//获取绝对值
        System.out.println(Math.max(10,20));//获取两个数的最大值
        System.out.println(Math.max(Math.max(100,200),300));//获取三个数得最大值，依此类推
        System.out.println(Math.min(100,200));//最小值
        System.out.println(Math.min(Math.min(100,200),300));//三个数得最小值
        System.out.println(Math.ceil(3.14));//向上取整，变成了4.0了，
        System.out.println(Math.floor(3.14));//向下取整，变成了3.0
        System.out.println(Math.round(3.1222222222));//四舍五入，这个只取整数类型，为3
        System.out.println(Math.round(3.999999999));//4  它只看3得后一位小数，剩下的不看
        System.out.println(Math.sqrt(4));//对4取平方根 2，只取正得，且为小数形式，最终为2.0
        System.out.println(Math.pow(2, 16));//取次方，这个为2得16次方，也为小数形式，为65536.0
        System.out.println(Math.pow(8, 1 / 3.0));//对8取立方根(注意这里要用小数，几次方如果为分数得时候必须要用小数，整数次方不用)


    }
}

qq_42667840

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Random、Date、BigDecimal、Calender、Math类、模式器、匹配器

1 Random类package Random类;import java.util.Random;public class Test { public static void main(String[] args) {// Random() 创建一个新得随机数生成器 Random random = new Random();// nextInt()// 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
复制链接

扫一扫