JavaSE学习记录-整数逆序+数组删除元素

数组定义方法

int[] arr = new int[10];

定义同时进行赋值：

int[] arr = new int[]{1,2,3,4,5};

数组打印方法 

1.for循环打印

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

2.foreach打印

for(int value:arr){
    System.out.print(value);
}

3.Arrays自带函数打印

System.out.print(Arrays.toString(arr));

示例：

    int[] arr = new int[10];
    Arrays.fill(arr,2,6,1);
    System.out.print(Arrays.toString(arr));

 

 数组填充

Arrays自带fill方法进行填充，可以往数组中用指定值根据指定指标进行填充。

    public static void fill(int[] a, int fromIndex, int toIndex, int val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }

 

实例练习

任务一：获取整数位数，并逆序打印输出，包含正负整数情况。

任务二：手动录入数组大小及元素，输入删除位置，对指定位置元素进行删除，并进行数组缩容。 

import java.util.*;
/**
 * Created on 2020/9/6.
 *
 * @author：resumebb
 * @Description:
 */
public class Reverse {
    //获取位数函数
    public static int getLength(int num){
        int count = 0;

        while(num!=0){
            num/=10;
            count++;
        }
        return count;
    }

    //逆序打印函数
    public static int reversePrint(int num,int count){
        System.out.println("原数:"+num);
        System.out.print("逆序输出:");
        //负数情况
        if(num<0){
            System.out.print(num % 10);
            num/=10;
            for(int i=1;i<count;i++) {
                System.out.print(Math.abs(num % 10));
                num/=10;
            }
            return 1;
        }
        //正数含0情况
        else {
            for (int i = 0; i < count; i++) {
                System.out.print(num % 10);
                num /= 10;
            }
            return 1;
        }


    }

    //删除指定位置元素，进行缩容
    public static int[] delElement(int[] arr,int delPos){
        int len = arr.length;
        //删除操作
        for(int i=delPos;i<len;i++){
            arr[i]=arr[++i];
        }
         //数组缩容
        arr = Arrays.copyOf(arr, arr.length-1);
        return arr;
    }

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        //获取位数+逆序输出
//        int num = in.nextInt();
//        int len = getLength(num);
//        System.out.println("位数:"+len);
//        reversePrint(num,len);

        //删除数组元素
        int delPos =0;
        System.out.println("数组大小:");
        int arrLen = in.nextInt();
        int[] arr = new int[arrLen];
        int length = arr.length;
        int[] newArr = new int[arrLen-1];

        for (int i=0;i<arrLen;i++){
            arr[i]=in.nextInt();
        }

        //删除指定位置元素
        System.out.println("原数组："+Arrays.toString(arr)+" 数组大小："+arr.length);
        System.out.println("输入删除位置:");
        delPos = in.nextInt();
        if(delPos<0||delPos>length){
            System.out.print("删除位置错误,重新输入");
        }else{
            arr=delElement(arr,delPos);
            System.out.println("删除后："+Arrays.toString(arr)+" 数组大小："+arr.length);
        }

        in.close();
    }
}

 

 

对于其中Arrays的copyOf数组复制函数，源码如下：

  public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

 通过System调用copyOf函数，两个形参，一个原始数组，一个要扩容或缩容的数组新的长度，根据新长度定义一个新数组，利用System调用arraycopy函数进行复制，在长度选择方面利用min函数取原数组长度和新数组长度之间较小值，若是新长度大，原长度小，它就只能复制原数组那么多元素，反之复制新长度那么多元素即可，所以其实主要还是arraycopy起作用，copyOf仅是调用arraycopy封装的一个简易函数，应用范围较小。

对于arraycopy函数，源码中如下定义：

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

五个参数，src为Object类型的原始数组，srcPos为copy的起始位置，如0,1，dest为Object类型的复制目标数组，destPos为目标数组准备复制的起始位置，length为复制原数组的长度，大小应该在0到src.length之间。

二者的区别在于Arrays的copy函数其实是System的copy函数的一个封装调用，它会在调用的同时创建一个新数组，而System的copy函数只是复制一个数组。