Java数组案例详解

1. （易）设计一个方法，找出一个数组中最大的数字，连同所在的下标一起输出
       
       import java.net.BindException;
       
       //（易）设计一个方法，找出一个数组中最大的数字，连同所在的下标一起输出。
       public class Demo1 {
           public static void main(String[] args) {
               int[] arr = new int[]{4,5,8,10,100,50,20,500};
               int temp = arr[0];
               int index = 0;
               for (int i = 0; i < arr.length-1; i++) {
                   if(temp <= arr[i+1]){
                       temp = arr[i+1];
                       index  =i+1;
                   }
               }
               System.out.println("数组中最大的值是："+index);
               System.out.println("数组中最大的值是："+temp);
           }
       }
       run:
       数组中最大的值是：4
       数组中最大的值是：500

2.设计一个方法，判断一个数组是不是一个升序的数组。

    //（中）设计一个方法，判断一个数组是不是一个升序的数组
    public class Demo2 {
        public static void main(String[] args) {
            /*输入一个数组*/
            int arr[] = new int[]{8,2,1,6};
            System.out.println(judgeArray(arr));
        }
        public static boolean judgeArray(int[] arr){
            /*给数组的第一个定义一个变量
            * 然后用它去进行比较*/
            int num = arr[0];
            /*分析：
            * 只是要求判断是不是一个升序的数组
            * 如果是就放回true
            * 不是就返回false*/
            for (int i = 0; i < arr.length-1; i++) {
                if (num > arr[i+1]){
                    return false;
                }
                }
            return true;
            }
        }
    run:
    false

3.（难）设计一个方法，找出一个整型数组中的第二大的值。1. 不可以通过排序实现，不能修改数组中的数据顺序2. 要考虑到最大的数字可能出现多次
 
    import java.util.Arrays;
    
    /*（难）设计一个方法，找出一个整型数组中的第二大的值。
            1. 不可以通过排序实现，不能修改数组中的数据顺序2.
            要考虑到最大的数字可能出现多次*/
    public class Demo3 {
        public static void main(String[] args) {
            int[] arr = new int[]{3,6,5,7,2};
            int[] maxAndSe = printValue(arr);
            System.out.println(Arrays.toString(maxAndSe));
    
        }
        public static int[] printValue(int[] arr){
            /*定义两个变量 存数组中的第一个元素和第二个元素*/
            int max= 0;
            int second = 0;
            /*条件判断哪个值更大一些
            * 分别存放进各自的变量
            * */
           if (arr[0]>arr[1]){
               max = arr[0];
               second = arr[1];
           }else{
               second = arr[0];
               max = arr[1];
           }
           /*因为第一第二个元素已经进行判断
           * 所以数组的循环可以从2开始*/
            for (int i = 2; i < arr.length-1; i++) {
                /*进行条件判断
                如果max值小于数组的其他值*/
                if (arr[i]>max){
                    /*逻辑输出
                    * 把最大的值先给第二大的值
                    * 然后数组大的值才给max*/
                    second = max;
                    max = arr[i];
                }else if (arr[i]<max && arr[i]>second){
                    second = arr[i];
                }
            }
            int [] temp = {max,second};
            Arrays.sort(arr);
            return temp;
        }
    }
    run:
    [7, 6]
    

4.（中）设计一个方法，将一个数组中的元素倒序排列（注意，不是降序）。

    
    import java.lang.reflect.Array;
    import java.util.Arrays;
    
    //（中）设计一个方法，将一个数组中的元素倒序排列
    // （注意，不是降序）。
    public class Demo4 {
        public static void main(String[] args) {
            int[] arr = new int[]{1,2,4};
             printArray(arr);
        }
        public static void printArray(int[] arr){
            /*倒叙排列
            * 遍历一个数组是顺序输出所有的数
            * */
            /*交换第0位和最后一位 第一位和倒数第二位 ...
            * 只需交换一半即可*/
            for (int i = 0; i < arr.length/2; i++) {
                int temp  = arr[i];
                arr[i] = arr[arr.length-1-i];
                arr[arr.length-1-i] = temp;
            }
            /*在方法内使用Arrays.toString遍历输出交换完成的数组*/
            System.out.println(Arrays.toString(arr));
        }
    }
    run:
    [4, 2, 1]

5.
    
    import java.util.Arrays;
    
    /*（易）将一个数组中的元素拷贝到另外一个数组中。*/
    public class Demo5 {
        public static void main(String[] args) {
            int[] array = new int[]{1, 3, 2, 4};
            int[] newarray = new int[4];
            copy(array,newarray);
        }
        public static void copy(int[] array,int[] newarray){
            for (int i = 0; i < array.length; i++) {
                if(i>=newarray.length){
                    break;
                }
                newarray[i]  =array[i];
            }
            System.out.println(Arrays.toString(newarray));
        }
    }
    run:
    [1, 3, 2, 4]

6.

    // （易）设计一个方法，比较两个数组中的元素是否相同
    // （数量、每一个元素都相同，才认为是相同的数组）。
    public class Demo6 {
        public static void main(String[] args) {
            int[] arr = {1,2,3};
            int[] arr2 = {1,2,4};
            System.out.println(compare(arr,arr2));
        }
        private static boolean compare(int[] arr,int[] arr2){
            /*先进行特殊的判断*/
            if(arr == null || arr2== null || arr.length != arr2.length){
                return false;
            }
            /*否则的话逐个元素的进行比较*/
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] != arr2[i]){
                    return false;
                }
            }
            return true;
            }
        }
        run:
        false

7.

    /*（中）使用递归计算一个数组中的元素和*/
    public class Demo7 {
        public static void main(String[] args) {
            int[] arr = {1,2,3,5};
            System.out.println(sum(arr,3));
        }
        public static int sum(int[] arr){
            return sum(arr,arr.length-1);
        }
        public static int sum(int[] arr,int index){
            if (index==0){
                return arr[0];
            }
            return arr[index] + sum(arr, index-1);
        }
    }
    run:11

8.

    
    import java.util.Scanner;
    
    /*（易）小明参加歌手比赛，评委组给出10个成绩，
    去掉一个最高分，去掉一个最低分，求平均分*/
    public class Demo8 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            double[] score = new double[10];
            System.out.println("请输入十个成绩：");
            for (int i = 0; i < 10; i++) {
                score[i] = scanner.nextDouble();
            }
            System.out.println(getAverage(score));
        }
        private static double getAverage(double[] score){
            double sum= 0;
            double max= score[0];
            double  min = score[0];
            for (double scores:score) {
                sum += scores;
                if (scores > max){
                    max = scores;
                }
                if (scores<min){
                    min = scores;
                }
            }
            return (sum - max - min)/(score.length-2);
        }
    }
    run:
    请输入十个成绩：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    5.5

9.
    //（中）设计一个方法，将一个字符串中的大小写字母翻转
    public class Demo9 {
        public static void main(String[] args) {
            /*将一个字符串转成一个的数组*/
            char[] array = "hello".toCharArray();
            String str = new String(array);
            System.out.println(getReverse(str));
        }
    
        public static String getReverse(String str) {
            char[] array = str.toCharArray();
            for (int i = 0; i < array.length; i++) {
                char c = array[i];
                if (c >= 'a' && c <= 'z') {
                    array[i] -= 32;
                }
                else if(c >= 'A' && c <= 'Z') {
                    array[i] += 32;
                }
            }
            return new String(array);
        }
    }
    run:
    HELLO