Math类，Array类

最新推荐文章于 2024-08-23 17:37:15 发布
最新推荐文章于 2024-08-23 17:37:15 发布
阅读量458 收藏 1
点赞数
文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43669384/article/details/130100010
版权
  1. Math的方法大都是静态的可以直接引用 
    package com.jshedu.Math_;

/**
 * @author jia
 * @version 1.0
 */
public class MathMethod {
    public static void main(String[] args) {
        //看看Math常用的方法(静态方法)
        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9
        //2.pow 求幂
        double pow = Math.pow(2, 4);//2的4次方
        System.out.println(pow);//16
        //3.ceil 向上取整,返回>=该参数的最小整数(转成double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0
        //4.floor 向下取整，返回<=该参数的最大整数(转成double)
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0
        //5.round 四舍五入  Math.floor(该参数+0.5)
        long round = Math.round(5.51);
        System.out.println(round);//6
        //6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0

        //7.random 求随机数
        //  random 返回的是 0 <= x < 1 之间的一个随机小数
        // 思考：请写出获取 a-b之间的一个随机整数,a,b均为整数 ，比如 a = 2, b=7
        //  即返回一个数 x  2 <= x <= 7
        // 老韩解读 Math.random() * (b-a) 返回的就是 0  <= 数 <= b-a
        // 1.这里可以理解Math.random() * 10这个意思不就是产生一个0-10不包括10的值嘛
        // 2.Math.random() * (b-a)产生一个0-(b-a)不包括b-a的值嘛，
        // 3.(b-a +1)就产生等于b-a的值了。
        // 4.a + Math.random() * (b-a +1),a加上产生的这个值不就变成了a-b之间的随机一个数。
        // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
        // (2) 使用具体的数给小伙伴介绍 a = 2  b = 7
        //  (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
        //  Math.random()*6 返回的是 0 <= x < 6 小数
        //  2 + Math.random()*6 返回的就是 2<= x < 8 小数
        //  (int)(2 + Math.random()*6) = 2 <= x <= 7
        // (3) 公式就是  (int)(a + Math.random() * (b-a +1) )
        for(int i = 0; i < 100; i++) {
            System.out.println((int)(2 +  Math.random() * (7 - 2 + 1)));
        }

        //max , min 返回最大值和最小值
        int min = Math.min(1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);

    }
}

    random随机生成a-b之间的数

  2. Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

    1. 定制排序

      package com.hspedu.arrays_;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author jia
 * @version 1.0
 */
public class ArraysSortCustom {
    public static void main(String[] args) {

        int[] arr = {1, -1, 8, 0, 20};
        //bubble01(arr);

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;// return i2 - i1;
            }
        });

        System.out.println("==定制排序后的情况==");
        System.out.println(Arrays.toString(arr));

    }

    //使用冒泡完成排序
    public static void bubble01(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //从小到大
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //结合冒泡 + 定制
    public static void bubble02(int[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

      Comparator接口,里有一个compare方法

    2. package com.jshedu.arrays_;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ArraysMethod01 {
    public static void main(String[] args) {

        Integer[] integers = {1, 20, 90};
        //遍历数组
//        for(int i = 0; i < integers.length; i++) {
//            System.out.println(integers[i]);
//        }
        //直接使用Arrays.toString方法，显示数组
//        System.out.println(Arrays.toString(integers));//

        //演示 sort方法的使用

        Integer arr[] = {1, -1, 7, 0, 89};
        //进行排序
        //老韩解读
        //1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
        //2. 因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
        //3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
        //   (2) 实现了Comparator接口的匿名内部类 , 要求实现  compare方法
        //5. 先演示效果，再解释
        //6. 这里体现了接口编程的方式 , 看看源码，就明白
        //   源码分析
        //(1) Arrays.sort(arr, new Comparator()
        //(2) 最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo, int hi, int start,
        //                                       Comparator<? super T> c)()
        //(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
        //    匿名内部类的 compare ()
        //     while (left < right) {
        //                int mid = (left + right) >>> 1;
        //                if (c.compare(pivot, a[mid]) < 0)
        //                    right = mid;
        //                else
        //                    left = mid + 1;
        //            }
        //(4) new Comparator() {
        //            @Override
        //            public int compare(Object o1, Object o2) {
        //                Integer i1 = (Integer) o1;
        //                Integer i2 = (Integer) o2;
        //                return i2 - i1;
        //            }
        //        }
        //(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
        //    会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
        //    将来的底层框架和源码的使用方式，会非常常见
        //Arrays.sort(arr); // 默认排序方法
        //定制排序
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println("===排序后===");
        System.out.println(Arrays.toString(arr));//



    }
}

      原码分析，看调用哪个方法。

    3. asList将一组值转换成list

      package com.jshedu.arrays_;

import java.util.Arrays;
import java.util.List;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 90, 123, 567};
        // binarySearch 通过二分搜索法进行查找，要求必须排好
        // 老韩解读
        //1. 使用 binarySearch 二叉查找
        //2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
        //3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
        //low代表的是应该存在的位置。568应该存在567后面下标应该是5,在加1，取负数-6
        int index = Arrays.binarySearch(arr, 568);
        System.out.println("index=" + index);//-6

        //copyOf 数组元素的复制
        // 老韩解读
        //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
        //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
        //4. 该方法的底层使用的是 System.arraycopy()
        //5. 可以拷0个，就是空数组
        Integer[] newArr = Arrays.copyOf(arr, arr.length+1);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));//[1, 2, 90, 123, 567, null]

        //fill 数组元素的填充
        Integer[] num = new Integer[]{9,3,2};
        //老韩解读
        //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
        Arrays.fill(num, 99);
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));//[99, 99, 99]

        //equals 比较两个数组元素内容是否完全一致
        Integer[] arr2 = {1, 2, 90, 123};
        //老韩解读
        //1. 如果arr 和 arr2 数组的元素一样，则方法true;
        //2. 如果不是完全一样，就返回 false
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("equals=" + equals);//equals=false

        //asList 将一组值，转换成list
        //老韩解读
        //1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
        //   静态内部类 private static class ArrayList<E> extends AbstractList<E>
        //              implements RandomAccess, java.io.Serializable
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);//asList=[2, 3, 4, 5, 6, 1]
        System.out.println("asList的运行类型" + asList.getClass());



    }
}

      编译类型，运行类型

  3. Array练习

    package com.hspedu.arrays_;


