一. 总结
1.Array List中引入capacity和size的概念,capacity表示数组容量,对于用户来说没有意义
size表示实际元素数量,供用户读取,该值被设置为private,防止用户肆意篡改,但是剋以
通过size()获取
2.capacity的初始值可以有用户指订,如果没有 系统默认为10
3.modCount的作用
用于存储当前ArrayList结构的修改次数
4.Arraylist以1.5倍的扩容方式去扩容
5.Max_ARRAY_SIZE=Integer.MAX_VALUE-8
数组的对象头-length 表示数组的长度
1.总结数组和ArrayList区别和联系
a. 数组和ArrayList都表示可以存一组同类型的对象;都使用下标定位和查找元素;
b. 数组的定义:
int[] num=new int[10];
Employee[] staff=new Employee[100];
c. ArrayList的使用:
List list=new ArrayList();
list.add();
1. List和ArrayList的区别和联系.
联系:两者都继承了IList接口
区别:1.ArrayList不是类型安全的,而List已经声明过其数据的对象类型,是类型安全的
2.ArrayList为了兼容所有类型对象,使用了Object数组,在使用元素的时候会有装箱和拆箱的操作
3.ArrayList只有把元素添加进去之后才可以通过下标访问相应的元素.
4.数组在创建的时候就已经确定了数据类型,并且它的长度是固定的,只能通过下标改变各个元素的值和访问.
2.Vector和ArrayList区别和联系
相同:ArrayList和Vector底层数据结构相同也是一个动态数组存放数据。都实现了List等接口。
当两者容量不够时,都会进行对Object数组的扩容
异处:Vector是一个同步容器并不是一个并发容器。而ArrayList是一个支持并发的容器。
二.1 ArrayList的属性及构造函数:
class MyArrayList<T>{
private T[] elements;
private int size;
public MyArrayList(){
this(5);
}
public MyArrayList(int capacity){
elements=(T[])new Object[capacity];
}
ArrayList底层实现就是数组;
无参构造函数,初始化默认数组大小为5;
有参构造,创建一个长度为capacity的Object类型的数组;
2.checkIndex方法判断合法性;
public void checkIndex(int index){
if(index<0||index>elements.length){
throw new UnsupportedOperationException("the index is illegal");
}
}
3.自定义添加数据方法:add();
public void add(T value){
//判断是否需要扩容
if(size==elements.length){
this.elements= Arrays.copyOf(this.elements,this.elements.length*2);
}
//添加元素
elements[size++]=value;
}
Arrays.coypyOf方法扩容数组;
Arrays.copyOf(原数组,当前扩容数组长度);
4.自定义删除数据方法:remove();
public boolean remove(int index){
try{
checkIndex(index);
System.arraycopy(this.elements,index+1,this.elements,index ,size-1-index);
elements[--size]=null;
return true;
}catch(UnsupportedOperationException e){
System.out.println(e.getMessage());
return false;
}
}
首先判断下标是否存在,如果不存在则抛出异常;
存在则将当前坐标下的数据删除,后面的数据往前移动;
elements[--size] = null; 方便垃圾回收;
5.自定义改变数据方法:set();
public void set(int index,T newValue) {
try {
checkIndex(index);
elements[index] = newValue;
} catch (UnsupportedOperationException e) {
System.out.println(e.getMessage());
}
}
先判断下标是否存在,再将新值覆盖旧值;
6.自定义查找数据方法:get();
public T get(int index) {
try {
checkIndex(index);
return elements[index];
} catch (UnsupportedOperationException e) {
System.out.println(e.getMessage());
return null;
}
}
判断下标是否存在,如若不存在,则抛出异常;反之如果查找的下标下存在数据,则返回坐标下的数据,否则返回null;
7.自定义重写方法:toString();
public String toString(){
StringBuilder strs=new StringBuilder();
for(int i=0;i<size;i++){
strs.append(elements[i]+" ");
}
return strs.toString();
}
三.自定义LinkedList:
LinkedList的属性及构造函数:
class MyLinkedList<E>{
protected Node<E> first; //指向链表的第一个元素
protected Node<E> last; //指向链表的最后一个元素
protected int size; //当前链表的元素个数
class Node<E>{
private E data; //元素内容
private Node<E> prev; //前驱引用
private Node<E> next; //后驱引用
public Node(E data, Node<E> prev, Node<E> next) {
this.data = data;
this.prev = prev;
this.next = next;
}
}
LinkedList底层使用链表实现;
2.尾插法添加元素:
public void add(E value){
Node<E> tmp = last;
Node<E> newNode = new Node<>(value, tmp, null);
last = newNode;
if(tmp == null){
first = newNode;
}else{
tmp.next = newNode;
}
size++;
}
定义tmp保存last节点,再定义一个新的节点,在链表尾部增添元素;
3.在指定位置添加元素:
public void add(int index, E value){
if(index < 0 || index > size){
return;
}
if(index == size){
add(value);
}else{
Node<E> succ = findNodeByIndex(index);
Node<E> succPre = succ.prev;
Node<E> newNode = new Node(value, succPre, succ);
succ.prev = newNode;
if(succPre == null){
//说明原先链表只有一个节点
first = newNode;
}else{
succPre.next = newNode;
}
}
size++;
}
public Node<E> findNodeByIndex(int index){
Node<E> tmp = first;
for(int i=0; i<index; i++){
tmp = tmp.next;
}
return tmp;
}
定义方法findNodeByIndex判断下标是否合法,再定义succ,succPre和一个newNode保存添加的元素,
succ.prev = newNode; succPre.next = newNode;
4.删除元素:
public boolean remove(E value){
Node<E> succ = findNodeByValue(value);
if(succ == null){
return false;
}
//考虑删除的是第一个元素和最后一个元素的情况
Node<E> succPrev = succ.prev;
Node<E> succNext = succ.next;
if(succPrev == null){
first = succNext;
}else{
succPrev.next = succNext;
succ.prev = null;
}
if(succNext == null){
last = succPrev;
}else{
succNext.prev = succPrev;
succ.next = null;
}
succ.data = null;
size--;
return true;
}
public Node<E> findNodeByValue(E value){
for(Node<E> tmp=first; tmp!=null; tmp=tmp.next){
if(value.equals(tmp.data)){
return tmp;
}
}
return null;
}
先定义方法判断想要删除的元素是否存在,然后考虑删除的是第一个元素还是最后一个元素;
5.得到某一坐标下元素的值:
public E get(int index){
Node<E> tmp = first;
for(int i=0; i<index; i++){
tmp = tmp.next;
}
if(tmp != null){
return tmp.data;
}
return null;
}
6.重写toString方法:
public String toString(){
StringBuilder strs = new StringBuilder();
Node<E> tmp = first;
for(; tmp != null; tmp = tmp.next){
strs.append(tmp.data + " ");
}
return strs.toString();
}
使用StringBuilder中的append方法进行重写;