写的不够好，有错误请指出QAQ
例题
Description
给你一个线性表，请你编程完成所要求的操作.
Input
只有一个案例,第1个数是n，接着有n行数据。
接着输入m，有m个数据要插入，每行的第1个数是要插入的位置，小于0的插入到第0行，大于等于n的插入到最后。
再接着输入一个数k，表示后面有p个数要删除。p个整数是要删除的序号。
再再接着输入一个整数q，有q个关键字，找到就输出有这关键字的数据。
Ouput
输出操作的结果，格式见样例。
Sample Input
4
1001 Li m SMU Computer
1003 Wang f FZU English
1004 Chen f PKU Geography
1005 Zhao m ZJU Information
2
3 1008 Jian m HDU Computer
6 1009 Jun m ZJU English
1
3
2
ZJU
English
Sample Output
最初的线性表是：
ID-1001，name-Li，sex-m，School-SMU，major-Computer.
ID-1003，name-Wang，sex-f，School-FZU，major-English.
ID-1004，name-Chen，sex-f，School-PKU，major-Geography.
ID-1005，name-Zhao，sex-m，School-ZJU，major-Information.
插入2个数据后的线性表是：
ID-1001，name-Li，sex-m，School-SMU，major-Computer.
ID-1003，name-Wang，sex-f，School-FZU，major-English.
ID-1004，name-Chen，sex-f，School-PKU，major-Geography.
ID-1008，name-Jian，sex-m，School-HDU，major-Computer.
ID-1005，name-Zhao，sex-m，School-ZJU，major-Information.
ID-1009，name-Jun，sex-m，School-ZJU，major-English.
删除1个数据后的线性表是：
ID-1001，name-Li，sex-m，School-SMU，major-Computer.
ID-1003，name-Wang，sex-f，School-FZU，major-English.
ID-1004，name-Chen，sex-f，School-PKU，major-Geography.
ID-1005，name-Zhao，sex-m，School-ZJU，major-Information.
ID-1009，name-Jun，sex-m，School-ZJU，major-English.
查找"ZJU"的结果是:
ID-1005，name-Zhao，sex-m，School-ZJU，major-Information.
ID-1009，name-Jun，sex-m，School-ZJU，major-English.
查找"English"的结果是:
ID-1003，name-Wang，sex-f，School-FZU，major-English.
ID-1009，name-Jun，sex-m，School-ZJU，major-English.
此时线性表的长度是5.
Hint
请按规范的要求写，处理线性表的类用泛型。
4//原线性表
1001 Li m SMU Computer
1003 Wang f FZU English
1004 Chen f PKU Geography
1005 Zhao m ZJU Information
2//要插入的线性表
3 1008 Jian m HDU Computer
6 1009 Jun m ZJU English
1//删除的个数
3//删除的序号，从0开始。
2//查找的个数，以下是查找的关键字。
ZJU
English
代码
我的代码
package 线性表的操作;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int n = in.nextInt();
Student[] st = new Student[n];
for(int i=0;i<n;i++) {
st[i] = new Student(in.next(),in.next(),in.next(),in.next(),in.next());
}
SeqList<Student> sl = new SeqList<Student>(st);
System.out.println("最初的线性表是：");
for(int i = 0;i<sl.length();i++) {
System.out.println(sl.element[i]);
}
int m = in.nextInt();
for(int i=0;i<m;i++) {
int x = in.nextInt();
Student sst = new Student(in.next(),in.next(),in.next(),in.next(),in.next());
sl.insert(sst, x);
}
System.out.println("插入"+m+"个数据后的线性表是：");
/*从这开始就不能使用sl.length()【这里的sl.length()==n，是线性表数据的个数，不包括null的】了，否则会报错，因为插入了该题目的数据后，
* 中间有的数据为null，sl.length()就变了，所以要用数据数组的长度【包含有null的】——以后不要取这种容易混淆的名字了，害我改了半天*/
for(int i = 0;i<sl.element.length;i++) {
if(sl.element[i]!=null)
System.out.println(sl.element[i]);
}
int k = in.nextInt();
for(int i=0;i<k;i++) {
sl.delete(in.nextInt());
}
System.out.println("删除"+k+"个数据后的线性表是：");
for(int i = 0;i<sl.element.length;i++) {
if(sl.element[i]!=null)
System.out.println(sl.element[i]);
}
int q = in.nextInt();
for(int i=0;i<q;i++) {
String key = in.next();
System.out.println("查找\""+key+"\"的结果是:");
sl.search(key);
}
System.out.println("此时线性表的长度是"+sl.length()+".");
}
}
class Student{
protected String id;
protected String name;
protected String sex;
protected String school;
protected String major;
public Student(String id, String name, String sex, String school, String major) {
this.id = id;
this.name = name;
this.sex = sex;
this.school = school;
this.major = major;
}
public String toString() {
return "ID-"+this.id+"，name-"+this.name+"，sex-"+this.sex+"，School-"+this.school+"，major-"+this.major+".";
}
}
class SeqList<T>{
protected Object[] element;
protected int n;
public SeqList(int length) {
this.element = new Object[length];
this.n = 0;
}
public SeqList() {
this(32);
}
public SeqList(T[] values) {
//由values数组提供元素，忽略其中空对象
this(values.length*2);
for(int i=0;i<values.length;i++) {
if(values[i]!=null) {
this.element[this.n++] = values[i];//使用this.n++改变n的值，用于记录顺序表的数据元素个数
}
}
}
public void insert(T x,int i) {
//插入，x为插入数据，i为插入位置
Object[] source = this.element;
// if(i>this.n) {
// i=this.n;
// }
if(this.n==element.length) {
//如果数组满了，需扩充数组容量
this.element = new Object[source.length*2];
for(int j=0;j<i;j++) {
//复制数组中前i个数据
element[j] = source[j];
}
}
for(int j=this.n-1;j>=i;j--) {
//从i开始到表尾的元素向后移，次序从后往前放入
this.element[j+1] = source[j];
}
this.element[i] = x;
this.n++;
}
public void delete(int i) {
//删除，i为删除位置
if(i>0&&i<this.n) {
//为什么是this.n-1？
for(int j=i;j<this.n-1;j++) {
//元素前移一个位置
this.element[j] = this.element[j+1];
}
this.element[this.n-1]=null;
this.n--;
}
}
public void search(String key) {
//查找
//n是线性表的长度，element.length是数组的长度，这里不能用i<this.n
for(int i = 0;i<element.length;i++) {
//if(this.element[i].toString().indexOf(key)!=-1&&this.element[i]!=null)会出问题
if(this.element[i]!=null && this.element[i].toString().indexOf(key)!=-1)
System.out.println(this.element[i].toString());
}
}
public int length() {
return this.n;
}
}
同学的代码
import java.util.Scanner;
class SeqList<T> extends Object{
protected int n; //顺序表元素个数
protected Object[] element;//对象数组存储顺序表的数据元素，保护成员
private static int MIN_CAPACITY=16;//指定数组element的容量最小值
public SeqList(int length) {//构建空顺序表
if(length<MIN_CAPACITY) {
length = MIN_CAPACITY;
}
this.element = new Object[length];
this.n = 0;
}
public SeqList() {
this(MIN_CAPACITY);
}
public SeqList(T[] values) {//由values数组提供元素，忽略其中空对象
this(values.length);
for(int i=0;i<values.length;i++) {//复制非null的数组元素
if(values!=null) {
this.element[this.n++]=values[i];//使用this.n++改变n的值，用于记录顺序表的数据元素个数
}
}
}
public int length() {
return this.n;
}
public void search(String key) {//查,直接输出
for (int i = 0; i <this.n; i++) {
if ((this.element[i]).toString().indexOf(key) != -1
&& this.element[i]!=null) {
System.out.println(this.element[i].toString());
}
}
}
public int insert(int i,T x) {//插
if(x==null){
return -1;
}
if(i<0) {
i=0;
}
if(i>this.n) {
i=this.n;
}
Object[] source = this.element;
if(this.n==element.length) {
this.element = new Object[source.length*2];
for(int j=0;j<i;j++) {
this.element[j] = source[j];
}
}
for(int j=this.n-1;j>=i;j--) {
this.element[j+1] = source[j];
}
this.element[i]=x;
this.n++;
return i;
}
public int insert(T x) {
return this.insert(this.n, x);
}
public T remove(int i) {//删除数据
if(i>=0&&i<this.n) {
T x = (T)this.element[i];
for(int j=i;j<this.n-1;j++) {
this.element[j] = this.element[j+1];
}
this.element[this.n-1]=null;
this.n--;
return x;
}
return null;
}
public void clear() {
this.n=0;
}
}
class Data{
private String id;
private String name;
private String sex;
private String school;
private String major;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public Data() {
}
public Data(String id,String name,String sex,String school,String major) {
this.id = id;
this.name = name;
this.school = school;
this.sex = sex;
this.major = major;
}
public String toString() {
return "ID-"+this.id
+"，name-"+this.name
+"，sex-"+this.sex
+"，School-"+this.school
+"，major-"+this.major+".";
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int n = in.nextInt();//第一次添加数据
Data[] data = new Data[n];
for(int i=0;i<n;i++) {
data[i] = new Data(in.next(),in.next(),in.next(),in.next(),in.next());
}
SeqList<Data> seqlist = new SeqList<Data>(data);
System.out.println("最初的线性表是：");
for(int i=0;i<seqlist.length();i++) {
System.out.println(seqlist.element[i]);
}
int m = in.nextInt();//第二次添加数据
for(int i=0;i<m;i++) {
int addid = in.nextInt();
Data dataone = new Data(in.next(),in.next(),in.next(),in.next(),in.next());
seqlist.insert(addid, dataone);
}
System.out.println("插入2个数据后的线性表是：");
for(int i=0;i<seqlist.element.length;i++) {
if(seqlist.element[i]!=null) {
System.out.println(seqlist.element[i]);
}
}
int sub = in.nextInt();//删除数据
for(int i=0;i<sub;i++) {
int subid = in.nextInt();
seqlist.remove(subid);
}
System.out.println("删除"+sub+"个数据后的线性表是：");
for(int i=0;i<seqlist.element.length;i++) {
if(seqlist.element[i]!=null) {
System.out.println(seqlist.element[i]);
}
}
int seek = in.nextInt();//查找
for(int i=0;i<seek;i++) {
String key = in.next();
System.out.println("查找\""+key+"\"的结果是: ");
seqlist.search(key);
}
System.out.println("此时线性表的长度是"+seqlist.length()+".");
}
}
}
小结
我把sl.length()【这个其实是n——线性表数据的个数】和sl.element.length搞混，结果一直抛出空指针错误，以后再也不去这种名字了！！害我改了半天淦！说到底还是基础不扎实，是该补一补
1.【Java】length和length()的区别
查找方法的那里如果是if(this.element[i].toString().indexOf(key)!=-1 && this.element[i]!=null)会出问题，交换了条件位置就没问题了，不知道为什么我同学的代码这样写没有问题？？？搞不懂搞不懂