一些关于数组的小练习

1.

已知：faibonacci（费波那契）数列的前几个数分别为 1，1，2，3，5，……。

从第 3 项开始，每一项都等于前两项的和。

读入一个整数 n，编程求出此数列的前 n 项的值存到数组中，并打印各个元素的值。

注意：这里的数列是从 1开始的。

import java.util.Scanner;

public class num1 {
    /*
     * 已知：faibonacci（费波那契）数列的前几个数分别为 1，1，2，3，5，……。 从第 3 项开始，每一项都等于前两项的和。 
     * 读入一个整数n，编程求出此数列的前 n 项的值存到数组中，并打印各个元素的值。
     * 注意：这里的数列是从 1开始的。
     */
    public static void main(String[] args) {
        /*
         *伪码:
         *引入Scanner类，声明整数n为自输入值;
         *定义数组arr;
         *使用while循环遍历数组元素;
         *if   else  结构分类为数组赋值;
         *在循环内输出数组元素.
         */
        int i = 0;
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个您想读入的数:");
        int n = in.nextInt();
        int[] arr = new int[n];
        while (i < n) {
            if (i < 2) {
                arr[i] = 1;
            } else {
                arr[i] = arr[i - 2] + arr[i - 1];
            }
            System.out.println("a[" + i + "]:" + arr[i]);
            i++;
        }
        in.close();
    }
}

2.

创建一个char类型的26个元素的数组，分别 放置'A'-'Z'。

使用for循环访问所有元素并打印出来。

public class num2 {
    /*
     * 创建一个char类型的26个元素的数组，分别 放置'A'-'Z'。 使用for循环访问所有元素并打印出来。
     */
    public static void main(String[] args) {
        /*
         * 伪码: 定义一个长度为26位的char类型数组a; 
         * 初始化a[0]为A; 
         * 使用for循环遍历数组a; 
         * 使得a[i]时的值为A+2，注意需强转为char.
         */
        char[] a = new char[26];
        a[0] = 'A';
        for (int i = 0; i < 26; i++) {
            a[i] = (char) (i + a[0]);
            System.out.println("a[" + i + "]=" + a[i]);
        }
    }
}

3.

自定义一个整数数组 a，读入一个整数 n，如果 n 在数组中存在，则输出 n 的下标；如果不存在，则输出-1。

import java.util.Scanner;

public class num3 {
    /*
     *自定义一个整数数组 a，读入一个整数 n，如果 n 在数组中存在，则输出 n 的下标；如果不存在，则输出-1。
     */
    public static void main(String[] args) {
        /*
         *伪码:
         *自定义一个整数数组 a;
         *引入Scanner类，声明整数n为自输入值，;
         *使用for循环遍历数组a元素;
         *使用if选择结构设置条件为当数组有元素等于自输入值时，输出此时下标，否则则输出-1.
         */
        int[] a = {1,2,3,4,5};
        Scanner in = new Scanner(System.in);
        System.out.println("请输入要查找的整数n：");
        int n = in.nextInt();
        boolean index = true;
        for(int i=0;i<a.length;i++) {
            if(a[i]==n) {
                index = false;
                break;
            }
        }
        if(index==false) {
            System.out.println("元素存在，下标为："+index);
        }else {
            System.out.println("元素不存在    -1");
        }
        in.close();
    }
}

4.

给定一个数组，将数组中所有的元素倒序输出

public class num4 {
    /*
     *给定一个数组，将数组中所有的元素倒序输出
     */
    public static void main(String[] args) {
        /* 
         * 伪码:
         * 定义一个数组a;
         * 设定for循环;
         * 遍历整个数组，替换下标;
         * 输出数组元素.
         */
        int[] a = {1,2,3,4,5};
        for(int i=0;i<5;i++) {
            int n=4-i;
            System.out.println("a["+i+"]="+a[n]);
        }
    }
}

5.

某百货商场当日消费积分最高的八名顾客，他们的积分分别是：18，25，7，36，13，2，89和63，

编写程序找出最低的积分及它在数组中的位置（索引）

public class num5 {
    /*某百货商场当日消费积分最高的八名顾客，他们的积分分别是：18，25，7，36，13，2，89和63，
     *    编写程序找出最低的积分及它在数组中的位置（索引）
     */
    public static void main(String[] args) {
        /* 
         * 伪码：
         * 定义数组a存储顾客积分;
         * 运用for循环中的if选择找出最小值并记录此时其下标;
         * 输出最小值及其下标.
         */
        int[] a = {18,25,7,36,13,2,89,63};
        int min = a[0];
        int index = 0;
        for(int i=1;i<a.length;i++) {
            if(a[i]<min) {
                min=a[i];
                index=i;
            }
        }
        System.out.println("数组中积分最低的为："+min);
        System.out.println("数组中积分最低的位置为："+index);
    }
}

6.

定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，统计各成绩等级（90分以上为‘A’，80~89分为‘B’，70~79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，并将其放入到数组count中，其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。

public class num6 {
    /*
     * 定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，
     * 统计各成绩等级（90分以上为‘A’，80~89分为‘B’，70~79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，
     * 并将其放入到数组count中，其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。
     */
    public static void main(String[] args) {
        /*
         * 伪码: 定义数组a存储12个学生的成绩; 初始化各成绩出现次数的计数器; 使用for循环遍历数组; 在for中对数组a中元素使用if分类并计数;
         * 定义count数组; 将计数器记得数子赋值到count数组.
         */
        int[] a = { 72, 89, 65, 58, 87, 91, 53, 82, 71, 93, 76, 68 };
        int[] count = new int[5];
        count[0] = 0;
        count[1] = 0;
        count[2] = 0;
        count[3] = 0;
        count[4] = 0;
        for (int i = 0; i < a.length; i++) {
            if (a[i] > 90) {
                count[0]++;
            } else if (a[i] > 80) {
                count[1]++;
            } else if (a[i] > 70) {
                count[2]++;
            } else if (a[i] > 60) {
                count[3]++;
            } else {
                count[4]++;
            }
        }
    }
}

7.

定义一个数组，将数组的最大值和第一个元素交换位置，最小值和最后一个元素交换位置，其他元素位置不变

public class num7 {
    /*
     * 定义一个数组，将数组的最大值和第一个元素交换位置，最小值和最后一个元素交换位置，其他元素位置不变
     */
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        /*
         *伪码:
         *定义一个数组a;
         *设定for循环;
         *遍历整个数组，分别查找最大最小值并记录其所在下标;
         *将最大值的下标与最后一个元素的下标替换;
         *将最小值的下标与第一个元素的下标替换.
         */
        int[] a = { 2, 6, 8, 5, 1, 44 };//
        int max = a[0];
        int m = 0;
        int min = a[a.length - 1];
        int n = 0;
        for (int i = 0; i < a.length; i++) {
            if (max < a[i]) {
                max = a[i];
                m = i;
            }
            if (min > a[i]) {
                min = a[i];
                n = i;
            }
        }
        int temp = max;
        a[m] = a[0];
        a[0] = max;
        int temp1 = min;
        a[n] = a[a.length - 1];
        a[a.length - 1] = min;
    }
}

8.

给定一个数组，把这个数组中所有元素顺序进行颠倒

public class num8 {
    /*
     * 给定一个数组，把这个数组中所有元素顺序进行颠倒
     */
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        /*
         *伪码:
         *定义一个数组a;
         *i---a.length-1-i;
         *
         *遍历整个数组，替换下标.
         */
        int[] a = {1,2,3,4,5};
        for(int i=0;i<5;i++) {
            int n=4-i;
        }
    }
}