Java常用工具类 Math Collections Random Date Calendar的使用

最新推荐文章于 2022-08-11 20:44:44 发布

SkylakeXun

最新推荐文章于 2022-08-11 20:44:44 发布

阅读量375

点赞数

分类专栏：代码库

本文链接：https://blog.csdn.net/SkylakeXun/article/details/78543176

版权

代码库专栏收录该内容

33 篇文章 0 订阅

订阅专栏

Math

        /**
         * 返回指定数字的绝对值
         * @Params int ,long, double,float
         * @Return int ,long, double,float
         */
        Math.abs(-1);//1

        /**
         * 向上取整
         * @Params double
         * @Return double
         */
        Math.ceil(-312.2231);//-312.00

        /**
         * 向下取整
         * @Params double
         * @Return double
         */
        Math.ceil(-312.2231);//-313.00

        /**
         * 比较并返回两者中较大的值
         * @Params1 int ,long, double,float
         * @Params2 int ,long, double,float
         * @Return int ,long, double,float
         */
        Math.max(1,2);//2

        /**
         * 比较并返回两者中较小的值
         * @Params1 int ,long, double,float
         * @Params2 int ,long, double,float
         * @Return int ,long, double,float
         */
        Math.min(1,2);//1

        /**
         * 返回一个(0.0,1.0)的数字
         * @Return double
         */
        Math.random();

        /**
         * 小数部分>0.5向较大绝对值的数取整,<=0.5的向较小绝对值的数取整
         * @Params double
         * @Return double
         */
        Math.rint(-2.51);//-3.0

        /**
         * 小数部分=0.5时向上取整,其余为四舍五入
         * @Params float double
         * @Return int
         */
        Math.round(-2.5);//-2
        Math.round(2.5);//3

        /**
         * 求一个数的三角正弦值
         * @Params 弧度大小 弧度=2 * PI/360 * 角度
         * @Return double
         */
        Math.sin(1.0);

        /**
         * 求一个数的三角余弦值
         * @Params 弧度大小 弧度=2 * PI/360 * 角度
         * @Return double
         */
        Math.cos(1.0);

        /**
         * 求一个数的三角正切值
         * @Params 弧度大小 弧度=2 * PI/360 * 角度
         * @Return double
         */
        Math.tan(1.0);

        /*
        * 假设一个圆的圆心坐标为(a,b),半径为r
        * 则该圆的轨迹坐标为(a + Math.sin(2*Math.PI / 360) * r,b + Math.cos(2*Math.PI / 360) * r )
        * */
        /*for(var times=0; times<60; times++) {
         *var hudu = (2*Math.PI / 360) * 6 * times;
         *var X = a + Math.sin(hudu) * r;
         *var Y = b - Math.cos(hudu) * r    //  注意此处是“-”号，因为我们要得到的Y是相对于（0,0）而言的。
        }*/

        /**
         * 返回指数函数,返回param1的param2次方
         * @Params1 double
         * @Params2 double
         * @Return double
         */
        Math.pow(2,3);//8

        //Pi常量
        double pi = Math.PI;

        /**
         * 返回立方根
         * @Param double
         * @Return double
         */
        Math.cbrt(2.2);

        /**
         * 将弧度制转换为角度制
         * @Param double
         * @Return double
         */
        Math.toDegrees(Math.PI);//180

        /**
         * 将角度制转换为弧度制
         * @Param double
         * @Return double
         */
        Math.toRadians(180);//3.14

        /**
         * 返回参数的符号函数:如果参数是零，则返回零；如果参数大于零，则返回 1.0；如果参数小于零，则返回 -1.0。
         * @Params double float
         * @Return int
         */
        Math.signum(89);

        /**
         * 返回底数为10的自然对数
         * @Params double
         * @Return double
         */
        Math.log10(100);//2

        /**
         * 返回底数为e的自然对数
         * @Params double
         * @Return double
         */
        Math.log(100);

        /**
         * 开平方根
         * @Param double
         * @Return double
         */
        Math.sqrt(4);

        /**
         * 勾股定理计算
         * @Param1 double
         * @Param2 double
         * @Return double
         */
        Math.hypot(3,4);//5.0

        /**
         * 返回角的反余弦，范围在 0.0 到 pi 之间。
         * @Param1 double
         * @Return double
         */
        Math.acos(1.1);
        /**
         * 返回角的反正弦，范围在 -pi/2 到 pi/2 之间。
         * @Param1 double
         * @Return double
         */
        Math.asin(1.1);
        /**
         * 返回角的反正切，范围在 -pi/2 到 pi/2 之间。
         * @Param1 double
         * @Return double
         */
        Math.atan(1.1);