import java.util.Arrays;
import java.util.Comparator;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ArrayExercise {
    public static void main(String[] args) {
        /*
        案例：自定义Book类，里面包含name和price，按price排序(从大到小)。
        要求使用两种方式排序 , 有一个 Book[] books = 4本书对象.

        使用前面学习过的传递 实现Comparator接口匿名内部类，也称为定制排序。
        [同学们完成这个即可 10min  ],
        可以按照 price (1)从大到小 (2)从小到大 (3) 按照书名长度从大到小

         */

        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("金瓶梅新", 90);
        books[2] = new Book("青年文摘20年", 5);
        books[3] = new Book("java从入门到放弃~", 300);

        //(1)price从大到小

//        Arrays.sort(books, new Comparator() {
//            //这里是对Book数组排序，因此  o1 和 o2 就是Book对象
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();
//                //这里老师进行了一个转换
//                //如果发现返回结果和我们输出的不一致，就修改一下返回的 1 和 -1
//                if(priceVal > 0) {
//                    return  1;
//                } else  if(priceVal < 0) {
//                    return -1;
//                } else {
//                    return 0;
//                }
//            }
//        });

        //(2)price从小到大
//        Arrays.sort(books, new Comparator() {
//            //这里是对Book数组排序，因此  o1 和 o2 就是Book对象
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();
//                //这里老师进行了一个转换
//                //如果发现返回结果和我们输出的不一致，就修改一下返回的 1 和 -1
//                if(priceVal > 0) {
//                    return  -1;
//                } else  if(priceVal < 0) {
//                    return 1;
//                } else {
//                    return 0;
//                }
//            }
//        });

        //(3)按照书名长度从大到小

        Arrays.sort(books, new Comparator() {
            //这里是对Book数组排序，因此  o1 和 o2 就是Book对象
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                //要求按照书名的长度来进行排序
                return book2.getName().length() - book1.getName().length();
            }
        });


        System.out.println(Arrays.toString(books));

    }
}

