Math类,Array类

这篇具有很好参考价值的文章主要介绍了Math类,Array类。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  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练习文章来源地址https://www.toymoban.com/news/detail-411600.html

    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 +
                    '}';
        }
    }
    

到了这里,关于Math类,Array类的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 由 Array.includes 函数引发对引用数据类型的思考

    `` 数组的includes方法在日常的编程中比较常用到,其作用就是判断某一数据是否在数组中,通常来说,数组中的数据如果是数字,布尔值,或者字符串的话,都是能够进行判断的 例如: 如果是对象的话,那么会有一个有趣的现象发生 arr.includes({ age: 11, name: \\\'bob\\\'}) 这行,inclu

    2024年02月09日
    浏览(62)
  • 详解5种网站 静态网站、动态网站、伪静态网站、云计算网站都是什么

    网站,在日常生活中已经是一种司空见惯的东西。但如果你真正要做一个网站,或者学习开发一个网站的时候。你会发现网站其实也分很多种。你会听到很多概念:静态网站、动态网站、前端、后端、伪静态网站、数据库、云计算、H5等。那么,我们就来聊聊网站为什么会有

    2023年04月23日
    浏览(43)
  • cmake find_package、引用GDAL 初步学习

    上次的源码的CMakeLists.txt文件里有 find_package(GDAL REQUIRED) 这句; 从字面意思看此源码需要GDAL库; 查了一下,find_package 指令的基本功能是查找第三方库,并返回其细节;   我当前GDAL安装在D:GDAL; 先把它的CMakeLists.txt重命名为别的,不使用; 新建一个CMakeLists.txt,里面有三句

    2024年02月06日
    浏览(34)
  • Uniapp 酷炫钱包页面模板 直接引用

    直接引用Vue页面 即可   下载链接(点击) https://ext.dcloud.net.cn/plugin?id=15071 提需求 问题反馈 联系作者 V:ANKR6699 添加下方的名片即可

    2024年02月08日
    浏览(42)
  • uniapp 小程序公共组件引用,无需导入和注册,直接使用

    相关文档链接:https://uniapp.dcloud.net.cn/tutorial/vue-components.html 页面引入组件方式 第一种:传统vue规范 第二种:通过uni-app的easycom 无需导入组件,无需注册组件,只要按照如下格式创建组件( 符合‘components/组件名称/组件名称.vue’目录结构,easycom方式可直接使用组件 ),创建

    2024年02月16日
    浏览(38)
  • unity 要怎么引用第三方库,直接用useing不?

    在Unity中引用第三方库的常见方法是使用 Assembly Definition Files(程序集定义文件) 。 这是一种Unity提供的机制,允许您创建自己的程序集,以便在Unity项目中引用和使用第三方库。以下是一些简单的步骤: 在Unity编辑器中,右键点击您的Assets文件夹,选择 Create    Assembly Defi

    2024年02月07日
    浏览(49)
  • Java基础知识——类、静态、继承、引用类型使用

    类的定义格式如下: 例如: 例如: 1.3.1 封装的步骤 1.使用 private 来修饰成员变量。 2.使用 public 修饰getter和setter方法。 1.3.2 封装的步骤实现 private修饰成员变量 public修饰getter和setter方法 1.4.1 构造器的作用 通过调用构造器可以返回一个类的对象,构造器同时负责帮我们把

    2023年04月19日
    浏览(45)
  • k8s除了可以直接运行docker镜像之外,还可以运行什么? springboot项目打包成的压缩包可以直接运行在docker容器中吗?

    Kubernetes(k8s)主要设计用于自动部署、扩展和管理容器化应用程序。虽然它与Docker容器最为密切相关,Kubernetes实际上是与容器运行时技术无关的,这意味着它不仅仅能够管理Docker容器。Kubernetes支持多种容器运行时,包括但不限于: Docker :最为人熟知的容器平台,Kubernetes最

    2024年02月21日
    浏览(51)
  • JS中 Math 和 Number 内置对象常用的一些方法

    参数:num,一个需要求绝对值的数。 参数:num,需要进行上舍入的数值。 注意事项:对于负数进行上舍入时会出现一定的差错。 参数:num,需要进行下舍入的数值。 参数:num1, num2, …, numN,需要比较的数值,可以是任意个数的参数。 注意事项:如果传入的参数为空,返回

    2024年02月05日
    浏览(39)
  • 好看的css样式:可以直接复制给备忘录用的

    好看的CSS样式 好看的按钮样式  好看的复选框样式 图片背景样式 颜色渐变背景样式 备忘录最初的样式 布局容器css画布背景样式

    2024年01月25日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包