【Java】数组上

数组的应用

应用库函数

import java.util.Arrays;

1、写一个swap函数，实现一个数组中元素之间的交换

public class Course0718 {
	public static void swap(int[] a, int i, int j) {
		int t = a[i];
		a[i] = a[j];
		a[j] = t;
	}

//写主函数，定义一个数组a，之后调用swap函数进行元素交换
// 交换下标 0 和 下标 3 的数据
//输出数组a的值
注：a为一个数组，需要用 Arrays.toString 进行输出，直接输出会成为乱码
toString:
返回指定数组的内容的字符串表示形式。
字符串表示由数组元素的列表组成，括在方括号（ “[]” ）中。 相邻的元素由字符", "分隔（逗号后跟一个空格）。

public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5 };
		//System.out.println(a);
		System.out.println(Arrays.toString(a));
		swap(a, 0, 3);
		System.out.println(Arrays.toString(a));
		}

2、已知一个数字，要获取与之相对应的数组中元素的下标
// a.length 表示获取数组长度

public static int indexOf(int[] a, int v) {
		for (int i = 0; i < a.length; i++) {
			if (a[i] == v) {
				return i;
			}
		}
		
		return -1;
	}

//使用二分查找法（左闭右开）

public static int binarySearch(int[] a, int v) {
		int left = 0;
		int right = a.length;
		
		while (left < right) {
			int mid = (left + right) / 2;
			if (v == a[mid]) {
				return mid;
			} else if (v < a[mid]) {
				right = mid;
			} else {
				left = mid + 1;
			}
		}
		
		return -1;
	}

//使用二分查找法（左闭右闭）

public static int binarySearch2(int[] a, int v) {
		int left = 0;
		int right = a.length - 1;
		
		while (left <= right) {
			int mid = (left + right) / 2;
			if (v == a[mid]) {
				return mid;
			} else if (v < a[mid]) {
				right = mid - 1;
			} else {
				left = mid + 1;
			}
		}
		
		return -1;
	}

//分别调用函数，给定v=4，来查找其相对应的下标

public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5 };
		int t1=indexOf(a,4);
		int t2=binarySearch(a,4);
		int t3=binarySearch2(a,4);
		System.out.println(t1);
		System.out.println(t2);
		System.out.println(t3);
		}

3、填充函数
public static void fill(int[] a,int val)：
将指定的int值分配给指定的int数组的每个元素。

public static void fill(int[] a, int fromIndex, int toIndex,int val)：
将指定的int值分配给指定的int数组的指定范围的每个元素。 要填充的范围从索引fromIndex扩展到索引toIndex ，排他。
（如果fromIndex==toIndex ，要填充的范围是空的。）
参数
a - 要填充的数组
fromIndex - 要用指定值填充的第一个元素（包括）的索引
toIndex - 要用指定值填充的最后一个元素（排除）的索引
val - 要存储在数组的所有元素中的值

public static void fill(int[] a, int v) {
		for (int i = 0; i < a.length; i++) {
			a[i] = v;
		}
	}

调用 fill,输出填充后的数组a
运行结果为[2,2,2,2,2]

public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5 };
		fill(a, 2);
		Arrays.fill(a, 2);
		System.out.println(Arrays.toString(a));
}

4、数组复制/填充/拷贝
public static int[] copyOf(int[] original,int newLength):
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。
对于在副本中而不是原件有效的任何索引，副本将包含0 。
当且仅当指定长度大于原始数组的长度时，这些索引才会存在。
参数
original - 要复制的数组
newLength - 要返回的副本的长度
结果
原始数组的副本，被截断或用零填充以获得指定的长度

public static int[] copyOf (int[] original, int newLength) {
		int[] dest = new int[newLength];
		int length = original.length <= newLength ? original.length : newLength;
		for (int i = 0; i < length; i++) {
			dest[i] = original[i];
		}
		
		return dest;
	}

运行结果：
[1,2,3,4,5,0,0,0,0,0]

public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5 };
		copyOf(a, 10);
		//System.out.println(Arrays.toString(copyOf(a, 10)));
		System.out.println(Arrays.toString(Arrays.copyOf(a, 10)));
}

运行结果：
[0,0,0,0,0,1,2,3,4,5]
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：
将指定源数组中的数组从指定位置复制到目标数组的指定位置。
如果dest是null ，那么会抛出一个NullPointerException 。
如果src是null ，则抛出一个NullPointerException并且目标数组不被修改。
参数
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目的地数据中的起始位置。
length - 要复制的数组元素的数量。

public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5 }; 
        int[] b = new int[10];
		System.arraycopy(a, 0, b, 5, 5);
		System.out.println(Arrays.toString(b));
		}

若 System.arraycopy(a, 2, b, 6, 1);
System.out.println(Arrays.toString(b));
则运行结果为
[0,0,0,0,0,0,3,0,0,0]
即将数组a中下标为2的元素复制给数组dest中下标为6的元素，复制元素的个数为1。