class Book {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

枯寂麻辣
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何在Markdown文档中使用MathType插入公式（含矩阵处理办法）
qq_42138662的博客
10-05 1882
在CSDN上写博客的时候，插入公式是一个令人头疼的问题，这篇文章记录如何利用mathtype 一、旋转向量 如图x=−b±b2−4ac2ax=\frac{-b\pm\sqrt{b^2-4ac}}{2a}x=2a−b±b2−4ac​​
类数组和数组
Mr.ShyZhang趟过的前端“小路坑”
06-10 4301
类数组和数组的转化类数组和数组的区别
2024最新MathType7数学公式编辑器下载使用操作详细教程
热门推荐
CaiHuaZeiPoJie的博客
05-06 6万+
很多理科论文中往往需要用到很多复杂的公式，但这些复杂的公式在office软件中是无法进行编辑的，这时就需要借助mathtype公式编辑器进行编辑，那公式编辑器怎么使用呢？有时在使用word时还需要对一些数据进行计算，那公式编辑器怎么计算呢？
由mathtype编写latex公式
魔法森林博客
11-15 8085
最近因为投稿的原因使用了Latex编辑文档，很多想要的效果不会实现，尤其是编辑公式的时候，复杂的语法格式组合，对长公式的编写是一件费时又费力的事情，尤其是一直以来使用mathtype公式编辑文档，突然使用latex有点不习惯。因为latex要根据其语法格式编写公式，不像Mathtype所见即所得，但是，还是有方法实现由Mathtype编写公式，然后生成latex公式代码的，本文简单介绍学习late
java Math类 和 System类 详解（通俗易懂）
Cyan_RA9的博客
03-09 2377
java API专题——常用类Math类 和 System类。
Java Math类，Math类小练习
Gaoju12138的博客
10-25 688
1、Math类 java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。 1、public static double abs(double num):获取绝对值。有多种重载 2、public static double ceil(double num):向上取整。 3、public static double floor(double num):向下取整。 4、public static long round(double num): 四舍五入。 ...
Math类详解与Random类、三种随机数生成方式（java）
罗铠威的博客
03-05 977
本篇博客主要以介绍Math类的常用方法及认识Random类，及三种随机数生成方式。
IDEA-Arrays工具类、Math数学类的使用
weixin_46370945的博客
02-16 1525
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。 public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素一,元素二,元素三…]） public static void sort(数组):按照默认升序（从小到大）对数组的元素进行排序。 备注： 1.如果是数组，sort默认按照升序从小到大 2.如果是字符串，sort默认按照字母升序 3.如果是自定义的类型，那么这个自定义的类需要有Comparabl
Javascript内部类
Switch的博客
12-24 4667
Javascript内部类 基本概念     JS中本身提供了一些可以直接使用的类，这些类就是内部类。 主要有： Array,Boolean,Date,Math,Number,String,RegExp PS：因为所有类都是从Object类中继承而来的，所有上述内部类都有Object的属性和方法。   内部类的分类 静态类 基本语法： 类名.属性/方法   Ma
java数组Array类（数组的方法类）
Half-up的博客
06-18 4782
package Array; import java.util.Arrays; public class Arraydemo1 { public static void main(String[] args) { int a[] = {1,2,3,4,9090,34242,3424,4242,4,24}; System.out.println(a); //打印数组元素 System.out.println(Arrays.toSt.
JAVA如何使用Math类操作数据
08-19
JAVA Math 类操作数据 JAVA 语言中的 Math 类是一个基本的数学工具类，位于 java.lang 包中，提供了许多静态方法来执行基本的数学运算。这些方法可以帮助开发者快速地实现数学计算，提高开发效率。 在本文中，我们...
Java中Arrays类与Math类详解
08-26
Java中Arrays类与Math类详解 Java中Arrays类与Math类是两个非常重要的类别，它们都提供了许多有用的静态方法来处理数组和数学运算。在本文中，我们将详细介绍Java中Arrays类与Math类的使用方法和示例代码。 Arrays...
leetcode题目分类
12-10
如数组（array）、链表（linked list）、字符串（string）、哈希表（hashtable）、栈（stack）、队列（queue）、二叉树（binary tree）、图（graph）、动态规划（DP）、数学问题（Math）、双指针技巧（Two Pointers...
开发常用工具类
01-26
例如，你可以使用`Arrays.sort(int[] array)`对整型数组进行升序排序。 2. **`java.util.Collections`**: 类似于`Arrays`，但针对集合框架。它提供了对List、Set和Map的操作，如排序（`sort()`）、反转（`reverse()...
常用类
11-28
在JavaScript中，Array、Object、String等内置对象就是常用类，还有Map、Set等ES6引入的新数据结构。此外，像lodash和jQuery这样的库提供了大量实用函数，如数组处理、对象操作、DOM操作等，极大地丰富了JavaScript...
MySQL 相关知识笔记
最新发布
weixin_68929783的博客
08-23 653
以上是根据 B 站黑马课程学习后的 MySQL 笔记，为了日后复习和给别人参考而整理，希望对大家有所帮助。同时，在实际应用中，还需要根据具体情况合理使用索引、约束等功能，以提高数据库的性能和数据的完整性。
Freertos学习笔记
qq_45031559的博客
08-21 617
Freertos学习笔记
分享思源笔记的几个骚操作
2301_80064376的博客
08-21 312
本文章主要分享下思源笔记软件最喜爱的几个功能
[Matsim]Matsim学习笔记-车辆和订单匹配的逻辑
机器学习菜鸟
08-23 155
这个方法体现了在DRT系统中对未计划请求进行调度的逻辑，包括对旧请求的重试和新请求的调度。通过并行处理车辆入口信息的创建，提高了调度过程的效率。matsim扩展包中DRT动态线路的场景是，给定一些车辆、一些订单，进行车辆和订单的匹配，类似滴滴的拼车功能。的方法，它用于调度未计划的DRT（需求响应交通）请求。操作，确保了在调度过程中对已处理的请求进行清理，避免重复调度。
JavaScript内置对象详解：String、Math、Array操作指南
本资源文档名为《JavaScript的String、Math、Array等数据对象.pdf》，主要聚焦于这三个核心内置对象的详细解释。 首先，我们来看看String对象。String对象与原始字符串类型相辅相成，它是JavaScript的核心对象之一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值