Test1.java

package com;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Test1 {

    public static void main(String[] args) {

        // NO.1 6-1 什么是数组
        // 定义一个数组，保存五名学生的成绩
        int[] scores = { 78, 93, 97, 84, 63 };

        // 输出数组中的第二个成绩
        System.out.println("数组中的第2个成绩为：" + scores[1]);

        // NO.2 6-3 如何使用java中的数组
        // 定义一个长度为5的字符串数组，保存考试科目信息
        String[] subjects = new String[5];

        // 分别为数组中的元素赋值
        subjects[0] = "Oracle";
        subjects[1] = "PHP";
        subjects[2] = "Linux";
        subjects[3] = "Java";
        subjects[4] = "HTML";

        System.out.println("数组中第4个科目为：" + subjects[3]);

        // NO.3 6-5 使用循环操作java中的数组
        // 定义一个长度为 3 的字符串数组，并赋值初始值
        String[] hobbys = { "sports", "game", "movie" };
        System.out.println("循环输出数组中元素的值：");

        // 使用循环遍历数组中的元素

        for (int i = 0; i < hobbys.length; i++) {
            System.out.println(hobbys[i]);
        }

        // NO.4 6-6 编程练习
        // 定义一个整型数组，并赋初值
        int[] nums = new int[] { 61, 23, 4, 74, 13, 148, 20 };

        int max = nums[0]; // 假定最大值为数组中的第一个元素
        int min = nums[0]; // 假定最小值为数组中的第一个元素
        double sum = 0;// 累加值
        double avg = 0;// 平均值

        for (int i = 0; i < nums.length; i++) { // 循环遍历数组中的元素
            // 如果当前值大于max，则替换max的值

            if (nums[i] > max) {

                max = nums[i];
            }

            // 如果当前值小于min，则替换min的值

            if (nums[i] < min) {
                min = nums[i];
            }

            // 累加求和
            sum += nums[i];

        }

        // 求平均值
        avg = sum / nums.length;

        System.out.println("数组中的最大值：" + max);
        System.out.println("数组中的最小值：" + min);
        System.out.println("数组中的平均值：" + avg);

        // NO.5 7-1 如何定义java中的方法
        // 在 main 方法中调用 print 方法
        Test1 test1 = new Test1();
        test1.print();

        // NO.6 7-2 java中无参无返回值方法的使用
        test1.showMyLove();

        // NO.7 7-3 java中无参带返回值方法的使用
        // 调用hello对象的calcAvg()方法，并将返回值保存在变量avg中
        double avg1 = test1.calcAvg();

        System.out.println("平均成绩为：" + avg1);

        // NO.8 7-4 编程练习
        // 调用方法并将返回值保存在变量中
        int maxScore = test1.getMaxAge();

        // 输出最大年龄
        System.out.println("最大年龄为：" + maxScore);

        // NO.9 7-5 java中带参无返回值方法的使用
        test1.calAvg(94, 81);

        // NO.10 7-6 java中带参带返回值方法的使用
        int[] scores1 = { 79, 52, 98, 81 };

        // 调用方法，传入成绩数组，并获取成绩的个数
        int count = test1.sort(scores1);

        System.out.println("共有" + count + "个成绩信息！");

        // NO.11 7-8 java中方法的重载
        test1.print();
        // 调用带有一个字符串参数的方法
        test1.print("jdjdj");

        // 调用带有一个整型参数的方法
        test1.print(4);

        // NO.12 7-8 编程练习
        // 调用方法并将返回值保存在变量中
        int[] nums1 = test1.getArray(8);

        // 将数组转换为字符串并输出
        System.out.println(Arrays.toString(nums1));

        // NO.13 8-1 编程练习
        int[] scores2 = { 89, -23, 64, 91, 119, 52, 73 };
        int count1 = 0;
        int[] Three = test1.numThree(scores2);
        for (int i = scores2.length - 1; i >= 0 && count1 < 3; i--) {
            if (Three[i] > 100 || Three[i] < 0) {
                continue;
            } else {
                System.out.println(Three[i]);
                count1++;
            }

        }
    }

    // 定义了一个方法名为 print 的方法，实现输出信息功能
    public void print() {
        System.out.println("Hello World");
    }

    /*
     * 定义无参无返回值的方法
     */
    public void showMyLove() {
        System.out.println("我爱慕课网!");
    }

    // 定义一个返回值为double类型的方法
    public double calcAvg() {

        double java = 92.5;
        double php = 83.0;
        double avg = (java + php) / 2; // 计算平均值

        // 使用return返回值
        return avg;

    }

    /*
     * 功能：输出学生年龄的最大值 定义一个无参的方法，返回值为年龄的最大值 参考步骤： 1、定义一个整形数组 ages ，保存学生年龄，数组元素依次为 18
     * ,23 ,21 ,19 ,25 ,29 ,17 2、定义一个整形变量 max ,保存学生最大年龄，初始时假定数组中的第一个元素为最大值 3、使用 for
     * 循环遍历数组中的元素，并与假定的最大值比较，如果比假定的最大值要大，则替换当前的最大值 4、使用 return 返回最大值
     */
    public int getMaxAge() {

        int[] ages = { 18, 23, 21, 19, 25, 29, 17 };
        int maxScore = ages[0];
        for (int i = 1; i < ages.length; i++) {
            if (ages[i] > maxScore) {
                maxScore = ages[i];
            }

        }
        return maxScore;

    }

    /*
     * 功能：计算两门课程考试成绩的平均分并输出平均分 定义一个包含两个参数的方法，用来传入两门课程的成绩
     */
    public void calAvg(int a, int b) {
        double c = (a + b) / 2;
        System.out.println("pingjunfen3 " + c);
    }

    /*
     * 功能：将考试成绩排序并输出，返回成绩的个数 定义一个包含整型数组参数的方法，传入成绩数组 使用Arrays类对成绩数组进行排序并输出
     * 方法执行后返回数组中元素的个数
     */
    public int sort(int[] scores) {
        Arrays.sort(scores);
        System.out.println(Arrays.toString(scores));

        // 要转换的list集合
        List<String> testList = new ArrayList<String>() {
            /**
            * 
            */
            private static final long serialVersionUID = 1L;

            {
                add("aa");
                add("bb");
                add("cc");
            }
        };

        // 使用toArray(T[] a)方法
        String[] array2 = testList.toArray(new String[testList.size()]);

        // 打印该数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println(Arrays.toString(array2));

        // list升序，降序，逆序
        List<Integer> list = new ArrayList<Integer>() {
            /**
            * 
            */
            private static final long serialVersionUID = 1L;

            // {
            // add(1);
            // add(2);
            // }
        };
        list.add(5);
        list.add(7);
        list.add(2);
        list.add(6);
        list.add(8);
        list.add(1);
        list.add(4);

        System.out.println("正序" + Arrays.toString(list.toArray(new Integer[list.size()])));
        // 3、逆序；
        Collections.reverse(list);// list：4 1 8 6 2 7 5
        System.out.println("逆序" + Arrays.toString(list.toArray(new Integer[list.size()])));
        // 1、升序：
        Collections.sort(list);// list： 1 2 4 5 6 7 8
        System.out.println("升序" + Arrays.toString(list.toArray(new Integer[list.size()])));
        // 2、降序：
        Collections.sort(list, Collections.reverseOrder());// list:8 7 6 5 4 2 1
        System.out.println("降序" + Arrays.toString(list.toArray(new Integer[list.size()])));

        // 数组升序，降序
        int[] a = { 5, 7, 2, 6, 8, 1, 4 };
        // 1、升序：
        Arrays.sort(a);// a： 1 2 4 5 6 7 8
        System.out.println("数组升序" + Arrays.toString(a));
        // 2、降序：
        // List<int[]> list2=Arrays.asList(a);

        // int[] src = {1,2,3,4,5,6,7,8,9,10};
        List<Integer> list2 = Arrays.stream(a).boxed().collect(Collectors.toList());

        Collections.sort(list2, Collections.reverseOrder());// a： 8 7 6 5 4 2 1
        System.out.println("数组降序" + Arrays.toString(list2.toArray(new Integer[list2.size()])));
        // 返回数组中元素的个数
        return scores.length;

    }

    public void print1() {
        System.out.println("无参的print方法");
    }

    public void print(String name) {
        System.out.println("带有一个字符串参数的print方法，参数值为：" + name);
    }

    public void print(int age) {
        System.out.println("带有一个整型参数的print方法，参数值为：" + age);
    }

    /*
     * 功能：创建指定长度的int型数组，并生成100以内随机数为数组中的每个元素赋值 定义一个带参带返回值的方法，通过参数传入数组的长度，返回赋值后的数组
     */
    public int[] getArray(int length) {
        // 定义指定长度的整型数组
        int[] nums = new int[length];

        // 循环遍历数组赋值
        for (int i = 0; i < length; i++) {

            // 产生一个100以内的随机数，并赋值给数组的每个成员
            nums[i] = (int) (Math.random() * 100);

        }
        return nums; // 返回赋值后的数组
    }

    // 定义方法完成成绩排序并输出前三名的功能

    public int[] numThree(int[] scores) {
        Arrays.sort(scores);
        return scores;

    }
}