Java全栈（二）JavaSE：18.常用类之System类、Math类、数组相关操作

最新推荐文章于 2023-08-18 09:58:35 发布
最新推荐文章于 2023-08-18 09:58:35 发布
阅读量142 收藏
点赞数
分类专栏： JAVA系统学习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ouyicnm/article/details/121130123
版权

1. 系统类

System系统类 : 定义在java.lang包中

定义了大量常用的字段(成员变量)和方法,该类不能实例化对象,不能new,类中的成员全部是静态修饰,类名直接调用.

全部静态成员,无需对象创建,类名调用. 构造方法private修饰

1.1 System类的方法

  • static long currentTimeMillis() 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 , 1000毫秒=1秒

    /**
* static long currentTimeMillis()
* 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 ,
* 1000毫秒=1秒
*/
public static void systemCurrentTimeMillis(){
    long timeMillis = System.currentTimeMillis();
    System.out.println("timeMillis = " + timeMillis); 
}

  • static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )复制数组的元素到另一个数组

    • src : 要赋值的数据源,源数组
    • srcPos : 源数组的开始索引
    • dest : 要复制的目标数组
    • destPos : 目标数组的开始索引
    • length : 要复制的元素个数
    public static void systemArraycopy(){
        int[] src = {1,3,5,7,9};
        int[] dest = {2,4,6,8,0};
        //数组元素的赋值 : src数组中的3,5 复制到dest数组中0索引开始
        System.arraycopy(src,1,dest,0,2);
        for(int x = 0 ;  x < src.length ;x++ ){
            System.out.println(dest[x]); // {3,5,6,8,0}
        }
    }
  • static Properties getProperties() 返回当前的操作系统属性
    /**
     *  static Properties getProperties() 返回当前的操作系统属性
     *  System.getProperty(String 键名)
     */
    public static void systemGetProperties(){
        Properties properties = System.getProperties();
        System.out.println(properties);
        String str = System.getProperty("os.name");
        System.out.println(str);
    }

  • static void exit(int status) ：退出当前系统

  • static void gc() ：运行垃圾回收器。

1.2 java.lang.Runtime类

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。

public static Runtime getRuntime()： 返回与当前 Java 应用程序相关的运行时对象。

public long totalMemory()：返回 Java 虚拟机中的内存总量。此方法返回的值可能随时间的推移而变化，这取决于主机环境。

public long freeMemory()：回 Java 虚拟机中的空闲内存量。调用 gc 方法可能导致 freeMemory 返回值的增加。

2.数学类

2.1 java.lang.Math

  • Math类构造器私有，所有方法都是静态方法

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

  • public static double abs(double a) ：返回 double 值的绝对值。
double d1 = Math.abs(-5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5
  • public static double ceil(double a) ：返回大于等于参数的最小的整数。向上取整
double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(-3.3); //d2的值为 -3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0
  • public static double floor(double a) ：返回小于等于参数最大的整数。向下取整
double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(-3.3); //d2的值为-4.0
double d3 = Math.floor(5.1); //d3的值为 5.0
  • public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0
  • public static double pow(double a,double b)：返回a的b幂次方法
  • public static double sqrt(double a)：返回a的平方根
  • public static double random()：返回[0,1)的随机值。
    // 取[m,n]的整数
(int)Math.random()*(n-m+1)+m
  • public static final double PI：返回圆周率
  • public static double max(double x, double y)：返回x,y中的最大值
  • public static double min(double x, double y)：返回x,y中的最小值
double result = Math.pow(2,31);
double sqrt = Math.sqrt(256);
double rand = Math.random();
double pi = Math.PI;
练习

请使用Math 相关的API，计算在 -10.8 到5.9 之间，绝对值大于6 或者小于2.1 的整数有多少个？

public class MathTest {
  public static void main(String[] args) {
    // 定义最小值
    double min = -10.8;
    // 定义最大值
    double max = 5.9;
    // 定义变量计数
    int count = 0;
    // 范围内循环
    for (double i = Math.ceil(min); i <= max; i++) {
      // 获取绝对值并判断
      if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
        // 计数
        count++;
      }
    }
    System.out.println("个数为: " + count + " 个");
  }
}

