一、数组的使用 Java
要求
请开发一个类包含如下功能的静态方法：
1.1打印一个整型数组。
1.2将一个整型数组反序排列。
1.3求一个整型数组元素中的最大值。
1.4将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置。
1.5求一个整型数组各元素之和。
1.6编写一个方法，其功能是对一个整型数组升序排列（请采用冒泡算法）。
1.7用选择法对若干个数排序（由大到小）。
1.8用插入法对若干个数排序（由大到小）。
1.9用折半查找法在一组排好序(递增有序或递减有序)的值中查找某个数据。
1.10求一个整型数组元素中最接近其平均值的整数。
1.11实现一个数组复制方法，参数为:源数组、起始下标、复制长度，返回值为新数组
代码如下
import java.util.*;
public class Array {
private int length;
private int[] a;
private Array(int[] a) {
this.a = a;
this.length = a.length;
}
//打印一个整型数组
private void Printarray() {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
for (int i : a) {
System.out.print(i + " ");
}
System.out.println();
}
//将一个整型数组反序排列
private void Reversearrangement(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
for (int i = a.length - 1; i >= 0; i--) {
System.out.print(a[i] + " ");
}
System.out.println();
}
//求一个整型数组元素中的最大值,最小值
private void Arraymax(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
int max, min;
max = min = a[0];
for (int i = 0; i < a.length; i++) {
if (a[i] > max) {
max = a[i];
}
if (a[i] < min) {
min = a[i];
}
}
System.out.println("最大值为：" + max + " 最小值为：" + min);
}
//将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置
private void Arraymove(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
int j = a[0];
for (int i = 0; i < a.length - 1; i++) {
a[i] = a[i + 1];
}
for (int i = 0; i < a.length; i++) {
a[length - 1] = j;
System.out.print(a[i] + " ");
}
System.out.println();
}
//求一个整型数组各元素之和
private int Arraysum(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
int i, sum = 0;
for (i = 0; i < a.length; i++) {
sum = sum + a[i];
}
return sum;
}
//编写一个方法，其功能是对一个整型数组升序排列（请采用冒泡算法）
private void Bubblesort(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
for (int i = 0; i < a.length - 1; i++)
for (int j = 0; j < a.length - 1 - i; j++)
if (a[j] > a[j + 1]) {
int x = a[j];
a[j] = a[j + 1];
a[j + 1] = x;
}
for (int i : a) {
System.out.print(i + " ");
}
System.out.println();
}
//用选择法对若干个数排序（由大到小）
private void Selectsort(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
int i, j, t;
for (i = 0; i < a.length - 1; i++) {
for (j = i + 1; j < a.length; j++) {
if (a[i] < a[j]) {
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
for (i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
//用插入法对若干个数排序（由小到大）
private void Insertsort(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
for (int i = 0; i < a.length - 1; i++) {
int j = a[i + 1];
int k = i;
while (k >= 0 && j < a[k]) {
a[k + 1] = a[k];
k--;
}
a[k + 1] = j;
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
//用折半查找法在一组排好序(递增有序或递减有序)的值中查找某个数据
private int HalfSearch(int[] a, int m) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
int i, j, k;
j = 0;
k = a.length - 1;
while (j <= k) {
i = (j + k) / 2;
if (m < a[i])
k = i - 1;
else if (m > a[i])
j = i + 1;
else
return i;
}
return -1;
}
//求一个整型数组元素中最接近其平均值的整数
private int Closeaverage(int[] a) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
int i, sum = 0;
for (i = 0; i < a.length; i++) {
sum = sum + a[i];
}
int y = sum / a.length;
if (a == null) {
return -1;
}
if (a.length == 1) {
return a[0];
}
int k = -1;
for (int j = 0; j < a.length; j++) {
if (a[j] > y) {
k = j;
break;
} else if (a[j] == y) {
return y;
}
}
int z;
if (k == -1) {
return a[a.length - 1];
} else if (k == 0) {
return a[0];
} else {
z = y - a[k - 1] < a[k] - y ? a[k - 1] : a[k];
}
return z;
}
//实现一个数组复制方法，参数为:源数组、起始下标、复制长度，返回值为新数组
private int[] Copyarray(int[] a, int e, int f) {
if (a == null || a.length == 0) {
System.out.println("输入的数组不合法！");
}
if (e < 0 || e > a.length - 1) {
System.out.println("输入的起始位置不合法！");
}
if (f < 1 || f > a.length - e) {
System.out.println("输入的复制长度不合法！");
}
int[] arr = new int[f];
for (int i = 0, j = e; i < arr.length; i++, j++) {
arr[i] = a[j];
}
return arr;
}
//主函数
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入你想定义的数组长度：");
int n = input.nextInt();
int[] a = new int[n];
System.out.print("请输入与定义的数组长度相等的正整数(若输入的数超过，则只会取与数组长度相等的数)：");
Array ll = new Array(a);
for (int i = 0; i < a.length; i++) {
a[i] = input.nextInt();
}
System.out.print("打印出的数组为：");
ll.Printarray();
System.out.print("数组的反序排列为：");
ll.Reversearrangement(a);
System.out.print("整型数组元素中的");
ll.Arraymax(a);
System.out.print("数组移动后的新数组为：");
ll.Arraymove(a);
System.out.print("数组中的元素之和为：");
int b = ll.Arraysum(a);
System.out.print(b + "\n");
System.out.print("冒泡排序的结果为(升序)：");
ll.Bubblesort(a);
System.out.print("选择排序的结果为(降序)：");
ll.Selectsort(a);
System.out.print("插入排序的结果为(升序)：");
ll.Insertsort(a);
System.out.print("请输入你想要查找的数字：");
int c = input.nextInt();
System.out.print("查找的数字的位置为(不在数组的元素输出的位置为-1)：");
int d = ll.HalfSearch(a, c);
System.out.print(d);
System.out.println();
System.out.print("距离平均值最近的数为：");
int e = ll.Closeaverage(a);
System.out.print(e);
System.out.println();
System.out.print("请输入你想要复制的起始位置：");
int f = input.nextInt();
System.out.print("请输入你想要复制的长度：");
int g = input.nextInt();
System.out.print("复制完成的数组为：");
int arr [] = ll.Copyarray(a, f,g);
System.out.print(Arrays.toString(arr));
}
}运行结果
示例：
请输入你想定义的数组长度：5
请输入与定义的数组长度相等的正整数(若输入的数超过，则只会取与数组长度相等的数)：1 3 0 5 9
打印出的数组为：1 3 0 5 9
数组的反序排列为：9 5 0 3 1
整型数组元素中的最大值为：9 最小值为：0
数组移动后的新数组为：3 0 5 9 1
数组中的元素之和为：18
冒泡排序的结果为(升序)：0 1 3 5 9
选择排序的结果为(降序)：9 5 3 1 0
插入排序的结果为(升序)：0 1 3 5 9
请输入你想要查找的数字：3
查找的数字的位置为(不在数组的元素输出的位置为-1)：2
距离平均值最近的数为：3
请输入你想要复制的起始位置：2
请输入你想要复制的长度：2
复制完成的数组为：[3, 5]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
