• 第五章 数组及排序 ② 代码

    这里写目录标题

    1.课前测试

    在这里插入图片描述

    代码如下：

    package com.yzh7.test1;

import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 09:34:00
 */
public class Test {
    public static void main(String[] args) {
        //创建输入工具类对象
        //Scanner scanner = new Scanner(System.in);
        //System.out.println("请输入一个主字符串:");
        String mainStr = "新年好，新年好，祝福新年好";//scanner.next();
        //System.out.println("请输入要查找的字符串:");
        String findStr ="新年好"; //scanner.next();

        /*
        int count = 0;
        //查找过程，统计出现次数
        while (true){
            int pos = mainStr.indexOf(findStr);
            //没找到
            if(pos==-1){
                break;
            }
            //找到则次数加1
            count++;
            //将主字符串截取出来没有查找过的部分
            mainStr = mainStr.substring(pos+findStr.length());
        }
        */

        int count=0;
        for (int i=0;i<=mainStr.length()-findStr.length();i++){
            //从特定位置截取出要查找内容长度的字符串
            String sub = mainStr.substring(i,i+findStr.length());
            System.out.println(mainStr);
            System.out.println(i);
            System.out.println(sub);

            if(sub.equals(findStr)){
                count++;
                System.out.println("匹配上了");
            }
            System.out.println("====================");
        }

        System.out.println("查找到的["+findStr+"]在主字符串中的次数是:"+count+"次");

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    package com.yzh7.test1;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 09:51:05
 */
public class Test2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("=====求日期差=====");
        System.out.println("请输入日期1:");
        String str1 = sc.next();
        System.out.println("请输入日期2:");
        String str2 = sc.next();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = sdf.parse(str1);
        Date d2 = sdf.parse(str2);

        while (true) {
            System.out.println("请选择求差单位:1.年 2.月 3.日 4.退出");
            int choose = sc.nextInt();
            switch (choose) {
                case 1:
                    System.out.println((d2.getTime()-d1.getTime())/1000/3600/24/365);
                    break;
                case 2:
                    System.out.println((d2.getTime()-d1.getTime())/1000/3600/24/30);
                    break;
                case 3:
                    System.out.println((d2.getTime()-d1.getTime())/1000/3600/24);
                    break;
                case 4:
                    System.out.println("退出");
                    return;
                default:
                    System.out.println("选择错误，请重新选择");
                    break;
            }

        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    思路一：
    先查找第一个字符串 然后截取出未查找的部分进行一次查找
    不确定次数的循环 while(true)
    计数器计数 终止条件break

    思路二：三字逐字匹配
    匹配成功计数器+1
    字符串随着for循环进行截取改变

    package com.yzh70630;
import java.util.Scanner;
/**
 * @author: XYT
 * @create-date: 2022/6/30 8:59
 */
public class TiMU1 {
    public static void main(String[] args) {
//        Scanner input=new Scanner(System.in);
//        System.out.println("请输入一个主字符串：");
//        String zhu1=input.next();
//        System.out.println("请输入要查找的字符串：");
//        String zhu2=input.next();
//        String[] N=zhu1.split(zhu2);
//        int n=N.length;
//        System.out.println("查找的["+zhu2+"]在字符串中出现了"+n+"次");

        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个主字符串：");
        String zhu1=input.next();
        System.out.println("请输入要查找的字符串：");
        String zhu2=input.next();
        int count=0;
        /*
        //第一种方法 不确定次数的循环while(true)
        while(true){
            int pos=zhu1.indexOf(zhu2);
            if(pos==-1){
                break;
            }
            count++;
            zhu1=zhu1.substring(pos+1);
        }
        */

        //字符长度 xxx.length() 数组长度 xxx.length 详见下一章节博客
        //第二种方法 for循环
        for (int i = 0; i <= zhu1.length()-zhu2.length(); i++) {  //这里是<=,否则最后一个"新年好"将无法匹配
            String jie=zhu1.substring(i,i+zhu2.length());
            if(zhu2.equals(jie)){
                count++;
            }
        }
        System.out.println("查找的["+zhu2+"]在字符串中出现了"+count+"次");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    在这里插入图片描述

    package com.yzh70630;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Period;
import java.time.format.DateTimeFormatter;

import java.util.Scanner;

/**
 * @author: XYT
 * @create-date: 2022/6/30 9:11
 */
public class QiCe {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入第一个日期字符串：");
        String s1=input.next();
        System.out.println("请输入第二个日期字符串：");
        String s2=input.next(); 
        DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate ld1 =  LocalDate.parse(s1,dtf2);    //这里老师用的是.getTime()
        LocalDate ld2 = LocalDate.parse(s2,dtf2);
        Period period = Period.between(ld1,ld2);
        //System.out.println("请输选择求差单位：1，年2.月，3.日，4，推出"); //注意:需要把判断变量放在函数里，否则将会出现死循环
        //int n=input.nextInt();

        //以下是功能不完整的残次品
//        int yue=period.getMonths();
//        int ri=period.getDays();
//        if(n==1){
//            System.out.println("两个日期相差了："+period.getYears()+"年");
//        } else if (n==2) {
//
//            System.out.println("两个日期相差了："+period.getYears()*12+yue+"月");
//        }else if(n==3){
//            System.out.println("两个日期相差了："+(period.getYears()*12+yue)*30+ri+"日");
//        }else if(n==4){
//            return;
//        }
        //功能完整的代码
        while(true){
            System.out.println("请输选择求差单位：1，年2.月，3.日，4，推出");
            int n=input.nextInt();
            int yue=period.getMonths();  
            int ri=period.getDays();
            switch(n){
                case 1:
                    System.out.println("两个日期相差了："+period.getYears()+"年");
                    break;
                case 2:
                    System.out.println("两个日期相差了："+period.getYears()*12+yue+"月");
                    break;
                case 3:
                    System.out.println("两个日期相差了："+(period.getYears()*12+yue)*30+ri+"日");
                    break;
                case 4:
                    System.out.println("推出");
                    return;
                default:
                    System.out.println("选择错误，请重新选择！");
                    break;
            }

        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    运行结果如下：
    在这里插入图片描述
    在这里插入图片描述

    2.数组的三种创建方式

    代码如下：
    第一种：

    package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:07:38
 */
public class Test {
    public static void main(String[] args) {
        //1.创建指定长度的数组
        int[] nums = new int[3];
        System.out.println(nums.length);

        //遍历数组:索引遍历数组
        for (int i=0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
        System.out.println("======================");

        nums[0]=10;
        nums[1]=30;
        nums[2]=200;
        //nums[3]=400;//Array(数组)Index(索引)OutOf(超出)Bounds(边界)Exception(异常)

        //for each遍历
        for (int xxxxxx : nums){
            //xxxxxx:此时是遍历的数组元素本身
            System.out.println(xxxxxx);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    在这里插入图片描述

    第二种：

    package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:13:31
 */
public class Test2 {
    public static void main(String[] args) {
        //2.用new的方式创建有初始值的数组
        String[] names ;
        names = new String[]{"孙悟空","猪八戒","唐僧","沙僧"};
        //访问数组元素
        System.out.println(names[3]);
        System.out.println(names[names.length-1]);

        //修改数组元素
        names[2]="嫦娥";
        //遍历数组
        for (int i=0;i<names.length;i++){
            System.out.println(names[i]);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    第三种：

    package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:16:23
 */
public class Test3 {
    public static void main(String[] args) {
        //静态方式创建数据，并赋初始值
        double[] tall = {1.3,1.9,2.1};
        //tall = {1.3,1.9,2.1}; //不能分开定义赋值
        for (int i=0;i<tall.length;i++){
            System.out.println(tall[i]);
        }

        for (double d:tall){
            System.out.println(d);
        }


    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    练习：

    package com.yzh7.test2;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport;

import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 10:45:27
 */
public class Test4 {
    public static void main(String[] args) {
        //扩展:定义长度为3的字符串数组，用循环输入3个名字，循环输出
        Scanner sc = new Scanner(System.in);
        String[] names = new String[3]; //0 1 2
        for (int i=0;i<names.length;i++){
            System.out.println("请输入第"+(i+1)+"个学生的姓名:");
            String n =sc.next();
            names[i]=n;
        }

        System.out.println("===========");
        for(String s: names){
            System.out.println(s);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    使用数组时需要：import java.lang.reflect.Array;

    package com.yzh70630;

import java.lang.reflect.Array;

/**
 * @author: XYT
 * @create-date: 2022/6/30 10:20
 */
public class Array0 {
    public static void main(String[] args) {
        // 定义有容量的数组
        // 数据类型[] 数组变量 = new 数据类型[数组容量];
        int[] arr=new int[3];
        System.out.println(arr.length);
        //for循环遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        arr[0]=0;
        arr[1]=1;
        arr[2]=2;
        //for-each
        for (int xxx:arr) {
            System.out.println(xxx);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    运行结果如下：

    在这里插入图片描述

    package com.yzh70630;

/**
 * @author: XYT
 * @create-date: 2022/6/30 10:29
 */
public class Array1 {
    public static void main(String[] args) {
        // 定义有初始化数据的数组.后面的中括号中不能写长度
        //数据类型[] 数组变量 = new 数据类型[]{数据1,数据2...};
        //String[] arr1= new String[]{"八戒","猴子","和尚"};
        //拆分
        String[] arr1;
        arr1 = new String[]{"八戒","猴子","和尚"};

        System.out.println(arr1[2]);
        System.out.println(arr1[arr1.length-1]);

        //更换数组元素
        arr1[0]="嫦娥";
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    运行结果如下：
    在这里插入图片描述

    package com.yzh70630;

import java.util.Scanner;

/**
 * @author: XYT
 * @create-date: 2022/6/30 10:40
 */
public class Array2 {
    public static void main(String[] args) {
        /*
        // 直接赋值创建(静态创建)，定义和赋值必须写在一起
        //数据类型[] 数组变量 = {数据1,数据2...};
        double[] d={1.1,1.2,1.3};
        //for
        for (int i = 0; i < d.length; i++) {
            System.out.println(d[i]);
        }
        //for-each
        for(double xxxx:d){
            System.out.println(xxxx);
        }
        */
        //开辟一个数组
        int[] sz=new int[3];
        //依次输入三个数字
        for(int i=0;i<3;i++){
            System.out.println("请输入第"+(i+1)+"个数：");
            Scanner input=new Scanner(System.in);
            int a=input.nextInt();
            sz[i]=a;
        }
        for (int xxxxx:
             sz) {
            System.out.print(xxxxx+"  ");
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    运行结果如下：
    在这里插入图片描述

    3.最大值&&位置||最小值&&位置

    代码如下：

    package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:50:41
 */
public class Test5 {
    public static void main(String[] args) {
        //定义长度为5的数组，并赋值，找出数组的最大值，最小值，最大值的位置，最小值的位置
        int[] nums = {9,1,7,10,6};
        //10:1  1:3
        //int max=nums[0]; //默认认为0的位置存储的是最大值
        int maxPos=0; //默认认为0的位置存储的是最大值位置
        //int min=nums[0];//默认认为0的位置存储的是最小值
        int minPos=0;//默认认为0的位置存储的是最小值位置

        //让数组元素依次相比
        for (int i=1;i<nums.length;i++){
            //比较最大值
            if(nums[maxPos]<nums[i]){
                maxPos=i; //存储最大值的位置
            }

            if(nums[minPos]>nums[i]){
                minPos = i; //存储最小值位置
            }
        }

        System.out.println("max:"+nums[maxPos]+" min:"+nums[minPos]);
        System.out.println("maxPos:"+maxPos+" minPos:"+minPos);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    运行结果如下：
    在这里插入图片描述

    4.冒泡排序->选择排序

    代码如下：
    冒泡排序：

    package com.yzh7.test3;

/**
 * @author: hy
 * @create: 2022-06-30 11:12:14
 */
public class Test {
    public static void main(String[] args) {
        //N元数组冒泡序，两两相比小前移，外层循环从1始，内层循环减i去
        int[] nums = {40,20,50,30,10};
        //外层控制轮数
        for (int i=1;i<nums.length;i++){
            //内层控制比较次数
            for (int j=0;j<nums.length-i;j++){
                //前后相比
                if(nums[j]>nums[j+1]){
                    //比较换位
                    int temp = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }

        for (int i :nums){
            System.out.println(i);
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    选择排序：

    package com.yzh7.test3;

import java.util.Arrays;

/**
 * @author: hy
 * @create: 2022-06-30 11:15:18
 */
public class Test2 {
    public static void main(String[] args) {
        //选择排序:选择本轮中最小值，与开始位置的数换位，每轮最多换位一次，但是会比较若干次
        int[] nums = {40,20,50,30,10};
        //外层循环控制轮数，同时i表示，每一轮的开始位置
        for (int i=0;i<nums.length-1;i++){
            //k用于记录最小值位置的
            //k=i，假设这一轮的开始位置是最小值
            int k = i;
            //开始本轮比较，找到真的最小值位置
            for(int j=i+1;j<nums.length;j++){
                //比较获取最小值的位置
                if(nums[k]>nums[j]){
                    //k记录当前最小值的位置
                    k=j;
                }
            }
            //循环之后，找到了这一轮中的最小值位置k
            System.out.println("本轮中的最小值位置:"+k);

            //最小值位置上的数与开始位置换位
            if(k!=i){
                int temp = nums[k];
                nums[k]=nums[i];
                nums[i]=temp;
            }
        }

        /*for(int i: nums){
            System.out.println(i);
        }*/

        //Arrays.toString(nums):将数组元素拼接成字符串
        System.out.println(Arrays.toString(nums));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    package com.yzh70630;

import java.util.Arrays;

/**
 * @author: XYT
 * @create-date: 2022/6/30 11:32
 */
public class PaiXu {
    public static void main(String[] args) {
        int[] nums = {40,20,50,30,10};

        for (int i = 0; i < nums.length-1; i++) {
            int minp=i;
            for (int j = i+1; j < nums.length; j++) {
                if(nums[minp]>nums[j]){
                    //nums[minp]=nums[j]; //注意 这里不能赋值 赋值的话意味着交换顺序 这里只需要得到最小值的下标索引
                    minp=j;
                }

            }
            System.out.println("第"+(i+1)+"轮最小值是"+nums[minp]);

            if(nums[minp]!=nums[i]){
                int temp=nums[minp];
                nums[minp]=nums[i];
                nums[i]=temp;
            }
        }
        System.out.println(Arrays.toString(nums));
        
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    运行结果如下：
    在这里插入图片描述

    5.数组的扩容

    代码如下：

    package com.yzh7.test3;

import java.util.Arrays;

/**
 * @author: hy
 * @create: 2022-06-30 11:43:25
 */
public class Test3 {
    public static void main(String[] args) {
        int[] nums = {39,48,12,5,44};
        //排序
        //Arrays.sort(nums);

        //打印输出
        //System.out.println(Arrays.toString(nums));

        //扩容
        //1.创建一个指定长度的新数组
        //2.将原有数组的内容，按对应位置复制到新数组中
        int[] mynums = Arrays.copyOf(nums,3);
        System.out.println(mynums.length);
        System.out.println(Arrays.toString(mynums));
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    不是新添加数组
    而是新建立了一个数组，初始值为0，将原来数组的数据搬过来
    在这里插入图片描述

    6.对象数组

    代码如下：
    创建学生对象数组方法：

    package com.yzh7.test4;

/**
 * @author: hy
 * @create: 2022-06-30 11:50:58
 */
public class Student {
    String name;
    int age;

    public Student(){}

    //fn+(alt+insert) ->constructor 生成构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void instroduce(){
        System.out.println(this.name+" "+this.age);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述
    在这里插入图片描述

    调用学生对象数组：

    package com.yzh7.test4;

/**
 * @author: hy
 * @create: 2022-06-30 11:52:44
 */
public class Test {
    public static void main(String[] args) {
        /*int[] nums = {3,4,5,6};
        Student[] stus = {
            new Student("张三",10),
            new Student("李四",20)
        };

        //访问对象数组中，下标为0的元素的姓名
        System.out.println(stus[0].name);
        //访问对象数组中，下标为0的元素的年龄
        System.out.println(stus[0].age);

        //访问对象数组中，下标为0的元素的自我介绍方法
        stus[0].instroduce();
        //访问对象数组中，下标为1的元素的自我介绍方法
        stus[1].instroduce();*/

        Student[] stus = new Student[3];
        System.out.println(stus[0]);
        System.out.println(stus[1]);
        System.out.println(stus[2]);

        Student s1 = new Student("张三",10);
        stus[0] = s1;
        stus[1] = new Student("李四",20);
        stus[2] = new Student("王五",18);

        for (int i=0;i<stus.length;i++){
            //将当前数组元素，存储到学生变量中
            Student s = stus[i];
            System.out.println(s.name+" "+s.age);

        }

        System.out.println("==============");
        for (Student s : stus){
            s.instroduce();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    package com.yzh7.test4;

import javafx.scene.transform.Scale;

import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 11:59:42
 */
public class Test2 {
    public static void main(String[] args) {
        //学生对象数组，长度为10
        Student[] stus = new Student[10];
        //实际存储的学生对象0
        int count = 0;

        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请选择:1.添加学生 2.修改学生 3.删除学生 4.查询学生 5.退出");
            int choose = scanner.nextInt();
            switch (choose){
                case 1:
                    System.out.println("请输入要添加的姓名：");
                    String name= scanner.next();
                    System.out.println("请输入要添加的年龄：");
                    int age = scanner.nextInt();
                    Student s = new Student(name,age);
                    //学生存储到指定位置
                    stus[count] = s;
                    //学生数量加1
                    count++;
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    System.out.println("编号\t姓名\t年龄");
                    for (int i=0;i<count;i++){
                        System.out.print(i+1);
                        System.out.print("\t");
                        System.out.print(stus[i].name);
                        System.out.print("\t");
                        System.out.print(stus[i].age);
                        System.out.print("\n");
                    }
                    break;
                case 5:
                    System.out.println("退出");
                    return;
                default:
                    System.out.println("选错了");
                    break;
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
  • 相关阅读:
    ctfshow web入门 php特性 web136-web140
    MapReduce（二）
    Rust编程基础核心之所有权(下)
    Linux安装mysql数据库并实现主从搭建
    Redis实现Session持久化
    第五篇 《随机点名答题系统》——抽点答题详解（类抽奖系统、在线答题系统、线上答题系统、在线点名系统、线上点名系统、在线考试系统、线上考试系统）
    FPGA学习笔记——知识点总结
    Java工具类--http请求-post
    umi中如何实现路由缓存
    【Matlab BP回归预测】GA优化BP回归预测（含优化前的对比）【含源码 1901期】
  • 原文地址：https://blog.csdn.net/Liu_wen_wen/article/details/125539665