Collections

       ArrayList<String> list = new ArrayList<>();

        /**
         * 将所有指定元素添加到指定 collection 中。
         * @Param1 Collection<? super T>
         * @Param2 T... a
         */
        Collections.addAll(list, "你", "好", "啊");//[你, 好, 啊]

        /**
         * 使用二进制搜索算法来搜索指定列表，以获得指定对象。
         */
        //        Collections.binarySearch(list, 1, new Comparator<Serializable>() {
        //            @Override
        //            public int compare(Serializable o1, Serializable o2) {
        //                return 0;
        //            }
        //        });

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("1");
        list2.add("2");
        list2.add("3");
        /**
         * 将所有元素从一个列表复制到另一个列表。
         * @Param1 List, 目标数组, 大小必须大于源数组
         * @Param2 List, 源数组
         */
        Collections.copy(list2, list);

        /**
         * 如果两个指定 collection 中没有相同的元素，则返回 true。
         */
        Collections.disjoint(list, list2);

        /**
         * 返回空的列表（不可变的）。
         */
        List<String> objects = Collections.emptyList();
        //objects.add("ni "); 抛出UnsupportedOperationException
        Collections.emptyMap();
        Collections.emptySet();

        /**
         * 使用指定元素替换指定列表中的所有元素。
         */
        Collections.fill(list, "啊");//[啊, 啊, 啊]

        /**
         * 返回指定 collection 中等于(equals)指定对象的元素数。
         */
        int x = Collections.frequency(list, "啊");//3

        /**
         * 返回指定源列表中第一次出现指定目标列表的起始位置，如果没有出现这样的列表，则返回 -1。
         * @Param1 源数组
         * @Param2 目标数组
         */
        Collections.indexOfSubList(list, list2);

        /**
         * 返回指定源列表中最后一次出现指定目标列表的起始位置，如果没有出现这样的列表，则返回 -1。
         * @Param1 源数组
         * @Param2 目标数组
         */
        Collections.lastIndexOfSubList(list, list2);

        /**
         * 返回一个数组列表，它按照枚举返回元素的顺序包含指定枚举返回的元素。
         * @Param Enumeration<T>
         * @Return ArrayList<T>
         */
//        Collections.list();

        /**
         * 根据元素的自然顺序 返回给定 collection 的最小元素
         */
        String min = Collections.min(list);
        /**
         * 根据指定比较器产生的顺序，返回给定 collection 的最小元素。
         */
        Collections.min(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return 0;
            }
        });

        /**
         * 使用另一个值替换列表中出现的所有某一指定值。
         * @Param1 List
         * @Param2 被替换的T
         * @Param3 用于替换的
         */
        Collections.replaceAll(list,"啊","a");

        /**
         * 反转指定列表的顺序
         * @Param List
         */
        Collections.reverse(list);
        /**
         * 返回一个比较器，它强行反转实现 Comparable 接口那些对象 collection 上的自然顺序。
         */
        Comparator<Object> objectComparator = Collections.reverseOrder();
        /**
         * 返回一个比较器，它强行反转指定比较器的顺序。
         */
        Collections.reverseOrder(new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        });

        /**
         * 根据指定的距离循环移动指定列表中的元素。
         */
        Collections.rotate(list,2);
        /**
         * 使用默认随机源随机更改指定列表的序列。
         */
        Collections.shuffle(list);

        /**
         * 根据元素的自然顺序 对指定列表按升序进行排序。
         */
        Collections.sort(list);
        /**
         * 根据指定比较器产生的顺序对指定列表进行排序。
         */
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return 0;
            }
        });

        /**
         * 返回由指定 collection 支持的同步（线程安全的）collection。
         * 余下同理
         */
