算法—数组平移

问题描述：给定一个数组，对其扩容后得到一个新数组，将和原数组中对应的元素往后平移给定的偏移量对应的位数，若平移后会越界，则至多平移至新数组的末尾。

1.给定数组（原数组）

int[] ints = { 1, 2, 3, 4 };

2.平移至末尾操作

System.out.println("=======扩容为原数组的3倍后，平移至末尾=======");
		int[] translate = translateToEnd(ints, ints.length*3);
		for(int e:translate) {
			System.out.print(e);
		}

3.平移至指定偏移量操作，若平移指定偏移量后会越界，则只平移至末尾

System.out.println("========扩容为7后，平移偏移量为2=======");
		int[] offset = traslateByOffset(ints, 2, 7);
		for(int e:offset) {
			System.out.print(e);
		}
System.out.println("========扩容为7后，平移偏移量为4，会越界，所以只平移至末尾=======");
		int[] offset2 = traslateByOffset(ints, 4, 7);
		for(int e:offset2) {
			System.out.print(e);
		}

演示结果

=======扩容为原数组的3倍后，平移至末尾=======
000000001234
========扩容为7后，平移偏移量为2=======
0012340
========扩容为7后，平移偏移量为4，会越界，所以只平移至末尾=======
0001234

完整源码

package compute;

import java.util.Arrays;

/**
 *数组平移
 *@create by gzx on 2022-1-29
 */
public class ArrayTranslation {
	public static void main(String[] args) {
		int[] ints = { 1, 2, 3, 4 };
		System.out.println("=======扩容为原数组的3倍后，平移至末尾=======");
		int[] translate = translateToEnd(ints, ints.length*3);
		for(int e:translate) {
			System.out.print(e);
		}
		System.out.println();
		System.out.println("========扩容为7后，平移偏移量为2=======");
		int[] offset = traslateByOffset(ints, 2, 7);
		for(int e:offset) {
			System.out.print(e);
		}
		System.out.println();
		System.out.println("========扩容为7后，平移偏移量为4，会越界，所以只平移至末尾=======");
		int[] offset2 = traslateByOffset(ints, 4, 7);
		for(int e:offset2) {
			System.out.print(e);
		}
	}
	/**
	 *平移至末尾
	 * @param original 原数组
	 * @param newArrayLength 扩容后的新数组长度
	 * @return 平移后的新数组
	 */
	public static int[] translateToEnd(int[] original,int newArrayLength) {
		int[] temp=Arrays.copyOf(original, newArrayLength);
		//将旧数组的原有元素平移至新数组的末尾
		for (int k = 0; k < original.length; k++) {
			temp[newArrayLength + k - original.length] = original[k];
		}
		//新数组的其它部分赋值为 0
		for(int p=0;p<(newArrayLength-original.length);p++) {
			temp[p]=0;
		}
		return temp;
	}
	/**
	 * 平移偏移量对应的位数，至多平移至末尾
	 * @param original 原数组
	 * @param offset 平移偏移量
	 * @param newArrayLength 新数组的长度
	 * @return 平移后的数组
	 */
	public static int[] traslateByOffset(int[] original,int offset,int newArrayLength) {
		int[] temp;
		//如果平移后会越界,则只移动到末尾
		if (offset>(newArrayLength-offset)) {
			temp=translateToEnd(original, newArrayLength);
		}else {
			//平移指定偏移量
			temp=Arrays.copyOf(original, newArrayLength);
			for(int k=0;k<original.length;k++) {
				temp[offset+k]=original[k];
			}
			//其它部分赋值 0
			for(int p=0;p<newArrayLength;p++) {
				if (p<offset||p>(offset+original.length)) {
					temp[p]=0;
				}
			}
		}
		return temp;
	}
}

平移至末尾的操作在jdk的System类中有个与数组扩容复制有关的一个方法，叫做arraycopy，但是这是一个本地方法，在java.util.Arrays类中的copyOf方法调用了这个本地方法。
以下是这两个方法的源码。
System的arraycopy

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

以下这个方法有很多重载方法，只列举一个
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;
    }

温馨提示：如读完此篇博客感觉有收获，不妨再看看我的其它博客，皆为原创，且都是自己思考的产物。如有不足之处，也敬请批评指正。