精华内容
下载资源
问答
  • 3.酒店中的每一个房间作为一个java对象 4.每一个房间应该有:房间号、房间类型、是否空闲 5.系统对外提供的功能:订房间、退房间、查看所有房间状态 代码实例 创建Room类 public class Room { /* 101 102 103 ... ...

    题目

    创建一个酒店管理系统,模拟退房,订房,打印所有房间信息

    要求

    1.系统用户:酒店前台
    2.酒店使用一个二维数组来模拟
    3.酒店中的每一个房间作为一个java对象
    4.每一个房间应该有:房间号、房间类型、是否空闲
    5.系统对外提供的功能:订房间、退房间、查看所有房间状态

    代码实例

    创建Room类

    public class Room {
        /*
        101 102 103 ...
        201 202 203 ...
        ...
        */
        private int num;//房间号
        private String size;//房间款式
        private boolean use;//是否有空房
    
        public Room() {
        }
    
        public Room(int num, String size, boolean use) {
            this.num = num;
            this.size = size;
            this.use = use;
        }
    
        public int getNum() {
            return num;
        }
    
    //setter and getter
        public void setNum(int num) {
            this.num = num;
        }
    
        public String getSize() {
            return size;
        }
    
        public void setSize(String size) {
            this.size = size;
        }
    
        public boolean getUse() {
            return use;
        }
    
        public void setUse(boolean use) {
            this.use = use;
        }
    
    //重写equals()、toString()方法
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Room room = (Room) o;
            return num == room.num;
        }
    
        @Override
        public String toString() {
            return "房间号:" + num+
                    ",类型:" + size+
                    (use?",占用":",空闲");
        }
    }
    

    创建Hotel类
    其中有:订房、退房、打印所有房间状态 三个方法

    public class Hotel {
        //模拟酒店是个二维数组表示各个房间
        //开辟一个二维数组
        private Room[][] rooms;
    
        public Hotel() {
            //三层 每层10个房间
            //设定二维数组的容量
            rooms=new Room[3][10];
            //创建3*10个房间
            //为每个元素new一个room对象
            for (int i = 0; i < rooms.length; i++) {//i是下标(i+1是楼层)
                for (int j = 0; j < rooms[i].length; j++) {//j是下标 (j+1是每层房间号)
                    if(i==0)
                        rooms[i][j]=new Room((i+1)*100+(j+1),"单人间",false);
                    else if(i==1)
                        rooms[i][j]=new Room((i+1)*100+(j+1),"标准间",false);
                    else if(i==2)
                        rooms[i][j]=new Room((i+1)*100+(j+1),"豪华间",false);
                }
            }
        }
    
        public Room[][] getRooms() {
            return rooms;
        }
    
        public void setRooms(Room[][] rooms) {
            this.rooms = rooms;
        }
    
        //提供一个 打印房间列表的方法
        public void print(){
            for (int i = 0; i < rooms.length; i++) {//i是下标(i+1是楼层)
                for (int j = 0; j < rooms[i].length; j++) {
                    Room room=rooms[i][j];
                    System.out.println(room.toString());
                }
                System.out.println();//每打印完一行后换行
            }
        }
        //提供一个 订房方法
        //主要是将房间的对象的use改为true(已入住)
        public void order(int roomNum){
            //假设房间为207---->下表为room[1][6]
            Room room=rooms[roomNum/100-1][roomNum%100-1];
            room.setUse(true);//改为true显示占用
        }
        //提供一个 退房方法
        public void exit(int roomNum){
            //假设房间为207---->下表为room[1][6]
            Room room=rooms[roomNum/100-1][roomNum%100-1];
            room.setUse(false);//改为false显示空闲
        }
    }
    

    测试类

    import java.util.Scanner;
    public class Test {
        public static void main(String[] args) {
            Hotel hotel=new Hotel();
            System.out.println("欢迎使用酒店管理系统");
            System.out.println("[1]表示查看房间列表。");
            System.out.println("[2]表示订房。");
            System.out.println("[3]表示退房");
            System.out.println("[0]表示退出系统");
            Scanner s=new Scanner(System.in);
    
            while (true) {
                System.out.println("请输入对应功能编号:");
                int i = s.nextInt();
                if (i == 1) {
                    //查看房间列表
                    hotel.print();
                    System.out.println("请选择需要的服务:");
                    System.out.println("[2]表示订房。");
                    System.out.println("[3]表示退房");
                    System.out.println("[0]表示退出系统");
                } else if (i == 2) {
                    //订房
                    System.out.println("请输入订房编号:");
                    int roomNum = s.nextInt();
                    hotel.order(roomNum);
                    System.out.println("已订房:" + roomNum);
    
                } else if (i == 3) {
                    //退房
                    System.out.println("请输入订房编号:");
                    int roomNum = s.nextInt();
                    hotel.exit(roomNum);
                    System.out.println("已退房:" + roomNum);
    
                } else if (i == 0) {
                    System.out.println("谢谢使用");
                    return;
                } else {
                    System.out.println("输入有误,请重新输入");
                }
            }
        }
    }
    
    

    测试结果

    欢迎使用酒店管理系统
    [1]表示查看房间列表。
    [2]表示订房。
    [3]表示退房
    [0]表示退出系统
    请输入对应功能编号:
    1
    房间号:101,类型:单人间,空闲
    房间号:102,类型:单人间,空闲
    房间号:103,类型:单人间,空闲
    房间号:104,类型:单人间,空闲
    房间号:105,类型:单人间,空闲
    房间号:106,类型:单人间,空闲
    房间号:107,类型:单人间,空闲
    房间号:108,类型:单人间,空闲
    房间号:109,类型:单人间,空闲
    房间号:110,类型:单人间,空闲
    
    房间号:201,类型:标准间,空闲
    房间号:202,类型:标准间,空闲
    房间号:203,类型:标准间,空闲
    房间号:204,类型:标准间,空闲
    房间号:205,类型:标准间,空闲
    房间号:206,类型:标准间,空闲
    房间号:207,类型:标准间,空闲
    房间号:208,类型:标准间,空闲
    房间号:209,类型:标准间,空闲
    房间号:210,类型:标准间,空闲
    
    房间号:301,类型:豪华间,空闲
    房间号:302,类型:豪华间,空闲
    房间号:303,类型:豪华间,空闲
    房间号:304,类型:豪华间,空闲
    房间号:305,类型:豪华间,空闲
    房间号:306,类型:豪华间,空闲
    房间号:307,类型:豪华间,空闲
    房间号:308,类型:豪华间,空闲
    房间号:309,类型:豪华间,空闲
    房间号:310,类型:豪华间,空闲
    
    请选择需要的服务:
    [2]表示订房。
    [3]表示退房
    [0]表示退出系统
    请输入对应功能编号:
    2
    请输入订房编号:
    101
    已订房:101
    请输入对应功能编号:
    1
    房间号:101,类型:单人间,占用
    房间号:102,类型:单人间,空闲
    房间号:103,类型:单人间,空闲
    房间号:104,类型:单人间,空闲
    房间号:105,类型:单人间,空闲
    房间号:106,类型:单人间,空闲
    房间号:107,类型:单人间,空闲
    房间号:108,类型:单人间,空闲
    房间号:109,类型:单人间,空闲
    房间号:110,类型:单人间,空闲
    
    房间号:201,类型:标准间,空闲
    房间号:202,类型:标准间,空闲
    房间号:203,类型:标准间,空闲
    房间号:204,类型:标准间,空闲
    房间号:205,类型:标准间,空闲
    房间号:206,类型:标准间,空闲
    房间号:207,类型:标准间,空闲
    房间号:208,类型:标准间,空闲
    房间号:209,类型:标准间,空闲
    房间号:210,类型:标准间,空闲
    
    房间号:301,类型:豪华间,空闲
    房间号:302,类型:豪华间,空闲
    房间号:303,类型:豪华间,空闲
    房间号:304,类型:豪华间,空闲
    房间号:305,类型:豪华间,空闲
    房间号:306,类型:豪华间,空闲
    房间号:307,类型:豪华间,空闲
    房间号:308,类型:豪华间,空闲
    房间号:309,类型:豪华间,空闲
    房间号:310,类型:豪华间,空闲
    
    请选择需要的服务:
    [2]表示订房。
    [3]表示退房
    [0]表示退出系统
    请输入对应功能编号:
    0
    谢谢使用
    
    展开全文
  • //运用数组打印输出10-50 public static void main(String[] args) { int[] arr = new int[5]; // 有效下标是0~长度-1 arr[0] = 10; arr[1] = 20; arr[2] = 30; arr[3] = 40; arr[4] = 50;
    public class ArrayTest {
    	//运用数组打印输出10-50
    	public static void main(String[] args) {
    		int[] arr = new int[5]; // 有效下标是0~长度-1 
    		arr[0] = 10;
    		arr[1] = 20;
    		arr[2] = 30;
    		arr[3] = 40;
    		arr[4] = 50;
    		//arr[5] = 60; 下标不可以越界
    		//arr[-1] = 5;
    		for (int i = 0; i < 5; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    }
    
    class ArrayTest2 {
    	//运用数组打印输出10-50
    	public static void main(String[] args) {
    		int[] arr = new int[5]; // 有效下标是0~长度-1 
    		for (int i = 0; i < 5; i++) { // 数组和循环是在一起
    			// 0~4
    			arr[i] = (i + 1) * 10;
    		}	
    		// 数组的遍历(迭代)
    		for (int i = 0; i < 5; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    }
    
    class Exer1 {
    	public static void main(String[] args) {
    		// 创建一个数组, 保存10个奇数, 遍历数组打印输出
    		int[] arr = new int[10];
    		for (int i = 0; i < 10; i++) {
    			arr[i] = 2 * i + 1;
    		}
    		// 遍历数组
    		for (int i = 0; i < 10; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    }
    
    class ArrayTest3 {
    //打印10 20 30 40 50
    	public static void main(String[] args) {
    		int[] arr = new int[5]; // 数组对象一旦创建,长度就是固定的,不可改变
    		System.out.println("数组长度:" + arr.length);
    		//arr.length = 10; arr.length是一个常量, 固定不变
    		
    		for (int i = 0; i < arr.length; i++) { // 数组和循环是在一起
    			// 0~4
    			arr[i] = (i + 1) * 10;
    		}		
    		// 数组的遍历(迭代)
    		for (int i = 0; i < arr.length; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    }
    
    class ArrayTest4 {
    //打印A-Z 26个英文字母
    	public static void main(String[] args) {
    		char[] chArr = new char[26];
    		for (int i = 0; i < chArr.length; i++) {
    			chArr[i] = (char)('A' + i);
    		}
    		// 遍历
    		for (int i = 0; i < chArr.length; i++) {
    			System.out.print(chArr[i] + " ");
    		}
    		System.out.println();
    	}
    }
    
    class Exer2 {
    	// 创建6个元素的数组, 保存你的生日和今天的日期,最后打印输出.
    	public static void main(String[] args) {
    		int[] arr = new int[6]; // 1994-1-23 2016-7-27
    		arr[3] = 1994; 
    		arr[4] = 1;
    		arr[5] = 23;
    		arr[0] = 2016;
    		arr[1] = 7;
    		arr[2] = 27;
    		System.out.println("生日:" + arr[3] + "年" + arr[4] + "月" + arr[5] + "日");
    		System.out.println("今天:" + arr[0] + "年" + arr[1] + "月" + arr[2] + "日");
    	}
    }
    
    class Exer3 {
    	// 创建26个元素的字符数组, 保存26个小写字母, 遍历打印输出
    	public static void main(String[] args) {
    		char[] chArr = new char[26];
    		for (int i = 0; i < chArr.length; i++) {
    			chArr[i] = (char)('a' + i);
    		}
    		// 遍历
    		for (int i = 0; i < chArr.length; i++) {
    			System.out.print(chArr[i] + " ");
    		}
    		System.out.println();
    	}
    }
    
    class Exer4 {
    	// 创建36个元素的字符数组, 前26个保存小写字母,后10个保存10个数字字符
    	public static void main(String[] args) {
    		char[] chArr = new char[36];
    		for (int i = 0; i < 26; i++) {
    			chArr[i] = (char)('a' + i);
    		}
    		for (int i = 26; i < chArr.length; i++) {
    			chArr[i] = (char)('0' + i - 26);
    		}
    		// 遍历
    		for (int i = 0; i < chArr.length; i++) {
    			System.out.print(chArr[i] + " ");
    		}
    		System.out.println();
    	}
    }
    
    class Exer42 {
    	// 创建36个元素的字符数组, 前26个保存小写字母,后10个保存10个数字字符
    	public static void main(String[] args) {
    		char[] chArr = new char[36];
    		for (int i = 0; i < 26; i++) {
    			chArr[i] = (char)('a' + i);
    		}
    		for (int i = 0; i < 10; i++) {
    			chArr[26 + i] = (char)('0' + i);
    		}
    		// 遍历
    		for (int i = 0; i < chArr.length; i++) {
    			System.out.print(chArr[i] + " ");
    		}
    		System.out.println();
    	}
    }
    
    class ArrayTest5 {
    	//静态初始化的练习
    	public static void main(String[] args) {
    		int[] arr1 = new int[]{9, 2, 1, 3, 8}; // 静态初始化, 比较灵活, 声明和初始化可以分开
    		int[] arr2 = {1, 2, 0, 9, 3}; // 写法固定, 只适用于数组的声明和创建在同一行.
    		int[] arr3;
    		//arr3 = {3, 4, 5};
    		arr3 = new int[]{3, 4, 5};	
    	}
    }
    
    class ArrayTest6 {
    	public static void main(String[] args) {
    		// 创建引用数组, 数组元素中只能保存地址, 但是地址可以指向对象, 所以也可以称为对象数组
    		MyDate[] arr = new MyDate[5]; // 此时并没有MyDate对象产生, 数组中都是空洞
    		arr[0] = new MyDate(1980, 1, 1);
    		arr[4] = new MyDate(2011, 5, 8);
    		arr[1] = new MyDate(1990, 2, 2);
    		arr[3] = new MyDate(2008, 8, 8);
    		arr[2] = new MyDate(1999, 9, 9);
    		for (int i = 0; i < arr.length; i++) { // 如果数组中有空洞, 就是抛出空指针异常
    			System.out.println(arr[i].say());
    		}	
    	}
    }
    
    class ArrayTest7 {
    	//字符串数组的创建
    	public static void main(String[] args) {
    		String[] strArr = {"aaa", "yyy", "bbb", "xxx", "qqq"};
    		for (int i = 0; i < strArr.length; i++) {
    			System.out.println(strArr[i]);
    		}
    	}
    }
    
    class ArrayTest8 {
    	//main方法中用字符串数组做参数
    // 命令行参数的用法
    	public static void main(String[] args) { // 命令行参数的用法
    		for (int i = 0; i < args.length; i++) {
    			System.out.println(args[i]);
    		}	
    	}
    }
    
    class Exer5 {
    	// 从命令行接收8个分数值, 打印分数的等级,如果分数值大于80,打印良, 小于60打印不及格, 其他打印其他 
    	public static void main(String[] args) {
    			for (int i = 0; i < args.length; i++) {
    			int score = Integer.parseInt(args[i]);
    			if (score > 80) {
    				System.out.println(score + " : 良");
    			} else if (score < 60) {
    				System.out.println(score + " : 不及格");
    			} else {
    				System.out.println(score + " : 其他");
    			}
    		}
    	}
    }
    class ArrayTest10 {
    	//创建MyDate类型的对象date1,其参数由命令行参数获取
    	public static void main(String[] args) { // 命令行参数的用法
    		MyDate date1 = new MyDate(	Integer.parseInt(args[0]), 
    									Integer.parseInt(args[1]), 
    									Integer.parseInt(args[2]));
    		System.out.println(date1.say());
    	}
    }
    //MyDate 类的定义
    class MyDate {
    	int year;
    	int month;
    	int day;
    //全参构造器
    	public MyDate(int year, int month, int day) {
    		this.year = year;
    		this.month = month;
    		this.day = day;
    	}
    	public String say() {
    		return year + "年" + month + "月" + day + "日";
    	}
    }
    
    class Exer6 {
    	// 生成5个[10~30)的随机整数
    	public static void main(String[] args) {
    		for (int i = 0; i < 5; i++) {
    			int rand = (int)(Math.random() * 20 + 10);
    			System.out.println(rand);
    		}
    	}
    }
    
    class ArrayTest11 {
    	//生成[0~1)、[0~101)、[0~50)的随机小数
    	public static void main(String[] args) {
    		double rand1 = Math.random(); // 生成一个随机小数[0~1)
    		System.out.println(rand1);
    		double rand2 = Math.random() * 101; // 生成一个随机小数[0~101)
    		System.out.println(rand2);
    		int rand3 = (int)(Math.random() * 50); // 生成一个随机整数[0~50)
    		System.out.println(rand3);
    	}
    }
    
    class ArrayTest12 {
    	//创建一个8个元素的数组,每个元素被[1-20)的随机数赋值,并遍历打印、求和、平均值、最大值并打印
    	public static void main(String[] args) {
    		int[] arr = new int[8];
    		for (int i = 0; i < arr.length; i++) {
    			arr[i] = (int)(Math.random() * 20);
    		}
    		// 遍历
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + " ");
    		}
    		System.out.println();
    		// 求和
    		int sum = 0;
    		for (int i = 0; i < arr.length; i++) {
    			sum += arr[i];
    		}
    		System.out.println("sum:" + sum);
    		// 求平均值
    		int avg = sum / arr.length;
    		System.out.println("avg:" + avg);
    		// 找最大值
    		int max = arr[0]; // 先假定第一个数是最大值
    		for (int i = 0; i < arr.length; i++) {
    			if (arr[i] > max) { // 从数列中遍历每个数,都和max作比较, 如果某个数比max还大, 你就是max
    				max = arr[i];
    			}
    		}
    		System.out.println("max:" + max);
    		System.out.println();
    	}
    }
    
    

    展开全文
  • (1)定义类Pritimive,在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。 */ public class Primtive { private boolean[] t = new boolean[3]; public Primtive() { } ...
    /*
    (1)定义类Pritimive,在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。
       
    */
    public class Primtive {
    	
    	private boolean[] t = new boolean[3];
    	
    	public Primtive() {
    		
    	}
    	
    	public Primtive(boolean[] t) {
    		this.t = t;
    	}
    	
    	public void setT(boolean[] t) {
    		this.t = t;
    	}
    	
    	public boolean[] getT() {
    		return t;
    	}
    	
    	public String say() {
    		return "布尔数组:" + t;
    	}
    	
    }
    
    /*定义类Array1,在Array1的main()方法中创建Pritimive对象d,输出其成员变量t的三个元素值。
      练习目的:检验基本数据类型数组创建时的自动赋值。
       (2)给对象d的成员变量t赋值为{true,true,true},并输出t的三个元素值。
    */
    public class Array1 {
    	
    	public static void main(String[] args) {
    		//创建Pritimive对象d
    		Pritimive d = new Pritimive();
    		//调用say()方法并打印
    		System.out.println(d.say());
    		
    		//对象d的成员变量t赋值为{true
    		d.setT0(true);
    		d.setT1(true);
    		d.setT2(true);
    		//调用say()方法并打印
    		System.out.println(d.say());
    	}
    }<pre name="code" class="html">public class StudentTest {
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		
    		for (int i = 0; i < stuArr.length; i++) {
    			System.out.println(stuArr[i].say());
    		}
    		System.out.println("----------------------------------");
    		// 2) 遍历数组时, 只打印3年级的学生的信息
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				System.out.println(stuArr[i].say());
    			}
    		}
    		System.out.println("----------------------------------");
    		// 3) 求学生的平均分数..
    		double sum = 0;
    		for (int i = 0; i < stuArr.length; i++) {
    			sum += stuArr[i].getScore();
    		}
    		double avg = sum / stuArr.length;
    		System.out.println("平均分:" + avg);
    		// 4) 找出学生中的最高分和最低分.
    		double max = stuArr[0].getScore();
    		double min = max;
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getScore() > max) {
    				max = stuArr[i].getScore();
    			}
    			if (stuArr[i].getScore() < min) {
    				min = stuArr[i].getScore();
    			}
    		}
    		System.out.println("最高分:" + max + ",最低分:" + min);
    		System.out.println("----------------------------------");
    		Student maxScoreStudent = stuArr[0]; // 先假定第一位同学就是持有最高分的同学
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getScore() > maxScoreStudent.getScore()) { // 如果某同学分数比最高分同学的分数还高, 刷新最高分同学
    				maxScoreStudent = stuArr[i];
    			}
    		}
    		System.out.println("最高分同学:" + maxScoreStudent.say());
    		Student minScoreStudent = stuArr[0]; 
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getScore() < minScoreStudent.getScore()) {
    				minScoreStudent = stuArr[i];
    			}
    		}
    		System.out.println("最低分同学:" + minScoreStudent.say());
    	}
    }
    class StudentTest2 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		int maxScoreStudentIndex = 0;
    		int minScoreStudentIndex = 0;
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getScore() > stuArr[maxScoreStudentIndex].getScore()) {
    				maxScoreStudentIndex = i;
    			}
    			if (stuArr[i].getScore() < stuArr[minScoreStudentIndex].getScore()) {
    				minScoreStudentIndex = i;
    			}
    		}
    		System.out.println("最高分:" + stuArr[maxScoreStudentIndex].say());
    		System.out.println("最低分:" + stuArr[minScoreStudentIndex].say());	
    	}
    }
    class StudentTest3 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[30];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("------------------------------------");
    		// 找出三年级的最高分,最低分
    		double maxScore = -1; // 或者double值最小值
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				if (stuArr[i].getScore() > maxScore) {
    					maxScore = stuArr[i].getScore();
    				}
    			}
    		}
    		if (maxScore == -1) {
    			System.out.println("没有三年级同学!!");
    		} else {
    			System.out.println("三年级最高分:" + maxScore);
    		}
    		
    		double minScore = 101;
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				if (stuArr[i].getScore() < minScore) {
    					minScore = stuArr[i].getScore();
    				}
    			}
    		}
    		if (minScore == 101) {
    			System.out.println("没有三年级同学");
    		} else {
    			System.out.println("三年级最低分:" + minScore);
    		}
    		
    		// 找出三年级的最高分的同学和最低分的同学
    		Student maxScoreOf3 = null;
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				if (maxScoreOf3 == null) {
    					maxScoreOf3 = stuArr[i];
    				} else if (stuArr[i].getScore() > maxScoreOf3.getScore()) {
    					maxScoreOf3 = stuArr[i];
    				}
    			}
    		}
    		if (maxScoreOf3 == null) {
    			System.out.println("没有三年级同学");
    		} else {
    			System.out.println("三年级最高分:" + maxScoreOf3.say());
    		}
    		
    		Student minScoreOf3 = null;
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				if (minScoreOf3 == null) {
    					minScoreOf3 = stuArr[i];
    				} else if (stuArr[i].getScore() < minScoreOf3.getScore()) {
    					minScoreOf3 = stuArr[i];
    				}
    			}
    		}
    		if (minScoreOf3 == null) {
    			System.out.println("没有三年级同学");
    		} else {
    			System.out.println("三年级最低分:" + minScoreOf3.say());
    		}
    		
    		// 求三年级的平均分
    		double sumOf3 = 0;
    		int count = 0;
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				sumOf3 += stuArr[i].getScore();
    				count++;
    			}
    		}
    		if (count == 0) {
    			System.out.println("没有三年级同学");
    		} else {
    			double avgOf3 = sumOf3 / count;
    			System.out.println("三年级平均分:" + avgOf3);
    		}
    	}
    }
    class StudentTest4 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("--------------数组复制完成------------------");
    		// 数组复制
    		// 1) 创建新数组, 长度和老数组一样
    		Student[] newArr = new Student[stuArr.length];
    		// 2) 遍历老数组, 把老数组中的每一个元素的值赋值于新数组的相应的位置
    		for (int i = 0; i < stuArr.length; i++) {
    			newArr[i] = stuArr[i];
    		}
    		// 遍历 
    		for (Student stu : newArr) {
    			System.out.println(stu.say());
    		}
    	}
    }
    class StudentTest5 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("--------------获取子数组完成------------------");
    		// 1) 创建新数组, 容量是原来的一半
    		Student[] childArr = new Student[stuArr.length / 2];
    		// 2) 遍历老数组, 把老数组中的每一个元素的值赋值于新数组的相应的位置
    		for (int i = 0; i < childArr.length; i++) {
    			childArr[i] = stuArr[i];
    		}
    		// 遍历 
    		for (Student stu : childArr) {
    			System.out.println(stu.say());
    		}
    	}
    }
    class StudentTest6 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("--------------数组扩容完成------------------");
    		// 1) 创建一个容量是老数组容量两倍的新数组
    		Student[] bigger = new Student[stuArr.length * 2];
    		// 2) 循环依次把老数组中的所有有效元素赋值于新数组的相应位置
    		for (int i = 0; i < stuArr.length; i++) {
    			bigger[i] = stuArr[i];
    		}
    		stuArr = bigger; // 让老数组引用指向新的大数组对象
    		// 遍历 
    		for (Student stu : stuArr) {
    			if (stu != null) { // 防止空指针异常!!
    				System.out.println(stu.say());
    			} else {
    				System.out.println(stu);
    			}
    		}
    		// 获取容量是原来1/3的子数组 
    		// 扩容1.5倍
    		Student[] bigger2 = new Student[(int)(stuArr.length * 1.5)];
    	}
    }
    class StudentTest7 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("--------------所有3年级列表------------------");
    		// 1) 要创建一个容量和老数组一样的新数组
    		Student[] newArr = new Student[stuArr.length];
    		// 2) 声明一个int型count变量
    		int count = 0;
    		// 3) 遍历老数组, 如果找到3年级同学, 把3年级同学保存在新数组中,下标就是count, 保存完毕后count++, count可以作为计数器来使用
    		for (int i = 0; i < stuArr.length; i++) {
    			if (stuArr[i].getGrade() == 3) {
    				newArr[count] = stuArr[i];
    				count++;
    			}
    		}
    		// 4) 创建容量为count的最终数组
    		Student[] finalArr = new Student[count];
    		// 5) 依次把count个新数组中的元素复制到最终数组中
    		for (int i = 0; i < count; i++) {
    			finalArr[i] = newArr[i];
    		}
    		// 遍历 
    		for (Student stu : finalArr) {
    			System.out.println(stu.say());
    		}
    	}
    }
    class StudentTest8 {
    	
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("--------------反转------------------");
    		for (int i = 0; i < stuArr.length / 2; i++) {
    			// 交换i位置和arr.length - 1 - i位置的元素
    			Student tmp = stuArr[i];
    			stuArr[i] = stuArr[stuArr.length - 1 - i];
    			stuArr[stuArr.length - 1 - i] = tmp;
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    	}
    }
    
    class StudentTest9 {
    
    	public static void main(String[] args) {
    		// 1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,年级和分数都是随机生成
    		//   遍历这个数组,打印每个对象的信息
    		String[] name1 = {"张", "李", "赵", "徐", "贾"};
    		String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
    		Student[] stuArr = new Student[20];
    		for (int i = 0; i < stuArr.length; i++) {
    			int id = i + 1;
    			int randIndex1 = (int)(Math.random() * name1.length);
    			int randIndex2 = (int)(Math.random() * name2.length);
    			String name = name1[randIndex1] + name2[randIndex2];
    			int grade = (int)(Math.random() * 6 + 1);
    			double score = (int)(Math.random() * 101);
    					
    			//public Student(int id, String name, int grade, double score) {
    			stuArr[i] = new Student(id, name, grade, score);
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    		System.out.println("--------------排序-----------------");
    		
    		for (int i = 0; i < stuArr.length - 1; i++) {
    			for (int j = 0; j < stuArr.length - 1 - i; j++) {
    				// j和j+1位置
    				if (stuArr[j].getScore() < stuArr[j + 1].getScore()) {
    					Student tmp = stuArr[j];
    					stuArr[j] = stuArr[j + 1];
    					stuArr[j + 1] = tmp;
    				}
    			}
    		}
    		// 遍历 
    		for (Student stu : stuArr) {
    			System.out.println(stu.say());
    		}
    	}
    }	
    	
    

    展开全文
  • import java.util.Arrays; import java.util.Scanner;... 写一个函数,计算一个整数数组的平均值 // public static void main(String[] args) { // int[] arr = { 1, 2, 3, 4, 5 }; // getAvg(arr); // }...
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class Demo05 {
    	//3. 写一个函数,计算一个整数数组的平均值
    //	public static void main(String[] args) {
    //		int[] arr = { 1, 2, 3, 4, 5 };
    //		getAvg(arr);
    //	}
    //	public static void getAvg(int[] arr) {
    //		int sum = 0;
    //		int avg = 0;
    //		for(int i=0; i<arr.length; i++) {
    //			System.out.print(arr[i] + "\t");
    //			sum += arr[i];
    //		}
    //		System.out.println("\n和为:" + sum);
    //		avg = sum / arr.length;
    //		System.out.println("平均数为:" + avg);
    //	}
    	
    	
    	//4. 自定义一个整数数组 a,读入一个整数 n,如果 n 在数组中存在,则输出 n 的下标;如果 不存在,则输出-1。
    //	public static void main(String[] args) {
    //		int[] a = { 1, 2, 3, 4, 5 };
    //		System.out.print("请输入一个整数:");
    //		Scanner sc = new Scanner(System.in);
    //		int n = sc.nextInt();
    //		boolean flag = false;
    //		for(int i=0; i<a.length; i++) {
    //			if(n == a[i]) {
    //				System.out.println("存在" + n + "下标为:" + i);
    //				flag = true;
    //				break;
    //			}
    //		}
    //		if(!flag) {
    //			System.out.println("不存在" + n + "下标为:-1");
    //		}
    //	}
    	
    	
    	//5. 给定一个数组,输出数组中的最大值和最小值 
    //	public static void main(String[] args) {
    //		int[] a = { 11, 22, 1, 2, 3, 4, 5 };
    //		int max = a[0];
    //		int min = a[0];
    //		for(int i=0; i<a.length; i++) {
    //			if(min > a[i]) {
    //				min = a[i];
    //			}
    //			if(max < a[i]) {
    //				max = a[i];
    //			}
    //		}
    //		System.out.println("最小值为:" + min);
    //		System.out.println("最大值为:" + max);
    //	}
    	
    	
    	//6. 已知一个二维数组 A 表示一个矩阵,求 AT。 其中,AT 表示矩阵的转置。矩阵转置的义:表示把一个矩阵行列互换
    //	public static void main(String[] args) {
    //		
    //	}
    	
    	
    	//7. *给定一个数组,把这个数组中所有元素顺序进行颠倒。
    //	public static void main(String[] args) {
    //		int[] a = { 11, 22, 1, 2, 3, 4, 5 };
    //		for (int i : a) {
    //			System.out.print(i + "  ");
    //		}
    //		System.out.println();
    //		for(int i=a.length-1; i>=0; i--) {
    //			System.out.print(a[i] + "  ");
    //		}
    //	}
    	
    	
    	//8. *数组的扩容。 给定一个数组,要求写一个 expand 函数,把原有数组的长度扩容一倍,并保留原有数 组原有的内容。
    	//例如,给定一个数组 int[] a = {1,2,3},则扩容之后,a 数组为:{1,2,3,0,0,0} 
    //	public static void main(String[] args) {
    //		 int[] a = {1,2,3};
    //		 for (int i : a) {
    //			 System.out.print(i + "  ");
    //		 }
    //		 System.out.println();
    //		 expend(a);
    //		 
    //	}
    //	
    //	public static void expend(int[] a) {
    //		a = Arrays.copyOf(a, a.length*2);
    		int[] newArray = new int[a.length * 2];   
    		System.arraycopy(a, 0, newArray, 0, a.length);   
    		a = newArray; 
    //		for (int i : a) {
    //			 System.out.print(i + "  ");
    //		 }
    //	}
    	
    	
    	//9. *数组的插入和删除 写两个函数,一个函数为 delete 函数,声明如下: public static void delete(int pos) 
    	//该函数表示删除数组 pos 位置上的元素。 
    	//第二个函数为 insert 函数,声明如下: public static void insert(int pos, int value) 
    	//该函数表示在数组 pos 位置上插入 value 值。
    //	public static void main(String[] args) {
    //		int[] a = {1,2,3,4,5};
    //		int pos = 2;
    //		int value = 8;
    //		System.out.println("原数组:");
    //		for (int i : a) {
    //			System.out.print(i + " ");
    //		}
    //		System.out.println();
    //		delete(a, pos);
    //		insert(a, pos, value);
    //	}
    //	public static void delete(int[] a, int pos) {
    //		int[] temp=new int[a.length-1];
    //		System.arraycopy(a, 0, temp, 0, pos);
    //		System.arraycopy(a, pos+1, temp, pos, temp.length-pos);
    //		a=temp;
    //		System.out.println("删除后:");
    //		for (int i : a) {
    //			System.out.print(i + " ");
    //		}
    //		System.out.println();
    //	} 
    //	public static void insert(int[] a, int pos, int value) {
    //		a = Arrays.copyOf(a, a.length+1);
    //		a[pos] = value;
    //		System.out.println("插入后:");
    //		for (int i : a) {
    //			System.out.print(i + " ");
    //		}
    //	}
    	
    	static int[] a = { 1, 3, 2, 5, 7 }; // 多个函数可以直接操作该数组 
    	static int index = a.length;
    	static int[] arr;
    
    	public static void main(String args[]) {
    		delete(2); // 1 3 5 7
    		insert(1, 4); // 1 4 3 5 7
    		insert(0, 6); // 6 1 4 3 5 7
    	}
    
    	public static void delete(int pos){ 
    		int[] temp=new int[a.length-1];
    		System.arraycopy(a, 0, temp, 0, pos);
    		System.arraycopy(a, pos+1, temp, pos, temp.length-pos);
    		a=temp;
    		System.out.println("删除后:");
    		for (int i : a) {
    			System.out.print(i + " ");
    		}
    		System.out.println(); 
    	}
    
    	public static void insert(int pos, int value){ 
    		if(index == a.length) {
    			a = Arrays.copyOf(a, a.length+1);
    			System.arraycopy(a, 0, arr, 0, index);
    		}else {
    			arr = a;
    		}
    		System.arraycopy(arr, pos+1, arr, pos, index-pos);
    		arr[pos] = value;
    		index++;
    		System.out.println("插入后:");
    		for (int i : arr) {
    			System.out.print(i + " ");
    		} 
    		System.out.println();
    	}
    }
    
    
    public class Worker {
    	private String name;
    	private int age;
    	private double salary;
    	private Address addr;
    	
    	public Worker(String name, int age, double salary, Address addr) {
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    		this.addr = addr;
    	}
    	public Address getAddr() {
    		return addr;
    	}
    	public void setAddr(Address addr) {
    		this.addr = addr;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public double getSalary() {
    		return salary;
    	}
    	public void setSalary(double salary) {
    		this.salary = salary;
    	}
    	
    	public Worker() {
    		System.out.println("无参构造");
    	}
    	public Worker(String name, int age, double salary) {
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    		System.out.println("有参构造");
    	}
    	
    	public void work() {
    		System.out.println("无参方法");
    	}
    	public void word(int hours) {
    		System.out.println("有参方法\t工作" + hours + "小时");
    	}
    	
    	
    }
    
    
    public class Address {
    	private String address;
    	private String zipCode;
    	
    	public Address() {
    	}
    	public Address(String address, String zipCode) {
    		this.address = address;
    		this.zipCode = zipCode;
    	}
    	public String getAddress() {
    		return address;
    	}
    	public void setAddress(String address) {
    		this.address = address;
    	}
    	public String getZipCode() {
    		return zipCode;
    	}
    	public void setZipCode(String zipCode) {
    		this.zipCode = zipCode;
    	}
    	
    	
    }
    
    
    public class Test {
    	public static void main(String[] args) {
    		Worker w1 = new Worker();
    		Worker w2 = new Worker("zhangsan",25,2500);
    		System.out.println("姓名:" + w2.getName() + ",年龄:" +w2.getAge() + ",薪资:" +w2.getSalary());
    		w1.work();
    		w1.word(12);
    		Address a = new Address();
    		a.setAddress("北京市海淀区清华园1号");
    		a.setZipCode("100084");
    		System.out.println("姓名:" + w2.getName() + ",年龄:" + w2.getAge() + ",工资:" + w2.getSalary()
    				+",家庭住址为:" + a.getAddress() + ",邮政编码为:" + a.getZipCode());
    	}
    }
    
    
    展开全文
  • 循环数组练习题 import java.util.Scanner; public class Demo01 { public static void main(String[] args) { //1.使用双重数组,输出数字三角形 // Scanner sc = new Scanner(System.in); // System.out....
  • 这两个练习题对我最大的挑战表面上是“构造方法”、“数组”的技法应用,实际是面向对象程序思路框架的搭建。第一题数组对象的属性,第二题对象数组的元素,不得不说都是跨了很多知识点的经典题目。 题目一:...
  • Java数组基础

    2021-06-19 22:03:46
    JAVA基础练习题(初学者) 新手练习题,联系到数组,求和,平均值,冒泡排序,数组的遍历知识点。 题目 创建一个数组对象,用于保存七位同学的成绩(具体成绩自己决定)。 要求: 1、求出数组中的成绩的最大值和...
  • 面向对象基础下— 1.5.7 可变参数 在JDK1.5之后,如果我们定义一个方法时,此时某个形参的类型可以确定,但是形参的个数不确定,那么我们可以使用可变参数。 修饰符 返回值类型 方法名(【非可变参数部分的形参列表,...
  • //创建并声明一个2维数组,赋值并遍历 public static void main(String[] args) { int[][] arrarr = new int[3][]; arrarr[0] = new int[4]; arrarr[1] = new int[2]; arrarr[2] = new int
  • //创建一个包含十个int型数据的数组,int型元素为1-20之内随机数,并求和、最大值、最小值、并遍历输出 public static void main(String[] args) { int[] arr = new int[8]; for (int i = 0; i ; i++) { ...
  • java练习题——数组

    2015-10-30 09:35:00
    上述代码可以顺利通过编译,并且输出一个“很...直接输出object的对象,系统会输出地址,如果想要输出其中的值,则要用循环下标分别输出。 例如: 转载于:https://www.cnblogs.com/xiaosongbiog/p/4922420.html...
  • 数组专项练习题

    2019-09-07 22:48:47
    1.Continue语句跳出整个...2.在面向对象编程里,经常使用is-a来说明对象之间的继承关系,下列对象中不具备继承关系的是?(D) A.手机与小米手机 B.企业家与雷军 C.编程语言与Java D.中国与北京 解析: is-a在JA...
  • java数组

    2021-01-08 23:18:31
    文章目录前言1、一维数组的创建2、数组的遍历3、练习题 前言 数组是表示多个相同类型变量的集合(在一个数组中所存放的所有元素的类型必须一致),可以使用共同的名字引用它 属于复杂数据类型 由类型相同的元素组成...
  • 题目:创建一个String对象数据,并为每一个元素都赋值一个String。用for循环来打印该数组。   public class test { public static void main(String[] args) { String []strs=new String[]{"1",&...
  • Java类和对象练习题

    2021-03-17 15:11:25
    1、数组的冒泡排序(Java) package one; /* * 使用冒泡排序,实现如下的数组从小到大排序。 int[] arr = new int[]{34,5,22,-98,6,-76,0,-3}; */ public class pao { public static void main(String args...
  • import java.util.Arrays; import java.util.Scanner; public class TestDemo { //给定一个整型数组, 将所有的偶数放在前半部分, // 将所有的奇数放在数组后半部分 public static void transform(int[] array) { ...
  • 创建一个简单的学生信息管理系统,能够实现管理员登录,修改密码,...(是java面向对象一些基本练习题4的一些修改,所有使用到Person数组的地方,用集合类对象取代,建议使用ArrayList类。)   我的答案: pac...
  • JAVA习题--数组1

    2019-05-16 19:57:48
    JAVA习题–数组 1.(1)定义类Pritimive,在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。 数组元素未赋值。 定义类Array1,在Array1的main()方法中创建Pritimive对象d,输出其成员变量t的三个元素值。 ...
  • 1.在一个二维数组中(每个一维数组的长度相同... 思路:找一个二维数组中中间大小的值与输入的目标值进行比较,通过比较大小移动二维数组的索引,选取的是右上角的元素作为比较的对象。 public class Solution { ...
  • 数组工具类 数学工具类 使用eclipse进行项目开发 学习目标 能够声明静态方法 能够调用静态方法 能够分别哪些成员变量应该是静态变量 能够访问和操作静态变量 能够f分析不同变量的区别 掌握几个常用工具类的...
  • 注:体现面向对象的特征,对象值进行判断,用异常处理。不合法的数值需要出现“这个数值是非法的提示”,不再进行运算。 2、在一个类中编写一个方法,这个方法搜索一个字符数组是否存在某个字符。如果存在则...
  • 创建一个MaxArray类,该类包含两个静态方法,一个是求数组元素最大值的静态方法,该方法有一个参数,参数类型是整型数组,返回值是该数组的最大值;另一个静态方法,该方法有两个参数,一个是整型变量,一个是整型...
  • JAVA学习初步练习题

    2020-10-11 16:38:28
    基础 1.实验报告 ...12.员工管理系统(Arrylist(动态数组)) 13.泛型的应用 14.集合的增删查改 15.罗马数字转整型 窗口 18.窗口、按键建立 16.父类创建子类构建函数 17.final的用法 1.实验报告 C++
  • 另一个类StudentDemo,在main方法中实现输入学生个数n,创建数组存储学生,并创建每个具体学生对象,输入学生的信息,然后再输出每个学生的总分、全班的每科平均分、全班的平均总分。 public class S...
  • java数组复制问题

    2015-11-25 18:27:01
    今天帮同学看蓝桥杯练习题时,想把一个c语言的小程序改成java程序时,发现自己怎么都不成功,捣鼓好久才知道数组作为一个JAVA对象和变量是不同的。例如在变量中这两样复制不会错 但是是数组就不一样了 要这样 小...
  • Java基础练习题

    2012-05-10 20:49:46
    包含了近百个JAVA的基础练习题,可以拿来加深对基础知识的熟悉和掌握。 总共分为:语法、条件结构、循环结构、数组、类与对象、三态、异常、集合、线程等一系列基础
  • 定义一个测试类,创建一个Student数组数组中的Student对象赋初值,将数组中的各个Student对象的内容输出到student.txt文件中; 然后将文件中的内容读出并在显示器中显示出来。 package test1; import java.io....
  • 将这些Student对象放进数组中 2.查询里面有没有叫田七的学生如果存在则打印学生的具体信息(封装成方法,键盘输入姓名) 3.计算所有学生的平均年龄,最大年龄,最小年龄 4.如果存在名字叫张三的将...
  • 栈可以存储java中任何引用类型的数据 2.提供push方法压栈(栈满 3.提供pop方法弹栈(栈空 4.编写测试程序,new栈对象,调用push pop方法模拟压栈弹栈动作 5.默认初始化容量是10(无参数 */ public class Stack ...
  • 【日常练习题】二维数组模拟简单酒店管理系统—java 酒店管理系统: 为某酒店编写程序:酒店管理系统,模拟订房、退房、打印所有房间状态等功能。 1、该系统的用户是:酒店前台 2、酒店使用一个二维数组来模拟。...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 149
精华内容 59
关键字:

java对象数组练习题

java 订阅