一、概述
顺序表是逻辑结构上连续,物理结构上也连续的,一般由数组的形式存储
二、简单的方法实现
java
public class MyArrayList implements IList{
public int[] elem;
public int usedSize;
public static final int DEFAULT_CAPACITY=10;
public MyArrayList() {
this.elem = new int[DEFAULT_CAPACITY];
}
@Override
public void set(int pos, int data) {
if (isEmpty()){
throw new EmptyListExpection(Constant.EMPTY_LIST);
}
checkPosAdd(pos,"位置不合法");
elem[pos] =data;
}
@Override
public void remove(int toRemove) {
if (isEmpty()){
throw new EmptyListExpection(Constant.EMPTY_LIST);
}
int index=indexOf(toRemove);
if (index == -1){
System.out.println("没有找到需删除的数据");
return;
}
for (int i = index; i <usedSize-1 ; i++) {
elem[i] = elem[i+1];
}
//如果删除的是引用类型,就需要置为空
//elem[usedSize] = null;
usedSize--;
}
@Override
public void add(int pos, int data) {
//判断是不是满的
if (isFull()){
grow();
}
checkPosAdd(pos,"pos位置不合法");
//1.判断是否放在最后一位上
if (pos == usedSize){
elem[pos] = data;
usedSize++;
return;
}
//2.如果在中间就需要移动数据
for (int i =usedSize-1;i>=pos;i--){
elem[i+1] =elem[i];
}
elem[pos] =data;
}
private void checkPosAdd(int pos,String msg){
if (pos< 0||pos >usedSize){
throw new PosIllegalityException(msg);
}
}
@Override
public void add(int data) {
//1.判断顺序表是否满了
if(isFull()){
grow();
}
//2.如果满了,就进行扩容
this.elem[this.usedSize]=data;
this.usedSize++;
}
private boolean isFull(){
return this.usedSize == elem.length;
}
private void grow(){
this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
}
@Override
public int get(int pos) {
if (isEmpty()){
throw new EmptyListExpection(Constant.EMPTY_LIST);
}
checkPos(pos,"当前给出的位置不合法");
return this.elem[pos];
}
private boolean isEmpty(){
return usedSize == 0;
}
private void checkPos(int pos,String msg){
if (pos<0 || pos >= usedSize){
throw new PosIllegalityException(msg);
}
}
@Override
public int indexOf(int toFind) {
for (int i = 0 ;i<usedSize;i++){
if (this.elem[i]==toFind){
return i;
}
}
return -1;
}
@Override
public boolean contain(int toFind) {
for (int i = 0; i <usedSize ; i++) {
if (this.elem[i] == toFind){
return true;
}
}
return false;
}
@Override
public void display() {
for (int i = 0;i<usedSize;i++){
System.out.print(this.elem[i]+" ");
}
System.out.println();
}
@Override
public int size() {
return this.usedSize;
}
}三、顺序表的三种构造方法
无参数的构造方法
java
ArrayList<Integer> list = new ArrayList<>();对于没有参数的构造方法来说,默认分配的数组大小为10;
之后扩容就是1.5倍的扩容
有一个参数的构造方法
(1)参数是填写顺序表的容量
java
ArrayList<Integer> list2 = new ArrayList<>(66);(2)参数是填写作为实现Collention的接口都可以填写且数据类型必须是该顺序表的本身或者子类
(用其他的集合类来构造一个顺序表)
java
ArrayList<Integer> list3 = new ArrayList<>();
ArrayList<Integer> list4 = new ArrayList<>(list3);四、真正顺序表的方法使用
java
ArrayList<Integer> list = new ArrayList<>();
list.add(5);
list.add(1,6);
list.add(7);
list.add(8);
List<Integer> sub =list.subList(1,3);
System.out.println(sub);
list.add(1,895);
System.out.println(list);
// Integer ii =6;
// list.remove(ii);
// list.remove(new Integer(6));
// System.out.println(list);
// ArrayList<Integer> list2 = new ArrayList<>();
// list2.add(99);
// list2.addAll(list);
// System.out.println(list2);五、顺序表的三种遍历方式
for循环遍历
java
ArrayList<Integer> list =new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
for (int i = 0; i < list.size(); i++) {
Integer a =list.get(i);
System.out.print( a +" ");
}
System.out.println();for-each遍历
java
for (int x: list) {
System.out.print(x+" ");
}
System.out.println();使用迭代器遍历
java
Iterator<Integer> it=list.iterator();
while(it.hasNext()){
System.out.print(it.next()+" ");
}
System.out.println();
System.out.println("=========迭代器2==========");
//从指定位置打印
ListIterator<Integer> it2 =list.listIterator(2);
while(it2.hasNext()){
System.out.print(it2.next()+" ");
}
System.out.println();
System.out.println("=========迭代器3===========");
//从后往前打印
ListIterator<Integer> it3 =list.listIterator(list.size());
while(it3.hasPrevious()){
System.out.print(it3.previous()+" ");注:只要实现了Interable接口都可以使用迭代器遍历