2.2 java.math包

（1）BigInteger 大整数

  • Java中使用BigInteger 来储存超大的整数。往往当数值大于Long.MAX_VALUE时，就使用BigInteger 。

  • 不可变的任意精度的整数。

  • BigInteger(String val) // 构造方法，储存数字val

  • BigInteger add(BigInteger val) // 加。两个BigInteger对象，不能直接“+”

  • BigInteger subtract(BigInteger val) // 减

  • BigInteger multiply(BigInteger val) // 乘

  • BigInteger divide(BigInteger val) // 除

  • BigInteger remainder(BigInteger val) // 求余

  • …

	@Test
	public void test01(){
//		long bigNum = 123456789123456789123456789L;
		
		BigInteger b1 = new BigInteger("123456789123456789123456789");
		BigInteger b2 = new BigInteger("78923456789123456789123456789");
		
//		System.out.println("和：" + (b1+b2));//错误的，无法直接使用+进行求和
		
		System.out.println("和：" + b1.add(b2));
		System.out.println("减：" + b1.subtract(b2));
		System.out.println("乘：" + b1.multiply(b2));
		System.out.println("除：" + b2.divide(b1));
		System.out.println("余：" + b2.remainder(b1));
	}
（2）RoundingMode枚举类

CEILING ：向正无限大方向舍入的舍入模式。
DOWN ：向零方向舍入的舍入模式。
FLOOR：向负无限大方向舍入的舍入模式。
HALF_DOWN ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。
HALF_EVEN：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
HALF_UP：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。
UNNECESSARY：用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。
UP：远离零方向舍入的舍入模式。

（3）BigDecimal 精确小数

  • 用于储存切确的小数，例如银行业务

  • 不可变的、任意精度的有符号十进制数。

  • BigDecimal(String val) // 构造方法

  • BigDecimal add(BigDecimal val) // 加

  • BigDecimal subtract(BigDecimal val) // 减

  • BigDecimal multiply(BigDecimal val) // 乘

  • BigDecimal divide(BigDecimal val) // 除

  • BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode) //除。RoundingMode roundingMode：计算舍入模式

  • BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) //除。int scale：需要保留的小数位数； RoundingMode roundingMode：计算策略

  • 如果除法计算的结果是无限小数，必须使用舍入模式

  • BigDecimal remainder(BigDecimal val)

  • …

	@Test
	public void test02(){
		/*double big = 12.123456789123456789123456789;
		System.out.println("big = " + big);*/
		
		BigDecimal b1 = new BigDecimal("123.45678912345678912345678912345678");
		BigDecimal b2 = new BigDecimal("7.8923456789123456789123456789998898888");
		
//		System.out.println("和：" + (b1+b2));//错误的，无法直接使用+进行求和
		
		System.out.println("和：" + b1.add(b2));
		System.out.println("减：" + b1.subtract(b2));
		System.out.println("乘：" + b1.multiply(b2));
		System.out.println("除：" + b1.divide(b2,20,RoundingMode.UP));//divide(BigDecimal divisor, int scale, int roundingMode)
		System.out.println("除：" + b1.divide(b2,20,RoundingMode.DOWN));//divide(BigDecimal divisor, int scale, int roundingMode)
		System.out.println("余：" + b1.remainder(b2));
	}

2.3 java.util.Random

用于产生随机数

  • boolean nextBoolean():返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。true 或者 false

  • void nextBytes(byte[] bytes):生成随机字节并将其置于用户提供的 byte 数组中。

  • double nextDouble():返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。

  • float nextFloat():返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。

  • double nextGaussian():返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。

  • int nextInt():返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。 产生int范围内的随机数

  • int nextInt(int n):返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

  • long nextLong():返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

	@Test
	public void test03(){
		Random r = new Random();
		System.out.println("随机整数：" + r.nextInt());
		System.out.println("随机小数：" + r.nextDouble());
		System.out.println("随机布尔值：" + r.nextBoolean());
	}

3. 数组的相关操作

3.1 数组的算法升华

1、数组的反转

方法有两种：

1、借助一个新数组

2、首尾对应位置交换

第一种方式示例代码：

