java第十五课

列表
AarrayList
变长的数组（增删改查）
执行实例化 new ArrayList，定义了一个空数组
添加数据
********Add 方法（增）
初始容量为 10，把空数组扩容，扩容到 10 个元素，
Arrays.copyOf
把其中的一个元素添加到数组中
面向对象编程： 一切皆对象，对象所有类的父类 Object
Class My extends Object{
}
Int 型不属于，java 把 int 写成类 Integer，int 简单类型，Integer
的简单类型的包装类
获取元素的方法
*********get(索引值)---查索引值从 0
开始计算索引
本来扩容了 10 个元素的数组，只有一部分有值，没有值就
是 null，官方源码中有一个 rangCheck(),方法不允许访问数组
中的空元素.
返回异常
return new Exception("Exception in thread \"main\"
java.lang.IndexOutOfBoundsException");

列表:
打印列表的变量名称时，输出列表中所有的元素。因为
ArrayList---AbastractArrayList--AbstractColection （ 重 写
toString()）
打印数组中元素是需要 Arrays.toString();
**********remove del（删）
remove 按照索引进行删除
[null,null,null,null,.....]
[1,2,3,4,5,6,7,8,null,null]
把索引为 2 的 3 元素去掉， 后面元素不会自动往前走
数组长度不变，把 4,5,6,7,8 往前走一个索引。后面多余的元
素还是 null
官方没有循环，使用
System.arraycopy(elementData, index+1,
elementData, index,
numMoved);
因为数组是定长，这里删除应该新的数组，这里只把元素做移动，
官方做移动的原理还是数组的拷贝，移动前后的数组本来是两个
数组，如果名称一致是一个数组，前面数组参数 index+1,删除
索引的后面元素， 后面元素相当于往前提一个位置，后面数组
参数 index，也就是前面数组元素的 index+1 覆盖后面数组元
素 index

System.arraycopy(elementData, index+1, elementData, index,
numMoved);
总结：
数组扩容： Arrays.copyOf
数组的删除：System.arraycopy
*******修改
数组本身具体数据的修改
修改使用 set
列表中其它方法
列表长度使用
Size( )底层记录列表的长度就是 size
isEmpty（）判断当前列表是否为空
indexOf 判断当前列表中是否有某个元素
lastIndexOf 底层是倒序遍历
clone()克隆：底层就是执行 Arrays.copyOf 又产生一个数
组
在 Arrays.copyOf 中的底层还是调用 System.copyOf
toArray（） 把当前的列表转成数组，底层还是用的
Arrays.copy
clear()把列表清空
for 循环，把所有的列表元素置 null，size 置 0
removeAll 移除所有的元素
listIterator 把所有的迭代器显示

iterator() 获取列表的迭代器
subList，从某一个索引到某一个索引取子列表
forEach 进行遍历
replace 替换方法，替换所有的元素
replaceAll
sort 排序调用的 Arrays.sort 排序方法.
仿造官方 ArrayList 写一个自己的 ArrayList.
在 AbstractArrayList
Get 方法没实现:
abstract public E get(int index);
试验一下
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
indexOf 在 AbstractArrayList 中实现
直接在 Abstract 实现.记住(官方在 Abstract 中的做的迭代
器,官方在 ArrayList 作的是循环)
Abstract 里面调用方法
public void clear() {
removeRange(0, size());
}
在 abstract 里面重写 equals,双重 for 循环比较
hashCode 都重写的，列表的算法与 String 算法相同
在 clear 方法中调用了
protected void removeRange(int fromIndex, int toIndex) {
ListIterator<E> it = listIterator(fromIndex);
for (int i=0, n=toIndex-fromIndex; i<n; i++) {
it.next();

it.remove();
}
}
上层是 abstractCollection
重写 contains
toArray
remove 方法在 abstractCollection 也实现了
containsAll 包含所有元素
removeAll 把所有元素清除
Collection 接口方法
int size();
boolean isEmpty();
boolean contains(Object o);
Object[] toArray();
boolean add(E e);
boolean remove(Object o);
boolean removeAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();
List 接口
int size();
boolean isEmpty();
boolean contains(Object o);

Iterator<E> iterator();
Object[] toArray();
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean removeAll(Collection<?> c);
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
boolean equals(Object o);
int hashCode();
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
void clear();

代码详见：Java第十七课 · Fang-fang/方芳 的java - Gitee.com