千锋逆战班，JavaSE结束项目学生信息管理系统

学习java第36天
Se阶段结束了，最后一个小项目。更新完成

程序启动

package com.qf.project.menu;

import java.util.Scanner;

import com.qf.project.entity.Student;
import com.qf.project.service.StudentService;
import com.qf.project.manager.*;
public class SystemMain {
	private static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		
		StudentService ss = new StudentService();

		for(int i = 0;i<10;i++) {
			String name = "吴彦祖"+i;
			int age = (int)(Math.random() *50);
			char sex = '男';
			String className = "NZ2002";
			double javaScore = (double)(Math.random() *100);
			double htmlScore = (double)(Math.random() *100);
			double springScore = (double)(Math.random() *100);
			ss.addStudent(new Student(name,age,sex,className,javaScore,htmlScore,springScore));
		}
		while(true){
			System.out.println("欢迎来到千锋学员管理系统");
			System.out.println("1.查看所有学员");
			System.out.println("2.新增学员");
			System.out.println("3.查询指定ID的学生信息");
			System.out.println("4.根据ID删除学员");
			System.out.println("5.根据ID修改学员信息");
			System.out.println("6.根据班级名称查询学员");
			System.out.println("7.根据姓名（姓、名）查询学员");
			System.out.println("8.根据需求排序学员信息");
			System.out.println("9.根据需求展示符合条件的学员信息");
			System.out.println("0.退出！");
			System.out.println("请选择：");
			
			int choice = sc.nextInt();
			
			switch(choice){
			case 1:
				ss.show();
				break;
			case 2:
				ss.addStudent();
				break;
			case 3:
				ss.getStuById();
				break;
			case 4:
				ss.delStuById();
				break;
			case 5:
				ss.setStuInId();
				break;
			case 6:
				ss.getStuByClassName();
				break;
			case 7:
				ss.getStuBySurName();
				break;
			case 8:
				ss.sortStu();
				break;
			case 9:
				ss.showFilter();
				break;
			case 0:
				ss.aa();
				return;
				default:
					break;
			
			
			
			
			}
			
			
		}
		
		
	}

}

