千锋逆战班学习第37天
千锋逆战班学习第37天
努力或许没有收获，但不努力一定没收获，加油。
今天我完善了Java课程的综合案例。
中国加油！！！武汉加油！！！千锋加油！！！我自己加油！！！
综合案例
com.qf.project.entity.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 gender;
private String className;
private double javaScore;//成绩
private double htmlScore;
private double springScore;//成绩
private double totalScore;//总分
//private static int count = 0;
public static int count = 0;//扩展、属性不私有
//无参
public Student() {}
//无成绩有参 基本信息
public Student(String name, int age, char gender, String className) {
super();
count++;
this.id = count;
this.name = name;
this.age = age;
this.gender = gender;
this.className = className;
}
//有成绩有参构造
public Student(String name, int age, char gender, String className, double javaScore, double htmlScore,
double springScore) {
this(name,age,gender,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 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 -= javaScore;//先把原来的java成绩减掉。
this.javaScore = javaScore;//正常赋值
this.totalScore += this.javaScore;//加上新成绩
}
public double getHtmlScore() {
return htmlScore;
}
public void setHtmlScore(double htmlScore) {
this.totalScore -= htmlScore;
this.htmlScore = htmlScore;
this.totalScore += htmlScore;
}
public double getSpringScore() {
return springScore;
}
public void setSpringScore(double springScore) {
this.totalScore -= 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 + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((className == null) ? 0 : className.hashCode());
result = prime * result + gender;
long temp;
temp = Double.doubleToLongBits(htmlScore);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + id;
temp = Double.doubleToLongBits(javaScore);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + ((name == null) ? 0 : name.hashCode());
temp = Double.doubleToLongBits(springScore);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(totalScore);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Student o = (Student) obj;
if (this.id == o.getId() && this.name.equals(o.getName()) && this.age == o.getAge()
&& this.gender == o.getGender() && this.className.equals(o.getClassName())
&& this.javaScore == o.getJavaScore() && this.htmlScore == o.getHtmlScore()
&& this.springScore == o.getSpringScore()) {
return true;
}
return false;
}
}
com.qf.project.manager.StudentManager
package com.qf.project.manager;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import com.qf.project.entity.Student;
import com.qf.project.util.MyComparator;
import com.qf.project.util.MyFilter;
import com.qf.project.util.impl.MyArrayList;
/**
* 完成所有学生管理系统的相关功能
* 逻辑代码、输入数据
* 只负责接受前端数据、调用后端
* */
public class StudentManager {
//只负责接受前端数据、调用后端
/**
* 使用自定义MyArrayList,存储学生对象
* */
private MyArrayList<Student> allStudent = null;
public StudentManager() {
allStudent = new MyArrayList<Student>();
load();
}
/**
* 传入初始容量，创建集合对象
* @param initCapacity 要求传入的容量大于0并且小于Integer.MAX_VALUE -8
* */
public StudentManager(int initCapacity) {
allStudent = new MyArrayList<Student>(initCapacity);
load();
}
public void load() {
try {
File file = new File("Files\\Student.txt");
if(file.exists()) {
if(file.length() > 0) {
//字节输入流
FileInputStream fis = new FileInputStream(file);
//对象输入流
ObjectInputStream ois = new ObjectInputStream(fis);
Object obj;
Student stu = new Student();
while(true) {
try {
obj = ois.readObject();
Student stu2 = (Student)obj;
Student.count = stu.count > stu2.count ? stu.getId() : stu2.getId();
} catch (Exception e) {
break;
}
allStudent.add((Student)obj);
}
System.out.println("初始化完毕，有" + allStudent.size() + "名学员信息");
ois.close();
fis.close();
}
}else {
file.createNewFile();//文件不存在，新建一个空文件
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void saveByStream() {
try {
FileOutputStream fos = new FileOutputStream("Files\\Student.txt",false);
ObjectOutputStream oos = new ObjectOutputStream(fos);
for (int i = 0; i < allStudent.size(); i++) {
Student stu = allStudent.get(i);
oos.writeObject(stu);
}
oos.flush();
oos.close();
fos.close();
}catch (Exception e) {
// TODO: handle exception
}
}
/**
* 添加学生对象的方法，采用尾插法，插入到集合的末端
* @param stu Student
* @return 成功返回ture ,失败返回false
* */
public boolean add(Student stu) {
if(stu == null) {
System.out.println("不能存入空值");
return false;
}
allStudent.add(stu);
return true;
}
/**
* 根据学生唯一Id，删除指定的学生
* @param studentId 学生编号
* @return 成功返回删除的学生对象，,失败返回null
* */
public Student remove(int id) {
//1.检查id在集合的位置
int index = findIndexById(id);
try {
return allStudent.remove(index);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
return null;
}
/**
* 修改方法，根据学生唯一Id，修改指定的学生
* @param studentId 学生编号
* @return 成功返回ture ,失败返回false
* */
public boolean modify(int studentId) {
return false;
}
/**
* 查单个
* 根据学生唯一Id，查询指定的学生
* @param studentId 学生编号
* @return 成功返回查询的学生对象，,失败返回null
* */
public Student get(int studentId) {
//1.判断下标数值正确
int index = findIndexById(studentId);
//2.获得学员对象返回给StudentService
if(index > 0) {
return allStudent.get(index);
}
return null;
}
/**
* 根据学生唯一Id，查询指定的学生的下标
* @param studentId 学生编号
* @return 成功返回大于0的数字，没找到，返回-1
*/
private int findIndexById(int studentId) {
int index = -1;
//从下标0开始，遍历集合
for (int i = 0; i < allStudent.size(); i++) {
//依次获取当前学生对象的id和传入的studentId做比较
if(allStudent.get(i).getId() == studentId) {
index = i;//把存在的学生下标，赋给index
}
}
return index;
}
/**
* 查询所有，直接遍历集合
*/
public void get() {
//打印所有学生信息
for (int i = 0 ;i < allStudent.size() ;i++) {
System.out.println(allStudent.get(i));
}
}
/**
* 根据班级名称查询学生信息
* @param className 班级名称
* */
public void get(String className) {
//打印所有学生信息
for (int i = 0 ;i < allStudent.size() ;i++) {
if(allStudent.get(i).getClassName().equalsIgnoreCase(className)) {
System.out.println(allStudent.get(i));
}
}
}
/**
* 根据姓氏查询学生信息
* @param surname 姓氏
* */
public void getSurname(String surname) {
//打印所有学生信息
for (int i = 0 ;i < allStudent.size() ;i++) {
if(allStudent.get(i).getName().startsWith(surname)) {
System.out.println(allStudent.get(i));
}
}
}
/**
* 根据名字查询学生信息
* @param lastname 名字
* */
public void getLastname(String lastname) {
for (int i = 0 ;i < allStudent.size() ;i++) {
if(allStudent.get(i).getName().contains(lastname)) {
System.out.println(allStudent.get(i));
}
}
}
//过滤
//排序
/**
* 根据id排序
*
public void sortId() {
//1.排序不允许在原数组中进行，创建一个新数组，复制一份
Object[] sortTemp = allStudent.toArray();
//2.选择排序
for (int i = 0; i < sortTemp.length - 1; i++) {
for (int j = i+1; j < sortTemp.length; j++) {
if(((Student)sortTemp[i]).getId() < ((Student)sortTemp[j]).getId()) {
Student temp = (Student)sortTemp[i];
sortTemp[i] = sortTemp[j];
sortTemp[j] = temp;
}
}
for (Object obj : sortTemp) {
System.out.println(obj);
}
}
}
*/
/**
* 根据传来的规则排序
*/
public void sort(MyComparator<Student> com) {
//1.排序不允许在原数组中进行，创建一个新数组，复制一份
Object[] sortTemp = allStudent.toArray();
//2.选择排序
for (int i = 0; i < sortTemp.length - 1; i++) {
for (int j = i+1; j < sortTemp.length; j++) {
if(com.compare((Student)sortTemp[i], (Student)sortTemp[j]) < 0) {
Student temp = (Student)sortTemp[i];
sortTemp[i] = sortTemp[j];
sortTemp[j] = temp;
}
}
}
for (Object obj : sortTemp) {
System.out.println(obj);
}
}
public void showStuFilter(MyFilter<Student> filter) {
for (int i = 0; i < allStudent.size(); i++) {
if(filter.accept(allStudent.get(i))) {
System.out.println(allStudent.get(i));
}
}
}
}
com.qf.project.menu.SystemMain
package com.qf.project.menu;
import java.util.Scanner;
import com.qf.project.entity.Student;
import com.qf.project.service.StudentService;
/**
*\只有菜单
* 1.查看
* 2.修改
* 3.添加
* 4.删
*/
public class SystemMain {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
StudentService ss = new StudentService();
int choice = 0;
/**
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));
}
*/
do{
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.退出");
choice = sc.nextInt();
switch (choice) {
case 1:
//查看所有
ss.show();
break;
case 2:
//新增学员
ss.addStudent();
break;
case 3:
//查询指定ID的学生信息
ss.getStuById();
break;
case 4:
//根据ID删除学生信息"
ss.deleteStuById();
break;
case 5:
//根据ID修改学生信息
ss.updataStuById();
break;
case 6:
//根据班级名称查询学生信息
ss.getStudentByClassName();
break;
case 7:
//根据姓名（姓/名）查询学员
ss.getStudentByLike();
break;
case 8:
//根据需求排序学生信息
ss.sortStu();
break;
case 9:
//
ss.showFilter();
break;
case 0:
//退出
ss.saveStuForFile();
return;
default:
break;
}
}while(choice != 0);
}
}
com.qf.project.service.StudentService
package com.qf.project.service;
import java.util.Scanner;
import com.qf.project.entity.Student;
import com.qf.project.manager.StudentManager;
public class StudentService {
Scanner sc = new Scanner(System.in);
StudentManager stm = new StudentManager();
/**
* 展示所有学生
* */
public void show() {
stm.get();
}
/**
* 添加学生对象的方法
* 该方法让用户输入数据，并判断数据
* */
public void addStudent() {
System.out.println("请按照顺序输入正确学员信息");
System.out.println("请输入学员姓名");
String name = sc.next();
System.out.println("请输入学员年龄");
int age = sc.nextInt();
System.out.println("请输入学员（性别男/女）");
char sex = sc.next().charAt(0);
System.out.println("请输入学员班级名称");
String className = sc.next();
System.out.println("请输入学员Java考试成绩（若没有，填零）");
double javaScore =sc.nextDouble();
System.out.println("请输入学员HTML考试成绩（若没有，填零）");
double HTMLScore =sc.nextDouble();
System.out.println("请输入学员Spring考试成绩（若没有，填零）");
double SpringScore =sc.nextDouble();
//封装成对象
Student stu = new Student(name,age,sex,className,javaScore,HTMLScore,SpringScore);
//调用StudentManager里的方法
boolean result = stm.add(stu);
if(result == true) {
System.out.println("新增成功");
}else {
System.out.println("新增失败");
}
}
public void addStudent(Student stu) {
stm.add(stu);
}
/**
* 查询指定ID的学生信息
* 该方法让用户输入ID，并打印学生信息，若没有，打印学员不存在
* */
public void getStuById() {
//1.判断输入是否正确
/**
int id = 0;
do {
System.out.println("请输入学员的ID");
id = sc.nextInt();
if(id <= 0) {
System.out.println("ID应大于0");
}
} while (id <= 0);
*/
//获取ID
Student stu = stm.get(IDcheck());
if(stu != null) {
System.out.println(stu);
}else {
System.out.println("学员不存在");
}
}
/**
* 删除指定ID的学生信息
* 该方法让用户输入ID，并打印删除成功，若没有，打印删除失败
* */
public void deleteStuById() {
/**
int id = 0;
do {
System.out.println("请输入要删除的学生Id");
id = sc.nextInt();
if(id <= 0) {
System.out.println("ID应大于0");
}
} while (id <= 0);
*/
Student stu = stm.remove(IDcheck());
if(stu != null) {
System.out.println("删除成功");
}else {
System.out.println("删除失败");
}
}
/**
* 修改指定ID的学生信息
* 该方法让用户输入ID，并修改指定ID的学生信息信息。
* */
public void updataStuById() {
/**
int id = 0;
do {
System.out.println("请输入修改信息的学生Id");
id = sc.nextInt();
if(id <= 0) {
System.out.println("ID应大于0");
}
} while (id <= 0);
*/
Student stu = stm.get(IDcheck());
if(stu != null) {
System.out.println("现在要修改"+stu.getName()+"的信息：");
System.out.println("学生ID："+stu.getId());
System.out.println("学生姓名："+stu.getName());
System.out.println("学生年龄:"+stu.getAge());
System.out.println("学生性别："+stu.getGender());
System.out.println("学生班级："+stu.getClassName());
System.out.println("Java："+stu.getJavaScore());
System.out.println("HTML："+stu.getHtmlScore());
System.out.println("Spring："+stu.getSpringScore());
System.out.println("-------------------------------------");
int choice = 0;
while(true) {
System.out.println("1.修改学生姓名");
System.out.println("2.修改性别");
System.out.println("3.修改班级名称");
System.out.println("4.修改学生年龄");
System.out.println("5.修改Java成绩");
System.out.println("6.修改HTML成绩");
System.out.println("7.修改Spring成绩");
System.out.println("8.退出，并保存");
choice = sc.nextInt();
switch(choice) {
case 1:
System.out.println("请输入学生的新姓名：");
String name = sc.next();
stu.setName(name);
break;
case 2:
System.out.println("请输入学生的性别(男 or 女)：");
char gender = sc.next().charAt(0);
stu.setGender(gender);
break;
case 3:
System.out.println("请输入学生的新班级：");
String className = sc.next();
stu.setClassName(className);
break;
case 4:
System.out.println("请输入学生的年龄：");
int age = sc.nextInt();
stu.setAge(age);
break;
case 5:
System.out.println("请输入学生的Java成绩：");
double javaScore = sc.nextDouble();
stu.setJavaScore(javaScore);
break;
case 6:
System.out.println("请输入学生的HTML成绩：");
double htmlScore = sc.nextDouble();
stu.setHtmlScore(htmlScore);
break;
case 7:
System.out.println("请输入学生的Spring成绩：");
double springScore = sc.nextDouble();
stu.setSpringScore(springScore);
break;
case 8:
System.out.println("修改完成，并保存了！");
System.out.println("修改后的学员信息为："+stu);
return;
default:
break;
}
}
}else {
System.out.println("查无此人！请核对学号");
}
}
/**
* 获取合适的id
* @return 返回符合标准的id
* */
private int IDcheck() {
int id = 0;
do {
System.out.println("请输入学员id");
id = sc.nextInt();
if(id <= 0) {
System.out.println("id不能小于等于0");
}
} while (id <= 0);
return id;
}
/**
* 根据班级名称查询学生信息。
* */
public void getStudentByClassName() {
System.out.println("请输入班级名称");
String className = sc.next();
stm.get(className);
}
/**
* 根据姓名（姓/名）查询学员
* */
public void getStudentByLike() {
System.out.println("请选择：1.根据姓 2.根据名字 0.退出");
int choice = 0;
while(true) {
choice = sc.nextInt();
switch (choice) {
case 1:
System.out.println("请输入姓氏");
String surname = sc.next();
stm.getSurname(surname);
break;
case 2:
System.out.println("请输入姓氏");
String lastname = sc.next();
stm.getLastname(lastname);
break;
case 0:
return;
default:
break;
}
}
}
/**
* 根据需求排序学生信息
* */
public void sortStu() {
//1.升序规则 升序
//2.升序的方式有多种：id,age,score
//3.底层排序：冒泡、选择
int choice = 0;
while(true){
System.out.println("将按照升序排列学员信息，请选择条件");
System.out.println("1.根据id 2. 根据age 3.根据score 0.退出");
choice = sc.nextInt();
switch (choice) {
case 1:
stm.sort((stu1,stu2)->stu1.getId() - stu2.getId());
break;
case 2:
stm.sort((stu1,stu2)->stu1.getAge() - stu2.getAge());
break;
case 3:
stm.sort((stu1,stu2)->(int)(stu1.getTotalScore() - stu2.getTotalScore()*100));
/**
stm.sort(new MyComparator<Student>() {
@Override
public int compare(Student stu1, Student stu2) {
return (int)(stu1.getTotalScore() - stu2.getTotalScore()*1000);
}
});
*/
break;
case 0:
return;
default:
break;
}
}
}
public void showFilter() {
//1.查询年龄大于15的
//2.查询总分大于250的
int choice = 0;
while(true) {
System.out.println("1.查询年龄大于15的 2.查询总分大于150的 0.退出 ");
choice = sc.nextInt();
switch (choice) {
case 1:
stm.showStuFilter((s)->s.getAge() > 15);
break;
case 2:
stm.showStuFilter((s)->s.getTotalScore() > 150);
break;
case 0:
return;
default:
break;
}
}
}
public void saveStuForFile() {
System.out.println("请稍后，正在更新最近学生信息");
stm.saveByStream();
}
}
com.qf.project.util.MyComparator
package com.qf.project.util;
public interface MyComparator<E> {
public int compare(E stu1 , E stu2);
}
com.qf.project.util.MyFilter
package com.qf.project.util;
public interface MyFilter<E> {
public boolean accept(E e);
}
com.qf.project.util.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 GQ
*
* @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);
}
com.qf.project.util.impl.MyArrayList
package com.qf.project.util.impl;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import com.qf.project.util.MyList;
public class MyArrayList<E> implements MyList<E>{
//1.保存任意类型数据的数组，集合的底层
private Object[] elementData = null;
//2.集合的初始容量
private static final int DEFAULT_CAPACITY = 10;
//3.保存数组中有效元素个数（下一个元素插入的下标）
private int size = 0;
public MyArrayList() {
//elementData = new Object[DEFAULT_CAPACITY];
//统一化当前集合页的初始化方式
this(DEFAULT_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 == 0) {
newCapacity = minCapacity;
}
//1、创建新数组
//2、拷贝将旧数组到新数组
//3、返回新数组的首地址
//4、替换
elementData = Arrays.copyOf(elementData, newCapacity);
}
@Override
public boolean add(int index, E e) {
//1. 判断下标是否合理,，不合理，抛异常，程序因异常而终止
checkIndex(index);
if(size == elementData.length) {
grow(size + 1);
}
//2.
for(int i = size;i > index; i--) {
elementData[i] = elementData[i - 1];
}
elementData[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("传递的是空值");
}
return this.remove(isCheck((E)o, 0));
}
/**
* 判断元素是否存在，存在返回位置，不存在返回-1
*@param E e
* @return 若存在返回所在下标 不存在返回-1
*/
private int isCheck(E e,int index) {
for (int i = index; i < size; i++) {
if(elementData[i].equals((E)e)) {
return i;
}
}
return -1;
}
@Override
public E remove(int index) {
//1.检查下标
checkIndex(index);
//2.获取对应下标的对象
E removeIndex = this.get(index);
for (int i = index; i < size - 1; i++) {
elementData[i] = elementData[i + 1];
}
elementData[size - 1] = null;//把数组中最后下标置空
size--;
return removeIndex;
}
@Override
public E set(int index, E e) {
checkIndex(index);
E oldE = (E) elementData[index];
elementData[index] = e;
return oldE;
}
@Override
public int size() {
return size;
}
@Override
public Object[] toArray() {
return Arrays.copyOf(elementData, size);//通过复制，产生新地址
}
@Override
public boolean isEmpty() {
if(size == 0) {
return true;
}
return false;
}
@Override
public boolean contains(Object o) {
for (int i = 0; i < size; i++) {
if(elementData[i].equals((E)o)) {
return true;
}
}
return false;
}
@Override
public MyList<E> subList(int start, int end) {
if(start > end) {
throw new ArrayIndexOutOfBoundsException(start + "必须小于" + end);
}
MyList<E> mylist = null;
for (int i = start; i <= end; i++) {
mylist.add(this.get(i));
}
return mylist;
}
@Override
public int indexOf(Object o) {
return isCheck((E)o,0);
}
@Override
public int lastIndexOf(Object o) {
int choice = -1;
for (int i = 0; i < size; i = choice + 1) {
choice = isCheck((E)o,i);
}
return choice;
}
@Override
public E get(int index) {
checkIndex(index);//检查下标
return (E)elementData[index];//返回指定下标的元素
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