在这里插入图片描述

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)先创建一个新数组
int[] newArr = new int[arr.length];

//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
    newArr[i] = arr[len -1 - i];
}

//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

缺点：需要借助一个数组，浪费额外空间，原数组需要垃圾回收

第二种方式示例代码：

**实现思想：**数组对称位置的元素互换。

在这里插入图片描述

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)计算要交换的次数：  次数 = arr.length/2
//(2)首尾对称位置交换
for(int i=0; i<arr.length/2; i++){//循环的次数就是交换的次数
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//（3）遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

或

在这里插入图片描述

	public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9};

		//左右对称位置交换
		for(int left=0,right=arr.length-1; left<right; left++,right--){
		    //首  与  尾交换
		    int temp = arr[left];
		    arr[left] = arr[right];
			arr[right] = temp;
		}

		//（3）遍历显示
		for(int i=0; i<arr.length; i++){
		    System.out.println(arr[i]);
		}
	}
2、数组的扩容

示例：当原来的数组长度不够了需要扩容，例如需要新增位置来存储10

int[] arr = {1,2,3,4,5,6,7,8,9};

//如果要把arr数组扩容，增加1个位置
//(1)先创建一个新数组，它的长度 = 旧数组的长度+1，或者也可以扩大为原来数组长度的1.5倍，2倍等
int[] newArr = new int[arr.length + 1];

//(2)复制元素
//注意：i<arr.length   因位arr比newArr短，避免下标越界
for(int i=0; i<arr.length; i++){
    newArr[i] = arr[i];
}

//(3)把新元素添加到newArr的最后
newArr[newArr.length-1] = 10;

//(4)如果下面继续使用arr，可以让arr指向新数组
arr = newArr;

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

（1）至于新数组的长度定义多少合适，看实际情况，如果新增的元素个数确定，那么可以增加指定长度，如果新增元素个数不确定，那么可以扩容为原来的1.5倍、2倍等

（2）数组扩容太多会造成浪费，太少会导致频繁扩容，效率低下

3、数组元素的插入

示例：在原数组的某个[index]插入一个元素

情形一：原数组未满

String[] arr = new String[5];
arr[0]="张三";
arr[1]="李四";
arr[2]="王五";

那么目前数组的长度是5，而数组的实际元素个数是3，如果此时需要在“张三”和“李四”之间插入一个“赵六”，即在[index=1]的位置插入“赵六”，需要怎么做呢？

String[] arr = new String[5];
arr[0]="张三";
arr[1]="李四";
arr[2]="王五";

//（1）移动2个元素，需要移动的起始元素下标是[1]，它需要移动到[2]，一共一共2个
System.arraycopy(arr,1,arr,2,2);
//（2）插入新元素
arr[1]="赵六";

//(3)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

情形二：原数组已满

String[] arr = new String[3];
arr[0]="张三";
arr[1]="李四";
arr[2]="王五";

那么目前数组的长度是3，而数组的实际元素个数是3，如果此时需要在“张三”和“李四”之间插入一个“赵六”，即在[index=1]的位置插入“赵六”，需要怎么做呢？

String[] arr = new String[3];
arr[0]="张三";
arr[1]="李四";
arr[2]="王五";

//（1）先扩容
String[] newArr = new String[4];
for(int i=0; i<arr.length; i++){
	newArr[i] = arr[i];
}
arr=newArr;

//（2）移动2个元素，需要移动的起始元素下标是[1]，它需要移动到[2]，一共一共2个
System.arraycopy(arr,1,arr,2,2);
//（3）插入新元素
arr[1]="赵六";

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}
4、数组元素的删除

示例：

String[] arr = new String[3];
arr[0]="张三";
arr[1]="李四";
arr[2]="王五";

现在需要删除“李四”，我们又不希望数组中间空着元素，该如何处理呢？

String[] arr = new String[3];
arr[0]="张三";
arr[1]="李四";
arr[2]="王五";

//（1）移动元素，需要移动元素的起始下标[2]，该元素需要移动到[1]，一共需要移动1个元素
System.arraycopy(arr,2,arr,1,1);

