一、Java 数组的使用

忘是亡心i 2023-01-08 02:08 86阅读 0赞

# ***一、数组的使用 `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]