//        Collections.synchronizedCollection();
//        Collections.synchronizedList();
//        Collections.synchronizedMap();
//        Collections.synchronizedSet();
        /**
         * 返回由指定有序映射支持的同步（线程安全的）有序映射。
         */
//        Collections.synchronizedSortedMap();
//        Collections.synchronizedSortedSet();
        /**
         * 返回指定 collection 的不可修改数据
         */
//        Collections.unmodifiableCollection();
//        Collections.unmodifiableList();
//        Collections.unmodifiableMap();
//        Collections.unmodifiableSet();
//        Collections.unmodifiableSortedMap();
//        Collections.unmodifiableSortedSet();

Random

        Random random = new Random();

        //使用单个 long 种子设置此随机数生成器的种子。
        random.setSeed(12412412512312312l);

        //返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。
        random.nextBoolean();

        //生成随机字节并将其置于用户提供的字节数组中。
        /*random.nextBytes(byte[] bytes);*/

        //返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的 double 值。
        random.nextDouble();

        //返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。
        random.nextFloat();

        //返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。
        random.nextGaussian();

        //返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
        random.nextInt();

        //返回下一个伪随机数，范围为(0,n);
        random.nextInt(10);

        //返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。
        random.nextLong();

Arrays

       /**
         * 返回一个受指定数组支持的固定大小的列表
         */
        List<String> strings = Arrays.asList("你", "好", "啊");

        Integer[] ints=new Integer[]{1, 2, 3, 5, 123, 62345, 123, 11, 2, 3, 45, 1};
        /**
         * 使用二进制搜索算法来搜索指定的 T 型数组，以获得指定的值。
         * @param1 byte[] char[] double[] float[] int[] long[] Object[] short[] T[]
         * @param2 byte   char   double   float   int   long   Object   short   T
         * @Return int 可能会负数,3代表从左往右数第三位,-5代表从右往左数第5位
         */
        Arrays.binarySearch(ints,11);//-5

        /**
         * 如果两个指定数组彼此是深层相等 的，则返回 true。
         */
        Arrays.deepEquals(ints,ints);

        /**
         * 基于指定数组的“深层内容”返回哈希码。
         * @Return int hashcode
         */
        int hashCode = Arrays.deepHashCode(ints);

        /**
         * 返回指定数组“深层内容”的字符串表示形式。
         */
        String s = Arrays.deepToString(ints);//[1, 2, 3, 5, 123, 62345, 123, 11, 2, 3, 45, 1]

        /**
         * 如果两个指定的 数组彼此相等，则返回 true。
         * @Param1 boolean[] byte[] char[] double[] float[] int[] long[] Object[] short[]
         * @Param2 boolean[] byte[] char[] double[] float[] int[] long[] Object[] short[]
         * @Return boolean
         */
        Arrays.equals(ints,ints);

        /**
         * 将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
         * @Param1 boolean[] byte[] char[] double[] float[] int[] long[] Object[] short[]
         * @Param2 boolean   byte   char   double   float   int   long   Object   short
         */
        Arrays.fill(ints,1);

        /**
         * 将指定的 boolean 值分配给指定 boolean 型数组的指定范围内的元素。
         * @Param1 boolean[] byte[] char[] double[] float[] int[] long[] Object[] short[]
         * @Param2 int fromIndex
         * @Param3 int toIndex
         * @Param4 boolean   byte   char   double   float   int   long   Object   short
         */
        Arrays.fill(ints,1);

        /**
         * 基于指定数组的内容返回哈希码。
         * @Param1 boolean[] byte[] char[] double[] float[] int[] long[] Object[] short[]
         */
        Arrays.hashCode(ints);

        /**
         * 对指定的数组按数字升序进行排序。
         * @Params byte[] char[] double[] float[] int[] long[] Object[] short[] T[]
         */
        Arrays.sort(ints);
        /**
         * 对指定 long 型数组的指定范围按数字升序进行排序。
         * @Param1 byte[] char[] double[] float[] int[] long[] Object[] short[] T[]
         * @Param2 int fromIndex
         * @Param3 int toIndex
         */
        Arrays.sort(ints,2,5);

        /**
         * 返回指定数组内容的字符串表示形式。
         * @Params boolean[] byte[] char[] double[] float[] int[] long[] Object[] short[]
         * @Return String
         */
        String s1 = Arrays.toString(ints);

