主要内容
- 容器的简介
- ArrayList简介
- 手写模仿ArrayList
- 手写模仿LinkedList
笔记详情
容器的简介
容器即Collection，它表示一组对象，他是集中、收集的意思，就是把一些数据收集起来。Collection函数库是Java.util包下的一些类和接口，其中类是用来产生对象存放数据用的，接口是访问数据的方法。
Collection接口中定义了一些基本的访问方法，这样我们就有了统一的方式，通过Collection和它的子接口来访问数据。Collection有很多子接口，其中比较重要和常用的有set和list接口。set接口的特点是：无序，元素不可重复；list接口的特点是：有序，元素可重复。
ArrayList简介
ArrayList继承自接口list，它的底层实现是数值，所以查询数据的时候很很快的，但是修改，插入和删除数据的时候会慢一些。与它同级的还有LinkedList，它的底层实现是链表，数据查询慢，数据修改、插入和删除快；这两者的共同特点是线程不安全，但是效率高，与它们同级的Vector线程安全，效率低。
下面是ArrayList的一些用法简介：
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class Test01 {
public static void main(String[] args) {
List list = new ArrayList();
// 向容器中添加元素，添加的元素都是对象
list.add("fengzhen");
list.add("Tom");
list.add(1234); // 包装类，自动封箱，变成对象
list.add(new Date());
list.add(new Dog()); // 自定义的类
System.out.println(list.size()); // 容器中元素的个数，目前是5
// 移除容器中的对象，注意只是从容器中移除，并没有删除
list.remove("fengzhen");
list.remove(new Date()); // 这个对象和之前的new Date()对象并不是一个，所以之前的new Date()对象不会被移除
System.out.println(list.size()); // 成功移除了一个对象，目前是4
// 获取容器中的对象
String strName = (String) list.get(0); // 明确是什么类型，可以强制转型
Object c = list.get(1);
}
}
class Dog {
String dogName;
}
手写模仿ArrayList
package fengzhen.collectionBase;
public class MyArrayList {
private Object elementData[];
private int size; // 容器中元素的个数
public MyArrayList() {
this(3);
}
public MyArrayList(int listSize) {
if (listSize < 0) {
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
elementData = new Object[listSize];
}
// 向容器中添加元素
public void add(Object newElement) {
// 根据条件判断是否进行扩容
if (size == elementData.length) {
int newSize = size * 2 + 1;
Object newElementData[] = new Object[newSize];
for (int i = 0; i < elementData.length; i++) {
newElementData[i] = elementData[i];
}
this.elementData = newElementData;
}
elementData[size++] = newElement;
}
// 向容器中添加元素
public void add(int index, Object obj) {
if (index < 1 || index > size) {
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
System.arraycopy(elementData, index - 1, elementData, index, size - index + 1);
elementData[index-1] = obj;
}
// 从容器中移除元素
public Object remove(int index) {
rangeCheck(index);
for (int i = index; i < size - 2; i++) {
elementData[i] = elementData[i + 1];
}
size--;
return elementData[index];
}
// 从容器中移除元素
public Object remove(Object obj) {
for (int i = 0; i < size; i++) {
if (elementData[i].equals(obj)) {
remove(i);
return obj;
}
}
return obj;
}
// 从容器中获取元素
public Object get(int index) {
rangeCheck(index);
return elementData[index];
}
public int size() {
return size;
}
public boolean isEmpty() {
if (size == 0) {
return true;
}
return false;
}
// 检测传入的index是否越界
public void rangeCheck(int index) {
if (index < 0 || index >= size) {
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
手写模仿LinkedList
package fengzhen.collectionBase;
public class MyLinkedList {
private int size;
Node first;
Node last;
// 向容器中添加元素
public void add(Object obj) {
Node newNode = new Node();
if (first == null) {
newNode.setBefore(null);
newNode.setValue(obj);
newNode.setNext(null);
first = newNode;
last = newNode;
} else {
newNode.setBefore(last);
newNode.setValue(obj);
newNode.setNext(null);
last.setNext(newNode);
last = newNode;
}
size++;
}
// 向容器中添加元素
public void add(int index, Object obj) {
if (index < 0 || index > size) {
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
if (index == 0) { // 在链表的最前面插入
Node newFirst = new Node();
newFirst.setBefore(null);
newFirst.setValue(obj);
newFirst.setNext(first);
first = newFirst;
size++;
} else {
Node temp = node(index - 1);
if (temp.getNext() == null) { // 在链表的最后面插入
this.add(obj);
} else {
Node before = temp;
Node next = temp.getNext();
Node newNode = new Node();
newNode.setValue(obj);
newNode.setBefore(before);
newNode.setNext(next);
before.setNext(newNode);
next.setBefore(newNode);
size++;
}
}
}
// 从容器中移除元素
public void remove(int index) {
Node temp = node(index);
if (index == 0) { // 删除第一个元素
first = first.getNext();
first.setBefore(null);
} else if (index == size - 1) { // 删除最后一个元素
last = last.getBefore();
last.setNext(null);
} else {
Node before = temp.getBefore();
Node next = temp.getNext();
before.setNext(next);
next.setBefore(before);
}
size--;
}
// 根据传入的索引，获取对应的节点
public Node node(int index) {
Node temp = first;
if (first != null) {
for (int i = 0; i < index; i++) {
temp = temp.getNext();
}
}
return temp;
}
// 从容器中获取元素
public Object get(int index) {
Node temp = first;
if (index < 0 || index >= size) {
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
temp = node(index);
return temp.getValue();
}
// 返回容器的元素个数
public int size() {
return size;
}
}