StudentService

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意类型数据的数组，集合的底层
	private Object[] elmentData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存数组中有效元素个数 (下一个元素插入的下标)
	private int size = 0;
	
	
	
	
	public MyArrayList() {
		//调用无参的构造方法会直接床架一个容量为10的数组
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int in) {
		if(in < 0 || in > Integer.MAX_VALUE-8){
			throw new IllegalArgumentException("传递了一个不符合规范的初始容量！："+in);
		}else{
			elmentData = new Object[in];
		}
	}
	/**
	 * 为底层数组elementData做扩容！
	 * @param minCapacity 扩容需要得最小容量！
	 */
	public void grow(){
		int oldCapacity = elmentData.length;
		int newCapacity = oldCapacity + (oldCapacity>>1);
		if(newCapacity > Integer.MAX_VALUE-8){
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity == 0){
			newCapacity = size+1;
		}
		/*
		 * 1、创建新数组
		 * 2.拷贝元数据到新数组
		 * 3.返回新数组的首地址
		 * 4，替换
		 */
		elmentData = Arrays.copyOf(elmentData, newCapacity);
	}

	@Override
	public boolean add(E e) {
		if(size == elmentData.length){
			grow();
		}
		elmentData[size] = e;
		size++;
		return true;
	}
	
	
	
	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//判断下标是否合法
		if(size == elmentData.length){
			grow();
		}
		for(int i = size;i > index;i--){
			elmentData[i] = elmentData[i-1];
		}
		elmentData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下标的安全检查！如果下标值不符合要求，抛异常
	 * @param index  下标
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		if(o == null){
			throw new NullPointerException("元素为空");
		}
		for(int i = 0; i< size;i++){
//			E e1 = (E)elmentData[i];
//			E e2 = (E)o;
//			if(e1.equals(e2)){
			if(elmentData[i].equals(o)){
//				System.out.println(elmentData[i]);
				for(int j = i;j<size-1;j++){
					elmentData[j] = elmentData[j+1];//往前覆盖，但是最后一个没有被覆盖（考虑数组长度和有效元素个数会相同）
				}
				elmentData[size-1] = null;//循环完事单独吧最后一个有效元素覆盖null
				size--;
				return (E)o;
			}
		}
		
		return null;
	}

	@Override
	public E remove(int index) {
		checkIndex(index);
		Object o1 = elmentData[index];
		for(int i=index;i< size-1;i++){
			elmentData[i] = elmentData[i+1];//往前覆盖，但是最后一个没有被覆盖（考虑数组长度和有效元素个数会相同,最后一个会出现下标越界错误）
		}
		elmentData[size-1] = null;//循环完事单独吧最后一个有效元素覆盖null
		size--;
		return (E)o1;
	}

	@Override
	public E set(int index, E e) {
		checkIndex(index);
		
		
		return (E)(elmentData[index] = e);
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		Object[] o = new Object[size];
		for(int i = 0;i<size;i++){
			o[i]=elmentData[i];
		}
		return o;
	}

	@Override
	public boolean isEmpty() {
		if(elmentData == null){
			return true;
		}
		if(size ==0){
			return true;
		}
		return false;
	}

	@Override
	public boolean contains(Object o) {
		for(int i =0;i < size ;i++){
			if(elmentData[i].equals(o)){
				return true;
			}
		}
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		checkIndex(start);
		checkIndex(end);
		if(start < end){
			MyList<E> m = new MyArrayList<E>();
			for(int i = start ; i <=end ;i++){
				m.add((E)elmentData[i]);
			}
			return m;
		}
		if(start >= end){
			throw new ArrayIndexOutOfBoundsException("开始大于了终止的下标");
		}
		return null;
	}

	@Override
	public int indexOf(Object o) {
		for(int i = 0;i<size;i++){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for(int i =size-1;i >= 0;i--){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//检查下标是否合法范围
		return (E)elmentData[index];
	}

}

Student

package com.qf.project.entity;

import java.io.Serializable;

public class Student implements Serializable {
	private int id;//学号
	private String name;//姓名
	private int age;//年龄
	private char sex;//性别
	private String className;//班级
	private double javaScore;//Java成绩
	private double htmlScore;//html成绩
	private double springScore;//spring成绩
	private double totalScore;//总分
	
	public static int count =0;
	//无参
	public Student() {
	
	}
	//无成绩有参   基本信息
	public Student(String name,int age,char sex,String className){
		count++;
		this.id = count;
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.className = className;
		
	}
	//有成绩有参构造 
	public Student(String name, int age, char sex, String className, double javaScore, double htmlScore,
			double springScore) {
		this(name,age,sex,className);
		this.javaScore = javaScore;
		this.htmlScore = htmlScore;
		this.springScore = springScore;
		this.totalScore = javaScore + htmlScore + springScore;
	}
	public int getId() {
		return id;
	}
	
	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 char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public double getJavaScore() {
		return javaScore;
	}
	public void setJavaScore(double javaScore) {
		this.totalScore -= this.javaScore;//先把原来的java成绩减掉。
		
		this.javaScore = javaScore;//正常赋值
		
		this.totalScore += javaScore;//将更新好的成绩重新加到总分中
	}
	public double getHtmlScore() {
		return htmlScore;
	}
	public void setHtmlScore(double htmlScore) {
		this.totalScore -= this.htmlScore;//将原来的html成绩从总分去除
		
		this.htmlScore = htmlScore;//将最新的成绩更新
		
		this.totalScore += htmlScore;//将更新好的成绩重新加到总分中
	}
	public double getSpringScore() {
		return springScore;
	}
	public void setSpringScore(double springScore) {
		this.totalScore -= this.springScore;//将原来的spring成绩从总分去除
		
		this.springScore = springScore;//将最新的成绩更新
		
		this.totalScore += springScore;//将更新好的成绩重新加到总分中
	}
	//总分不能自己修改
	public double getTotalScore() {
		return totalScore;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", className=" + className
				+ ", javaScore=" + javaScore + ", htmlScore=" + htmlScore + ", springScore=" + springScore
				+ ", totalScore=" + totalScore + "]";
	}
	@Override
	public int hashCode() {
		
		return id;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (this.getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if(this.id == other.id && this.name.equals(other.name)&&this.age == other.age && this.sex == other.sex
				&& this.className.equals(other.className)&&this.javaScore==other.javaScore&&this.htmlScore==other.htmlScore
				&&this.springScore == other.springScore){
			return true;
			
		}
				
		return false;
	}
	
	
	
	
}

StudentManager

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意类型数据的数组，集合的底层
	private Object[] elmentData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存数组中有效元素个数 (下一个元素插入的下标)
	private int size = 0;
	
	
	
	
	public MyArrayList() {
		//调用无参的构造方法会直接床架一个容量为10的数组
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int in) {
		if(in < 0 || in > Integer.MAX_VALUE-8){
			throw new IllegalArgumentException("传递了一个不符合规范的初始容量！："+in);
		}else{
			elmentData = new Object[in];
		}
	}
	/**
	 * 为底层数组elementData做扩容！
	 * @param minCapacity 扩容需要得最小容量！
	 */
	public void grow(){
		int oldCapacity = elmentData.length;
		int newCapacity = oldCapacity + (oldCapacity>>1);
		if(newCapacity > Integer.MAX_VALUE-8){
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity == 0){
			newCapacity = size+1;
		}
		/*
		 * 1、创建新数组
		 * 2.拷贝元数据到新数组
		 * 3.返回新数组的首地址
		 * 4，替换
		 */
		elmentData = Arrays.copyOf(elmentData, newCapacity);
	}

	@Override
	public boolean add(E e) {
		if(size == elmentData.length){
			grow();
		}
		elmentData[size] = e;
		size++;
		return true;
	}
	
	
	
	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//判断下标是否合法
		if(size == elmentData.length){
			grow();
		}
		for(int i = size;i > index;i--){
			elmentData[i] = elmentData[i-1];
		}
		elmentData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下标的安全检查！如果下标值不符合要求，抛异常
	 * @param index  下标
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		if(o == null){
			throw new NullPointerException("元素为空");
		}
		for(int i = 0; i< size;i++){
//			E e1 = (E)elmentData[i];
//			E e2 = (E)o;
//			if(e1.equals(e2)){
			if(elmentData[i].equals(o)){
//				System.out.println(elmentData[i]);
				for(int j = i;j<size-1;j++){
					elmentData[j] = elmentData[j+1];//往前覆盖，但是最后一个没有被覆盖（考虑数组长度和有效元素个数会相同）
				}
				elmentData[size-1] = null;//循环完事单独吧最后一个有效元素覆盖null
				size--;
				return (E)o;
			}
		}
		
		return null;
	}

	@Override
	public E remove(int index) {
		checkIndex(index);
		Object o1 = elmentData[index];
		for(int i=index;i< size-1;i++){
			elmentData[i] = elmentData[i+1];//往前覆盖，但是最后一个没有被覆盖（考虑数组长度和有效元素个数会相同,最后一个会出现下标越界错误）
		}
		elmentData[size-1] = null;//循环完事单独吧最后一个有效元素覆盖null
		size--;
		return (E)o1;
	}

	@Override
	public E set(int index, E e) {
		checkIndex(index);
		
		
		return (E)(elmentData[index] = e);
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		Object[] o = new Object[size];
		for(int i = 0;i<size;i++){
			o[i]=elmentData[i];
		}
		return o;
	}

	@Override
	public boolean isEmpty() {
		if(elmentData == null){
			return true;
		}
		if(size ==0){
			return true;
		}
		return false;
	}

	@Override
	public boolean contains(Object o) {
		for(int i =0;i < size ;i++){
			if(elmentData[i].equals(o)){
				return true;
			}
		}
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		checkIndex(start);
		checkIndex(end);
		if(start < end){
			MyList<E> m = new MyArrayList<E>();
			for(int i = start ; i <=end ;i++){
				m.add((E)elmentData[i]);
			}
			return m;
		}
		if(start >= end){
			throw new ArrayIndexOutOfBoundsException("开始大于了终止的下标");
		}
		return null;
	}

	@Override
	public int indexOf(Object o) {
		for(int i = 0;i<size;i++){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for(int i =size-1;i >= 0;i--){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//检查下标是否合法范围
		return (E)elmentData[index];
	}

}

	
}

MyArrayList

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意类型数据的数组，集合的底层
	private Object[] elmentData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存数组中有效元素个数 (下一个元素插入的下标)
	private int size = 0;
	
	
	
	
	public MyArrayList() {
		//调用无参的构造方法会直接床架一个容量为10的数组
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int in) {
		if(in < 0 || in > Integer.MAX_VALUE-8){
			throw new IllegalArgumentException("传递了一个不符合规范的初始容量！："+in);
		}else{
			elmentData = new Object[in];
		}
	}
	/**
	 * 为底层数组elementData做扩容！
	 * @param minCapacity 扩容需要得最小容量！
	 */
	public void grow(){
		int oldCapacity = elmentData.length;
		int newCapacity = oldCapacity + (oldCapacity>>1);
		if(newCapacity > Integer.MAX_VALUE-8){
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity == 0){
			newCapacity = size+1;
		}
		/*
		 * 1、创建新数组
		 * 2.拷贝元数据到新数组
		 * 3.返回新数组的首地址
		 * 4，替换
		 */
		elmentData = Arrays.copyOf(elmentData, newCapacity);
	}

	@Override
	public boolean add(E e) {
		if(size == elmentData.length){
			grow();
		}
		elmentData[size] = e;
		size++;
		return true;
	}
	
	
	
	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//判断下标是否合法
		if(size == elmentData.length){
			grow();
		}
		for(int i = size;i > index;i--){
			elmentData[i] = elmentData[i-1];
		}
		elmentData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下标的安全检查！如果下标值不符合要求，抛异常
	 * @param index  下标
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		if(o == null){
			throw new NullPointerException("元素为空");
		}
		for(int i = 0; i< size;i++){
//			E e1 = (E)elmentData[i];
//			E e2 = (E)o;
//			if(e1.equals(e2)){
			if(elmentData[i].equals(o)){
//				System.out.println(elmentData[i]);
				for(int j = i;j<size-1;j++){
					elmentData[j] = elmentData[j+1];//往前覆盖，但是最后一个没有被覆盖（考虑数组长度和有效元素个数会相同）
				}
				elmentData[size-1] = null;//循环完事单独吧最后一个有效元素覆盖null
				size--;
				return (E)o;
			}
		}
		
		return null;
	}

	@Override
	public E remove(int index) {
		checkIndex(index);
		Object o1 = elmentData[index];
		for(int i=index;i< size-1;i++){
			elmentData[i] = elmentData[i+1];//往前覆盖，但是最后一个没有被覆盖（考虑数组长度和有效元素个数会相同,最后一个会出现下标越界错误）
		}
		elmentData[size-1] = null;//循环完事单独吧最后一个有效元素覆盖null
		size--;
		return (E)o1;
	}

	@Override
	public E set(int index, E e) {
		checkIndex(index);
		
		
		return (E)(elmentData[index] = e);
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		Object[] o = new Object[size];
		for(int i = 0;i<size;i++){
			o[i]=elmentData[i];
		}
		return o;
	}

	@Override
	public boolean isEmpty() {
		if(elmentData == null){
			return true;
		}
		if(size ==0){
			return true;
		}
		return false;
	}

	@Override
	public boolean contains(Object o) {
		for(int i =0;i < size ;i++){
			if(elmentData[i].equals(o)){
				return true;
			}
		}
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		checkIndex(start);
		checkIndex(end);
		if(start < end){
			MyList<E> m = new MyArrayList<E>();
			for(int i = start ; i <=end ;i++){
				m.add((E)elmentData[i]);
			}
			return m;
		}
		if(start >= end){
			throw new ArrayIndexOutOfBoundsException("开始大于了终止的下标");
		}
		return null;
	}

	@Override
	public int indexOf(Object o) {
		for(int i = 0;i<size;i++){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for(int i =size-1;i >= 0;i--){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//检查下标是否合法范围
		return (E)elmentData[index];
	}

}

接口：
MyFilter

package com.qf.project.util;

public interface MyFilter<E> {
	boolean accept(E e);
}

MyComparator

package com.qf.project.util;

public interface MyComparator<E> {
	/**
	 * 自定义排序的方法，方法的返回值是int类型
	 * @param stu1 student类型
	 * @param stu2 student类型
	 * @return >0 前者大于后者   <0 前者小于后者  ==0 两者相同
	 */
	int compare(E e1,E e2);
}

MyList

package com.qf.project.util;
/**
 * 
 *  增加：
 * add(E e);
 * add(int index,E e);
 * 删除：
 * remove(E e);
 * remove(int index);
 * 改：
 * set(int index,E e);
 * 获取：
 * int size();
 * Object[] toArray();
 * boolean isEmpty();
 * boolean contains(Object o);
 * MyArrayList<E> subList(int start,int end);
 * int indexOf(Object o);
 * int lastIndexOf(Object o);
 * E get(int index);
 * @author Dell
 *
 * @param <E> 泛型，应用在不同类型下，作为集合中元素的类型（传入什么类型就为什么类型）
 */


public interface MyList<E> {
	/**
	 * 添加方法
	 * 添加元素到集合末尾
	 * @param e 元素
	 * @return 添加成功返回true否则false
	 */
	boolean add(E e);
	
	/**
	 * 添加方法
	 * 将元素添加到指定的下标中
	 * @param index 集合元素的下标
	 * @param e 集合中元素
	 * @return  添加成功返回true否则false
	 */
	boolean add(int index ,E e);
	/**
	 * 
	 * 移除方法
	 * 移除指定元素
	 * @param o 要移除的元素
	 * @return 返回移除的元素
	 */
	E remove(Object o);
	/**
	 *移除方法
	 * 根据指定的下标移除下标上的元素
	 * @param index 将要移除元素的下标
	 * @return 返回移除的元素
	 */
	E remove(int index);
	
	/**
	 * 覆盖方法，替换制定下标上的元素
	 * 
	 * @param index 下标
	 * @param e 替换的元素
	 * @return 被替换的元素
	 */
	E set(int index,E e);
	
	/**
	 *获取集合中有效的元素个数
	 * 
	 * @return 有效元素个数
	 */
	int size();
	/**
	 * 获取集合中，算有元素的Object类型数组
	 * 
	 * @return Object[] 集合元素数组
	 */
	Object[] toArray();
	
	/**
	 * 
	 * 判断集合是否为空
	 * @return 如果一个元素都没有，返回true，有元素返回false
	 */
	boolean isEmpty();
	
	/**
	 * 判断集合中是否有何传入元素相同的元素
	 * @param o 需要查找的对象
	 * @return 有返回true，没有返回false
	 */
	boolean contains(Object o);
	/**
	 * 根据需求，返回start到end之间的MyList集合的子集合
	 * @param start 要求有效下标的范围，不能超过end
	 * @param end要求有效下标的范围，不能小于等于start
	 * @return 数据符合要求，返回一个当前集合的子集合。若数据不符合要求，返回NULL
	 */
	MyList<E> subList(int start,int end);
	/**
	 * 获得指定元素在集合中第一次出现的位置
	 * @param o 指定的元素
	 * @return 找到返回值 返回下标，没找到返回-1
	 */
	int indexOf(Object o);
	/**
	 * 获取指定元素在集合中最后一次出现的位置
	 * @param o指定的元素
	 * @return 找到返回值 返回下标，没找到返回-1
	 */
	int lastIndexOf(Object o);
	/**
	 * 根据指定的下标位置，获得元素
	 * @param index 下标
	 * @return 元素对象
	 */
	E get(int index);
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
}