Date

        long currentTime = System.currentTimeMillis();
        Date newDate1 = new Date(currentTime);
        /**
         * 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”
         * ，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
         */
        Date newDate2 = new Date(currentTime+1);
        /**
         * 根据参数确定日期和时间。这些参数被解释为年份、月份、月中某一天、一天中的某一小时、小时中某一分钟和分钟中的某一秒。
         * @Param1 int year
         * @Param2 int month
         * @Param3 int date
         * @Param4 int hrs
         * @Param5 int min
         * @Param6 int sec
         */
//        Date.UTC();

        /**
         * 判断当前使用的日期是否在传入日期之前
         * @Param Date
         * @Return boolean
         */
        boolean isbefore = newDate1.before(newDate2);//true
        /**
         * 判断当前使用的日期是否在传入日期之后
         * @Param Date
         * @Return boolean
         */
        boolean isafter = newDate1.after(newDate2);//false

        /**
         * 比较两个日期的顺序
         * @Param Date
         * @Return int -1 表示在之前  1表示之后 0表示相等
         */
        newDate1.compareTo(newDate2);

        /**
         * 返回几号
         */
        int date = newDate1.getDate();
        /**
         * 返回星期几
         */
        int day = newDate1.getDay();
        /**
         * 返回小时
         */
        int hour = newDate1.getHours();
        /**
         * 返回分钟
         */
        int minute = newDate1.getMinutes();
        /**
         * 返回月份
         */
        int month = newDate1.getMonth();
        /**
         * 返回分钟数
         */
        int second = newDate1.getSeconds();
        /**
         * 返回年份
         */
        int year = newDate1.getYear();//返回的数字+1900才是当前年份

        /**
         * 返回时间戳
         */
        long time = newDate1.getTime();

        /**
         * 返回和标准时区的时间偏移量
         * @Return int minutes
         */
        int timezoneOffset = newDate1.getTimezoneOffset();//480,也就是东8区

        /**
         * 尝试把一个事件字符串解析为时间戳,解析失败会抛出一个IllegalArgumentException
         * @Param String "Sat, 12 Aug 1995 13:30:00 GMT",接受很多表示事件的字符串
         * @Return int
         */
        //        long time = Date.parse("");

        /**
         * 获取表示标准时区时间的字符串
         * @Return String
         */
        String s = newDate1.toGMTString();

        /**
         * 获取表示当前时区时间的字符串
         * @Return String
         */
        String localTimeString = newDate1.toLocaleString();//2017年11月16日 10:09:30

        /**
         * 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy
         */
        String string = newDate1.toString();//Thu Nov 16 10:10:28 GMT+08:00 2017

        /**
         * 设置时间
         */
//        newDate1.setTime();
//        newDate1.setDate();
//        newDate1.setHours();
//        newDate1.setMinutes();
//        newDate1.setSeconds();
//        newDate1.setMonth();
//        newDate1.setYear();