//（2）因为数组元素整体往左移动，这里本质上是复制，原来最后一个元素需要置空
arr[2]=null;//使得垃圾回收尽快回收对应对象的内存
5、数组的二分查找

二分查找：对折对折再对折

要求：要求数组元素必须支持比较大小，并且数组中的元素已经按大小排好序

示例：

class Exam2{
	public static void main(String[] args){
		int[] arr = {2,5,7,8,10,15,18,20,22,25,28};//数组是有序的
		int value = 18;
		
        int index = -1;
		int left = 0;
        int right = arr.length - 1;
        int mid = (left + right)/2;
        while(left<=right){
            //找到结束
            if(value == arr[mid]){
                index = mid;
                break;
            }//没找到
            else if(value > arr[mid]){//往右继续查找
                //移动左边界，使得mid往右移动
                left = mid + 1;
            }else if(value < arr[mid]){//往左边继续查找
                right = mid - 1;
            }
            
            mid = (left + right)/2;
        }
        
        if(index==-1){
    		System.out.println(value + "不存在");
		}else{
    		System.out.println(value + "的下标是" + index);
		}
        
	}
}

在这里插入图片描述
在这里插入图片描述

6、数组的直接选择排序

示例代码：简单的直接选择排序

int[] arr = {49,38,65,97,76,13,27,49};

for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
    //（1）找出本轮未排序元素中的最值
    /*
    未排序元素：
    第1轮：i=1,未排序，[0,7]，本轮未排序元素第一个元素是[0]
    第2轮：i=2,未排序，[1,7]，本轮未排序元素第一个元素是[1]
    ...
    第7轮：i=7,未排序，[6,7]，本轮未排序元素第一个元素是[6]
    
    每一轮未排序元素的起始下标：0,1,2,3,4,5,6，正好是i-1的
    未排序的后面的元素依次：
    第1轮：[1,7]  j=1,2,3,4,5,6,7
    第2轮：[2,4]  j=2,3,4,5,6,7
    。。。。
    第7轮：[7]    j=7
    j的起点是i，终点都是7
    */
    int max = arr[i-1];
    int index = i-1;
    for(int j=i; j<arr.length; j++){
        if(arr[j] > max){
            max = arr[j];
            index = j;
        }
    }
    
    //（2）如果这个最值没有在它应该在的位置，就与这个位置的元素交换
    /*
    第1轮，最大值应该在[0]
    第2轮，最大值应该在[1]
    ....
    第7轮，最大值应该在[6]
    正好是i-1的值
    */
    if(index != i-1){
        //交换arr[i-1]与arr[index]
        int temp = arr[i-1];
        arr[i-1] = arr[index];
        arr[index] = temp;
    }
}

//显示结果
for(int i=0; i<arr.length; i++){
	System.out.print(arr[i]);
}

在这里插入图片描述

3.2 数组工具类

java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]类型的，其他类型的数组类推：

  • static int binarySearch(int[] a, int key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数。本质是二分查找

  • static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组

  • static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组

  • static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同

  • static void fill(int[] a, int val) ：用val填充整个a数组

  • static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val

  • static void sort(int[] a) ：将a数组按照从小到大进行排序。注意：数组内是基本数据类型除布尔外，都可以直接使用。而自定义类型对象需要重写比较的方法。如实现Comparator接口

  • static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列

  • static String toString(int[] a) ：把a数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3。。。]

  • static String deepToString(int[][] a)：把a二维数组的元素，拼接为一个字符串。

示例代码：

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

public class Test{
    public static void main(String[] args){
    	int[] arr = new int[5];
        // 打印数组,输出地址值
  		System.out.println(arr); // [I@2ac1fdc4
  		// 数组内容转为字符串
    	System.out.println("arr数组初始状态："+ Arrays.toString(arr));
    	
    	Arrays.fill(arr, 3);
    	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
    	
    	Random rand = new Random();
    	for (int i = 0; i < arr.length; i++) {
			arr[i] = rand.nextInt(100);//赋值为100以内的随机整数
		}
    	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
    	
    	int[] arr2 = Arrays.copyOf(arr, 10);
    	System.out.println("新数组：" + Arrays.toString(arr2));
    	
    	System.out.println("两个数组的比较结果：" + Arrays.equals(arr, arr2));
    	
    	Arrays.sort(arr);
    	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
    }
}

