数组,math类

数组

案例一:

  • java.util.Arrays是一个数组相关的工具类,里面提供了大量静态方法,用来实现数组常见的操作
  • public static String tostring(数组)将参数转换为字符串,
  • publicstatic void sort(数组) 按照数组升序排序

备注

  1. 如果是数值,sort默认按照升序排序。
  2. 如果是字母,按照字母升序
  3. 如果是自定义类型,那么这个自定义类型需要有compareable或者comparator接口支持
package com.company.数组;

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

public class demo2 {
    public static void main(String[] args) {
        int[] intArray=new int[]{10,20,30};
//        String intStr=intArray.toString();
        String intStr= Arrays.toString(intArray);
        System.out.println(intStr);
        Arrays.sort(intArray);
        System.out.println(intArray);
        String[] strArray=new String[]{"aaa","bbb","ccc"};
        System.out.println("排序前");
        for(int i=0;i<=strArray.length-1;i++){
            System.out.println(strArray[i]);
        }
        Arrays.sort(strArray, Comparator.reverseOrder());
        System.out.println("排序后");
        for (int i=0;i<=strArray.length-1;i++){
            System.out.println(strArray[i]);
        }
    }
}

运行结果

math类

案例一:获取绝对值,向上取整,向下取整,抹零

package com.company.math类;

public class demo1 {
    public static void main(String[] args) {
        //求绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(0));
        System.out.println(Math.abs(-3.14));

        //向上取整
        System.out.println(Math.ceil(4.0));
        System.out.println(Math.ceil(3.1));
        System.out.println(Math.ceil(3.9));
        System.out.println("=============");

        //向下取整,抹零
        System.out.println(Math.floor(30.1));
        System.out.println(Math.floor(30.9));
        System.out.println(Math.floor(30.0));

        System.out.println(Math.round(20.6));
        System.out.println(Math.round(20.1));
    }
}

运行结果

案例二:计算-10.8到5.9之间绝对值大于六或者小于2.1的整数有多少个

package com.company.math类;

import com.sun.org.apache.bcel.internal.generic.ATHROW;

public class demo2 {
    public static void main(String[] args) {
        //计算-10.9到5.9之间绝对值大于六或者小于2.1的整数有多少个
        double start=-10.8;
        int count=0;
        while (start<5.9){
            if(Math.abs(start)>6 || Math.abs(start)<2.1){
                System.out.println(Math.abs(start));
                count++;
                System.out.println(start);
                start+=0.1;
            }
            else{
                start+=0.1;
            }
        }
    }
}

运行结果

### Java生成指定范围内的随机数并排序 #### 数组和`Math.random()`生成随机数 可以通过`Math.random()`函数生成介于 `[0, 1)` 的浮点数,再将其映射到所需范围内。以下是具体实现方式: ```java public class RandomArray { public static void main(String[] args) { int min = 127; int max = 521; int size = 10; // 创建数组存储随机数 int[] array = new int[size]; // 填充数组 for (int i = 0; i < size; i++) { array[i] = (int)(min + Math.random() * (max - min + 1)); } System.out.println("原始数组:"); printArray(array); } private static void printArray(int[] array) { for (int num : array) { System.out.print(num + " "); } System.out.println(); } } ``` 此代码片段利用 `Math.random()` 函数生成了范围在 `[127, 521]` 内的 10 个随机整数[^1]。 --- #### 排序算法实现升序/降序排列 ##### 计数排序(Counting Sort) 计数排序适用于一定范围内的整数排序。由于题目中指定了数值范围为 `[127, 521]`,因此可以采用该算法。下面是其实现: ```java public static void countingSort(int[] array, boolean ascending) { int offset = 127; // 最小值偏移量 int range = 521 - 127 + 1; // 数据范围大小 // 初始化计数数组 int[] count = new int[range]; // 统计频率 for (int num : array) { count[num - offset]++; } // 根据顺序重新填充原数组 int index = 0; if (ascending) { // 升序 for (int i = 0; i < range; i++) { while (count[i]-- > 0) { array[index++] = i + offset; } } } else { // 降序 for (int i = range - 1; i >= 0; i--) { while (count[i]-- > 0) { array[index++] = i + offset; } } } } // 测试部分 System.out.println("计数排序后的数组(升序):"); countingSort(array.clone(), true); printArray(array); System.out.println("计数排序后的数组(降序):"); countingSort(array.clone(), false); printArray(array); ``` 此处实现了基于计数排序的升序与降序排列功能[^2]。 --- ##### 快速排序(Quick Sort) 快速排序是一种高效的比较排序算法,适合处理任意型的可比较数据。下面是一个简单的实现: ```java public static void quickSort(int[] array, int low, int high, boolean ascending) { if (low < high) { int pi = partition(array, low, high, ascending); quickSort(array, low, pi - 1, ascending); quickSort(array, pi + 1, high, ascending); } } private static int partition(int[] array, int low, int high, boolean ascending) { int pivot = array[high]; int i = low - 1; for (int j = low; j < high; j++) { if ((array[j] <= pivot && ascending) || (array[j] >= pivot && !ascending)) { i++; swap(array, i, j); } } swap(array, i + 1, high); return i + 1; } private static void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } // 测试部分 System.out.println("快速排序后的数组(升序):"); quickSort(array.clone(), 0, array.length - 1, true); printArray(array); System.out.println("快速排序后的数组(降序):"); quickSort(array.clone(), 0, array.length - 1, false); printArray(array); ``` 这段代码展示了如何通过调整分区逻辑来支持升序或降序排序[^1]。 --- #### 输出示例 假设生成的随机数组如下: ``` 原始数组: 345 189 456 234 127 521 345 456 234 189 ``` 执行以上两种排序方法后可能得到的结果分别为: - **计数排序** ``` 计数排序后的数组(升序): 127 189 189 234 234 345 345 456 456 521 计数排序后的数组(降序): 521 456 456 345 345 234 234 189 189 127 ``` - **快速排序** ``` 快速排序后的数组(升序): 127 189 189 234 234 345 345 456 456 521 快速排序后的数组(降序): 521 456 456 345 345 234 234 189 189 127 ``` --- ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值