Calendar

        //使用默认时区和语言环境获得一个Calendar对象
        Calendar calendar = Calendar.getInstance();
        //使用指定语言和默认时区获取一个Calendar对象
        Calendar.getInstance(Locale.CHINA);

        //返回此日历的字符串表示形式。
        String calendarString = calendar.toString();//java.util.GregorianCalendar[time=1510813688965,areFieldsSet=true,lenient=true,zone=Asia/Shanghai,firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2017,MONTH=10,WEEK_OF_YEAR=46,WEEK_OF_MONTH=3,DAY_OF_MONTH=16,DAY_OF_YEAR=320,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=2,HOUR_OF_DAY=14,MINUTE=28,SECOND=8,MILLISECOND=965,ZONE_OFFSET=28800000,DST_OFFSET=0]

        //使用给定的时区值来设置时区。
//        calendar.setTimeZone(TimeZone timeZone);

        /**
         * 用给定的 long 值设置此 Calendar 的当前时间值。
         * @Param long
         */
        calendar.setTimeInMillis(System.currentTimeMillis());

        /**
         * 使用给定的 Date 设置此 Calendar 的时间。
         * @Param
         */
        calendar.setTime(new Date());

        /**
         * 设置一星期的开始是哪一天,美国是sunday,法国是monday
         */
        calendar.setFirstDayOfWeek(Calendar.MONDAY);

        /**
         * 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
         */
        //        calendar.set(int year, int month, int date);

        /**
         * 设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。
         */
        //        calendar.set(int year, int month, int date, int hourOfDay, int minute);

        /**
         * 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。
         */
//        calendar.set(int year, int month, int date, int hourOfDay, int minute, int second);

        calendar.setTimeInMillis(System.currentTimeMillis()-11000);
        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTimeInMillis(System.currentTimeMillis());

        /**
         * 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。
         * @Param Object ,当且仅当 when 是一个 Calendar 实例时才返回 true。否则该方法返回 false。
         * @Return boolean
         */
        boolean before = calendar.before(calendar2);
        /**
         * 表示的时间是否在指定 Object 表示的时间之后，返回判断结果。
         * @Param Object ,当且仅当 when 是一个 Calendar 实例时才返回 true。否则该方法返回 false。
         * @Return boolean
         */
        boolean after = calendar.after(calendar2);

        /**
         * 比较两个 Calendar 对象表示的时间值（从历元至现在的毫秒偏移量）。
         * @Param Calendar
         * @int Calendar.AM=0,Calendar.PM=1;
         */
        int i = calendar.compareTo(calendar2);//-1

        /**
         * 当前时间是在中午之前还是之后
         * @Return -1之前 1之后
         */

        int isAfterAM = calendar.get(Calendar.AM_PM);
        /**
         * 当前月份的第一天是星期几
         */
        int weekOfMonth = calendar.get(Calendar.WEEK_OF_MONTH);

        /**
         * 返回当前是几号
         */
        int date = calendar.get(Calendar.DATE);

        /**
         * 返回当前是本月的第几天,效果同上
         */
        int i1 = calendar.get(Calendar.DAY_OF_MONTH);

        /**
         * 当前是本周的第几天,默认第一天是周日
         */
        int i2 = calendar.get(Calendar.DAY_OF_WEEK);

        /**
         * 当前是今天的第几天
         */
        int i3 = calendar.get(Calendar.DAY_OF_YEAR);

        /**
         * 当前是本月的第几周
         */
        int i4 = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);

        /**
         * 今天的第几个小时
         */
        int i5 = calendar.get(Calendar.HOUR_OF_DAY);

        /**
         * 在当前秒中的毫秒数
         */
        int i6 = calendar.get(Calendar.MILLISECOND);
        /**
         * 当前小时的第几分钟
         */
        int i7 = calendar.get(Calendar.MINUTE);

        /**
         * 当前的年份
         */
        int i8 = calendar.get(Calendar.YEAR);

        /**
         * 获取当前的时间戳
         */
        long timeInMillis = calendar.getTimeInMillis();

        /**
         * 返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。
         */
        Date time = calendar.getTime();

        /**
         * 获取当前的时区
         */
        TimeZone timeZone = calendar.getTimeZone();