自定义对象数组的排序：

package com.oy.常用类.MyArrays;

import java.util.Arrays;

class Demo1 {
    public static void main(String[] args) {
        Person[] persons = {
                new Person("张三", 20),
                new Person("李四", 35),
                new Person("王五", 26)
        };
        Arrays.sort(persons); //Arrays.sort()方法会自动根据你自定义的compareTo方法实现排序
        System.out.println(Arrays.toString(persons));// [{name:张三,age:20}, {name:王五,age:26}, {name:李四,age:35}]
    }
}

// 自定义类，并实现Comparable接口
class Person implements Comparable{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Object o) {
        return this.age - ((Person) o).age;
    }

    @Override
    public String toString() {
        return "{name:"+name+",age:"+age+"}";
    }
}

package com.oy.常用类.MyArrays;

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

class Demo1 {
    public static void main(String[] args) {
        Person[] persons = {
                new Person("张三", 20),
                new Person("李四", 35),
                new Person("王五", 26)
        };
        PersonComparator personComparator = new PersonComparator();
        Arrays.sort(persons,personComparator); //Arrays.sort()方法会自动根据你自定义的比较强personComparator实现排序
        System.out.println(Arrays.toString(persons));
    }
}

// 自定义类
class Person {
    private String name;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "{name:" + name + ",age:" + age + "}";
    }
}

// 自定义实现类，继承Comparator接口
class PersonComparator implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        return ((Person) o1).getAge() - ((Person) o2).getAge();
    }
}

3.3 数组面试题

1、编程题1

找出数组中一个值，使其左侧值的加和等于右侧值的加和，

​ 例如：[1,2,5,3,2,4,2]，结果为：第4个值3

​ [9, 6, 8, 8, 7, 6, 9, 5, 2, 5]，结果是没有

	public static void main(String[] args) {
		int[] arr = {1,2,5,3,2,4,2};
			
		int index = leftSumEqualsRightSum(arr);
		if(index!=-1) {
			System.out.println(arr[index]);
		}else {
			System.out.println("没有");
		}
	}
	
	public static int leftSumEqualsRightSum(int[] arr) {
		for (int mid = 0; mid < arr.length; mid++) {
			int leftSum = 0;
			int rightSum = 0;
			for (int i = 0; i <mid; i++) {
				leftSum += arr[i];
			}
			for (int i = mid+1; i < arr.length; i++) {
				rightSum += arr[i];
			}
			if(leftSum==rightSum) {
				return mid;
			}
		}
		return -1;
	}
2、编程题2

  • 左奇右偶

    • 10个整数的数组{26,67,49,38,52,66,7,71,56,87}。
    • 元素重新排列，所有的奇数保存到数组左边，所有的偶数保存到数组右边。

  • 代码实现，效果如图所示：
    在这里插入图片描述

  • 开发提示：

    • 左边的偶数与右边的奇数换位置：
    • 定义两个变量left和right，从左边开始查找偶数的位置，找到后用left记录，从右边开始找奇数的位置，找到后用right记录，如果left<right，那么就交换，然后在上一次的基础上继续查找，直到left与right擦肩。
    //效率最高
    public void order2(int[] arr){
        for (int left = 0,right = arr.length-1; left < right; ){
            //left代表左边需要交换的数的下标，偶数的下标
            //如果arr[left]此时是奇数，说明此时left不是我们要找的下标，left++往后移动
            while(arr[left]%2!=0){//当arr[left]是偶数时，结束while循环
                left++;
            }
            //如果arr[right]此时是偶数，说明此时right不是我们要找的下标，right--往前移动
            while(arr[right]%2==0){//当arr[right]是奇数时，结束while循环
                right--;
            }
            if(left < right){
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right]= temp;
            }
        }
    }

