在千峰“逆战班”学习的第36天
今天的学习内容是JDK8特性中的Stream API，以及一个小的StudentSystem项目
中国加油！武汉加油！千峰加油！我自己加油！！
package com.qf.project.entity;
public class Student {
private int id;//学号，唯一性，不可更改
private String name;//姓名
private int age;//年龄
private char gender;//性别
private String className;//班号
private double javaScore;
private double htmlScore;
private double springScore;
private double totalScore;//总分
public Student(){}
public Student(int id, String name, int age, char gender, String className) {
super();
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
this.className = className;
}
public Student(int id, String name, int age, char gender, String className, double javaScore, double htmlScore,
double springScore) {
this(id,name,age,gender,className);
this.javaScore = javaScore;
this.htmlScore = htmlScore;
this.springScore = springScore;
//总分有其他三科成绩相加得到
this.totalScore = javaScore + htmlScore + springScore;
}
//学号唯一且不可更改，不能有set方法
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 getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
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;
this.javaScore = javaScore;
this.totalScore += javaScore;
}
public double getHtmlScore() {
return htmlScore;
}
public void setHtmlScore(double htmlScore) {
this.totalScore -= this.htmlScore;
this.htmlScore = htmlScore;
this.totalScore += htmlScore;
}
public double getSpringScore() {
return springScore;
}
public void setSpringScore(double springScore) {
this.totalScore -= this.springScore;
this.springScore = springScore;
this.totalScore += springScore;
}
public double getTotalScore() {
return totalScore;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", className="
+ className + ", javaScore=" + javaScore + ", htmlScore=" + htmlScore + ", springScore=" + springScore
+ ", totalScore=" + totalScore + "]";
}
}
package com.qf.project.manager;
import com.qf.project.entity.Student;
/**
* 完成所有学生管理系统的相关功能
* 逻辑代码、输入数据
* @author 11344
*
*/
public class StudentManeger {
/**
* 添加学生对象的方法，采用尾插法，插入到集合末端
* @param stu 要添加的学生对象
* @return true表示添加成功，false表示添加失败
*/
public boolean add(Student stu){
return true;
}
/**
* 根据学生的唯一学号，删除指定学生
* @param id 要删除的学生学号
* @return 删除的学生对象
*/
public Student remove(int studentID){
return null;
}
/**
* 修改方法，指定学生的学号
* @param studentID 学生的学号
* @return 修改成功返回true，失败返回false
*/
public boolean motify(int studentID){
return true;
}
/**
* 根据学生学号查询单个学生对象
* @param studentID 学生学号
* @return 查询到的学生对象，没有则返回null
*/
public Student get(int studentID){
return null;
}
/**
* 查询所有学生对象，直接遍历集合
*/
public void get(){
//打印所有学生对象
}
}
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 11344
*
* @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();
/**
* 判断对象o，在集合中是否存在
* @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);
}
package com.qf.project.util.impl;
import java.util.Arrays;
import com.qf.project.util.MyList;
public class MyArrayList<E> implements MyList<E> {
//保存任意类型数据的数组，集合的底层
private Object[] elementData = null;
//集合初始容量
private static final int DEFAILT_CAPACITY = 10;
//保存数组中有效元素个数（下一个元素插入的下标）
private int size = 0;
public MyArrayList(){
// elementData = new Object[DEFAILT_CAPACITY];
this(DEFAILT_CAPACITY);
}
/**
* 手工初始化集合的容量
* @param initCapacity 传入的容量大小：要求大于0并且小于Integer.MAX_VALUE-8
*/
public MyArrayList(int initCapacity){
//判断initCapacity是否符合要求
if(initCapacity < 0 || initCapacity > Integer.MAX_VALUE - 8){
throw new IllegalArgumentException("传递了一个不符合规范的初始容量:" + initCapacity);
}else{
elementData = new Object[initCapacity];
}
}
@Override
public boolean add(E e) {
//判断数组是否还有空间
if(size == elementData.length){
//扩容
grow(size + 1);
}
elementData[size] = e;
size++;
return true;
}
/**
* 为底层数组elementData做扩容
* @param minCapacity 扩容需要的最小容量
*/
private void grow(int minCapacity){
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if(newCapacity > Integer.MAX_VALUE - 8){
throw new OutOfMemoryError("集合溢出了！");
}
if(newCapacity > minCapacity){
newCapacity = minCapacity;
}
/**
* 1.创建新数组
* 2.拷贝原数组到新数组
* 3.返回新数组的地址
* 4.替换
*/
elementData = Arrays.copyOf(elementData, newCapacity);
}
@Override
public boolean add(int index, E e) {
//检查下标是否合理，不合理抛出异常，程序停止
checkIndex(index);
//判断数组是否需要扩容
if(size == elementData.length){
//扩容
grow(size + 1);
}
for(int i = size; i > index; i--){
elementData[i] = elementData[i - 1];
}
elementData[index] = e;
size++;
return true;
}
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("查询的内容不存在");
}else{
this.remove(getIndex(o));
}
return null;
}
private int getIndex(Object o){
for(int i = 0; i < size; i++){
if(elementData[i].equals(o)){
return i;
}
}
return -1;
}
@Override
public E remove(int index) {
checkIndex(index);
E old = (E)elementData[index];
for(int i = index; i <size; i++){
elementData[i] = elementData[i + 1];
}
size--;
return old;
}
@Override
public E set(int index, E e) {
E old = (E)elementData[index];
elementData[index] = e;
return old;
}
@Override
public int size() {
//返回有效元素个数
return size;
}
@Override
public Object[] toArray() {
Object[] o = new Object[size];
for(int i = 0; i < size; i++){
o[i] = elementData[i];
}
return o;
}
@Override
public boolean isEmpty() {
if(size == 0){
return true;
}
return false;
}
@Override
public boolean contains(Object o) {
if(getIndex(o) == -1){
return false;
}
return true;
}
@Override
public MyList<E> subList(int start, int end) {
checkIndex(start);
checkIndex(end);
if(start <= end){
throw new ArrayIndexOutOfBoundsException(start + "必须小于" + end);
}
MyList<E> newMyList = new MyArrayList<E>();
for(int i = start; i < end; i++){
newMyList.add((E)elementData[i]);
}
return newMyList;
}
@Override
public int indexOf(Object o) {
return getIndex(o);
}
@Override
public int lastIndexOf(Object o) {
for(int i = size - 1; i >= 0;i--){
if(elementData[i].equals(o)){
return i;
}
}
return -1;
}
@Override
public E get(int index) {
checkIndex(index);
//返回指定下标元素
return (E)elementData[index];
}
}