public void order3(int[] arr){
        int len = arr.length;
        while (len>0) {
            for (int j=0; j<len-1; j++){
                //左边的元素是偶数，就和它相邻的元素交换
                if (arr[j]%2==0) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            len--;
        }
    }

public void order(int[] arr){
        //从左边往右边找偶数，记录下标，evenIndex，这个是错误的数字的下标
        //从右边往左边找奇数，记录下标，oddIndex，这个是错误的数字的下标
        //交换arr[oddIndex]与arr[evenIndex]，调整之后就可以了
        int evenIndex = 0;
        int oddIndex = arr.length-1;
        while(evenIndex < oddIndex){
            for (int i=0; i<arr.length; i++){
                if(arr[i]%2==0){
                    evenIndex = i;
                    break;
                }
            }

            for(int i=arr.length-1; i>=0; i--){
                if(arr[i]%2!=0){
                    oddIndex = i;
                    break;
                }
            }

            if(evenIndex < oddIndex) {
                int temp = arr[evenIndex];
                arr[evenIndex] = arr[oddIndex];
                arr[oddIndex] = temp;
            }
        }
    }
3、编程题3

  • 数组去重

    • 10个整数{9,10,6,6,1,9,3,5,6,4}，范围1-10，保存到数组中。
    • 去除数组中重复的内容，只保留唯一的元素。

  • 按步骤编写代码，效果如图所示：

在这里插入图片描述

  • 开发提示：

    • 定义一个变量count，初始化为数组的长度
    • 遍历每一个元素，如果该元素与前面的某个元素相等，那么通过移动数组，把该元素覆盖掉，并修改count–。
    • 最后创建一个新数组，长度为count，并从原数组把前count个元素复制过来
4、编程题4

在这里插入图片描述

import java.util.Arrays;

public class TestExer4 {
	public static void main(String[] args) {
		
		double[] arr = new double[10];
		for (int i = 0; i < arr.length-1; i++) {
			arr[i] = Math.random() * 100;//[0,100)之间的小数
		}
		arr[arr.length-1] = 0;
		System.out.println("直线上每一个点距离下一个点的距离："+Arrays.toString(arr));
		
		double length = 150.5;
		
		int count = 0;
		double sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
			if(sum<=length) {
				count++;
			}else {
				break;
			}
		}
		System.out.println("长度为：" + length + "的绳子最多能覆盖" +count+"个点");
	}
}
5、编程题5

在这里插入图片描述

冒泡排序：

public static void bubbleSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = 0; j < arr.length-i; j++) {
				if(arr[j] > arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}

直接选择排序：

public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			int minIndex = i;
			for (int j = i+1; j < arr.length; j++) {
				if(arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			if(minIndex!=i) {
				int temp = arr[minIndex];
				arr[minIndex] = arr[i];
				arr[i] = temp;
			}
		}
	}

3.4 附加（有能力同学）

1、折半插入排序

例如：数组{12,2,6,1,5}

第一次：在[0,1)之间找插入2的位置==>left = [0] ==> {2,12,6,1,5}

第二次：在[0,2)之间找插入6的位置==>left = [1] ==> {2,6,12,1,5}

第三次：在[0,3)之间找插入1的位置==>left = [0] ==>{1,2,6,12,5}

第四次：在[0,4)之间找插入5的位置==>left = [2] ==>{1,2,5,6,12}

    @Test
    public void test(){
        int[] arr = {12,2,6,1,5};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public void sort(int[] arr){
        for (int i=1; i<arr.length; i++){
            //找到[0,i)之间插入arr[i]的位置
            //使用二分查找法
            int left = 0;
            int right=i-1;
            while (left<=right){
                int mid = (left + right)/2;
                if(arr[i]<=arr[mid]){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }
 
            //在[0,i)插入arr[i]
            if(left < i){
                int temp = arr[i];
                System.arraycopy(arr,left,arr,left+1,i-left);
                arr[left] = temp;
            }
        }
    }

在这里插入图片描述
在这里插入图片描述

2、快速排序

例如：数组{5, 2, 6, 12, 1,7,9}

    @Test
    public void test(){
        int[] arr = {5, 2, 6, 12, 1,7,9};
        sort(arr,0, arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    //将[start+1,end]之间的元素分为两拨，左边的所有元素比arr[start]小，右边的所有元素比arr[start]大
    public void sort(int[] arr,int start, int end){
        if(start < end){
            int left = start+1;
            int right = end;
            while(left<right){
                //从左往右，从[start+1]开始找比arr[start]大的数arr[left]，让它与arr[right]交换
                //当arr[left]大于arr[start]就停止循环，因为此时找到了比arr[start]大的数arr[left]
                while(arr[left]<=arr[start] && left<=end){
                    left++;
                }
                
                //从右往左，从[end]开始找比比arr[start]小的数arr[right]，让它与arr[left]交换
               //当arr[right]小于arr[start]就停止循环，因为此时找到了比arr[start]小的数arr[right]
                while(arr[right]>=arr[start] && right>start){
                    right--;
                }
                
                
                if(left < right){
                    int temp = arr[left];
                    arr[left] = arr[right];
                    arr[right] = temp;
                }
            }
            
            //经过上面的while，//如果right>start+1，那么说明在[start+1,end]之间的数分为两拨
            //[start+1,right]之间的是比arr[start]小的数
            //[right,end]之间的是比arr[start]大的数
            //交换arr[start]与arr[right]
            if(right > start + 1){
                int temp = arr[start];
                arr[start] = arr[right];
                arr[right] = temp;
            }
            //此时[start,right-1]之间都是比arr[start]小的数据了，但是它们还未排序
            //此时[right+1,end]之间都是比arr[start]大的数据了，但是它们还未排序
            //所以需要分别对[start,right-1]、[right+1,end]之间元素重复上面的操作继续排序
            sort(arr,start,right-1);
            sort(arr,right+1,end);
        }

    }

第1次调用sort(arr,0,6)
交换arr[left=2]与arr[right=4]：[5, 2, 1, 12, 6, 7, 9]
交换基准位置的元素与分界位置的元素：arr[start=0]与arr[right=2]：[1, 2, 5, 12, 6, 7, 9]
第2次调用sort(arr,0,1)
第3次调用sort(arr,0,0)
第4次调用sort(arr,2,1)
第5次调用sort(arr,3,6)
交换基准位置的元素与分界位置的元素：arr[start=3]与arr[right=6]：[1, 2, 5, 9, 6, 7, 12]
第6次调用sort(arr,3,5)
交换基准位置的元素与分界位置的元素：arr[start=3]与arr[right=5]：[1, 2, 5, 7, 6, 9, 12]
第7次调用sort(arr,3,4)
第8次调用sort(arr,3,3)
第9次调用sort(arr,5,4)
第10次调用sort(arr,6,5)
第11次调用sort(arr,7,6)

在这里插入图片描述

new nm个对象
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1、JavaSE：Java入门.pdf
12-13
Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、JavaSE：Java入门.pdf1、...
8、JavaSE：常用类.pdf
04-24
看B站视频项目总结的系列文档，仅供个人学习使用
01.06学习Java的day16【基础API与常见算法】
weixin_45506970的博客
03-06 224
day16【基础API与常见算法】 主要内容 常用类 基础算法 学习目标 了解数学相关API 了解日期时间API 了解系统类API 掌握数组基础算法 掌握数组工具类的使用 第十章 基础API与常见算法 10.1 和数学相关的类 10.1.1 java.lang.Math java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的...
JavaSE-18【线程】
最新发布
Allure泽宇的博客
08-18 138
线程的一般知识点
java 最小众倍数_最小众倍数
weixin_29514913的博客
03-07 186
21、找出三个整数的组合2、对每个组合求最小公倍数(先求两个数值的最小公倍数，再和第三个数值求最小公倍数)3、找到10种组合里边的最小值输出 #include#includeusing namespace std;int func(int a,int b){int temp1=a,temp2=b,temp=0;while(temp2>0){temp=temp1%temp2;temp1=tem...
常用API算法介绍
wbryze的博客
03-07 994
MathMath包含基本数字运算方法public static int abs(int a) 绝对值public static double ceil(double a) 向上取整public static double floor(double a) 向下取整public static int round(float a) 四舍五入public static int max(int a，int b) 返回最大值public static int min(int a，int b) 返回最小值public
JavaSE_18_Java反射机制
weixin_42788897的博客
06-14 62
重点Java反射相关概念；镜像对象获取；反射中字段、方法的设置及使用。难点Java反射相关概念；反射中字段、方法、构造的设置及使用。
5、JavaSE：数组.pdf
04-24
看B站视频项目总结的系列文档
4、JavaSE：方法.pdf
04-24
看B站视频项目总结的文档
JavaSE之数组与集合类
07-21
这个文件里的内容适合Java初学者，里边包含了JavaSE阶段用到的多个数组以及集合的用法和声明方式。这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE入门者学习，都是浅显易懂的话语，没有太...
机器学习算法API汇总
sangwz
06-09 878
sklearnAPI 1. K-近邻算法 1.读取数据 1.1sklearn.datasets datasets.load_* — 读取较小数据 datasets.fetch_* — 读取较大的数据 参数：subset = “ ”，train,test,all可选，选择要加载的数据集 返回值：datasets.base.Bunch(字典格式) data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组 target：标签数组，是 n...
Java之IO流学习笔记
weixin_43572399的博客
09-09 139
IO流 IO流的概念 IO就是Input和Output的简写，也就是输入和输出的含义。 IO流就是指读写数据时像流水一样从一端流到另外一端，因此得名为“流"。 基本分类 按照读写数据的基本单位不同，分为 字节流 和 字符流。 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。 其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。 按照读写数据的方向不同，分为 输入流 和 输出流（站在程序的角度）。 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文
JavaSE进阶（18~19）
大小曲奇的博客
01-17 323
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。动态：读到什么就创建什么，读到什么就运行什么Java反射机制利用反射可以无视修饰符获取类里面所有的属性和方法。先获取配置文件中的信息，动态获取信息并创建对象和调用方法XML的全称为(EXtensible Markup Language)，是一种可扩展的标记语言标记语言。
JavaSE18-面向对象-内部类
Joyechen1的博客
03-01 338
面向对象-内部类
Java SE 18 新增特性
Practitioner
08-22 336
在 Java SE 18 之前的 Java中，标准字符集会因操作系统和语言设置的不同而不同。Java 标准字符集决定了在 JDK 类库的许多方法中如何将字符串转换为字节，反之亦然（例如，在写入和读取文本文件时）。当一个应用程序在一个环境中被开发和测试，然后在另一个环境中运行（ Java 选择了不同的默认字符集），这可能导致不可预测的行为。方案一：在调用所有将字符串转换成字节的方法时指定字符集，反之亦然。其次，如上所述，指定的字符集并不用于所有的 API 方法。这个方案会导致大量的代码重复，容易出错。
JavaSE学习18（接口组成更新，方法引用）
weixin_44643735的博客
11-19 137
接口组成更新 1.1 接口组成更新概述 接口的组成 常量： public static final 可省略 抽象方法： public abstract 可省略 java8之后 加入了 默认方法： 静态方法： java9之后 加入了 私有方法： 1.2 接口中的默认方法 接口中默认方法的定义格式 public ...
JavaSE基础(18) 继承
逆轮回
04-08 1099
生活中我们经常听到一些名词，譬如富二代，官二代，红二代，穷二代，农二代等等，它代表中人与人之间的一种关系。那么程序当中怎么表示这种关系呢？概念：描述两个类的关系的。在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类(派生类，SubClass)，现有类被称作父类(超类，SuperClass)，子类会自动拥有父类所有非私有的属性和方法。
机器学习常见算法API小结
zerone
04-27 1530
https://www.cnblogs.com/maybe2030/p/4665816.html#_label6 收藏专用，具体点击网址
JAVASE18
cnjss的博客
04-16 738
JAVASE18 一、反射 程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言，如Python，Ruby是动态语言；显然C++，Java，C#不是动态语言，但是JAVA有着一个非常突出的动态相关机制：Reflection。 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个 对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java语言的反射机制，很多优秀的开源框架都是通过反射完成的。 发生在程序运行期间的行为
https://www.oracle.com/java/technologies/javase-downloads.html
06-28
这是Oracle官网上Java SE的下载页面，Java SE是Java平台的标准版本，它提供了Java程序开发和运行所需的核心功能和库。在该页面中，您可以下载Java SE的不同版本，包括JDK（Java Development Kit）、JRE（Java ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值