2018-06-01 第二十六天
一、Vector
Vector和 ArrayList 的区别。
相同点:
1:都是List 的实现的子类。
2:元素都是有序,不唯一,可以是null
3:底层都是用数组实现。Object[]
不同点:
1:出现的jdk 版本不同; Vector---1.0 、ArrayList---1.2
2:Vector中包含的方法比ArrayList 更多一些。Vector包含了一些老旧的操作容器元素的方法。
3:Vector可以使用ArrayList 所有进行遍历的方式进行遍历,还可以使用Enumeration枚举器,进行遍历。ArrayList 不可以使用Enumeration。
4:ArrayList 的出现在一定程度上是为了在某些情况下对 Vector 类的替代使用。
5:Vector 的方法大都是线程安全的。效率相对较低。ArrayList 是线程非安全的,效率更高。因此ArrayList 在单线程情况下使用,更合适。
6:扩容的规则不同:Vector 每次扩容到现有容量的2倍,ArrayList 扩容到现有容量的1.5倍。
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class TestVector {
public static void main(String[] args) {
//底层使用数组作为数据结构存储元素
Vector vector = new Vector<>();
//扩容规则:每次扩容为现有容量的2倍。
for(int i=0;i<100;i++){
vector.add("1");
}
//添加元素
vector.addElement("abc");//早期的使用的方法
vector.add("qwe");
vector.add(1, "123");
vector.insertElementAt("456", 3);
//修改
vector.setElementAt("efg", 2);
vector.set(2, "china");
//删除
vector.removeElementAt(1);
vector.remove(null);
//获得
vector.get(0);
vector.elementAt(0);
//遍历 for
for(int i=0;i
vector.get(i);
}
//foreach
for (String string : vector) {
System.out.println(string);
}
//迭代器
Iterator iterator = vector.iterator();
while (iterator.hasNext()) {
String string = iterator.next();
System.out.println(string);
}
//使用枚举器 Enumeration 接口,有两个方法。
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
String string = elements.nextElement();
System.out.println(string);
}
System.out.println(vector);
}
}
二、自定义Iterator
import java.util.ArrayList;
import java.util.Iterator;
public class TestMyIterator {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
ArrayList list = new ArrayList(){
@Override
public Iterator iterator() {
//使用方法匿名内部类创建一个Iterator 的实例
Iterator iterator = new Iterator() {
//数组的索引,该值是否指向了一个存在的元素
private int cursor = 0;
@Override
public boolean hasNext() {
//System.out.println("1111111111111111");
return cursor < size();
}
//返回cursor 指向 元素,并cursor 后移
@Override
public String next() {
//System.out.println("2222222222222");
return (String)get(cursor++);
}
};
return iterator;
}
};
list.add("a");
list.add("a");
list.add("a");
list.add("a");
list.add("a");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String string = iterator.next();
System.out.println(string);
}
}
}
三、LinkedList
特点:元素有序,不唯一。
四、LinkedList 和 ArrayList 性能测试
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class TestLinkedList {
public static void main(String[] args) {
test1();
Test2();
test3();
test4();
}
static void test1(){
//LinkedList 和 ArrayList 性能 测试
//ArrayList 遍历的效率 远远高于 LinkedList
final int COUNT = 50000;
List list = new LinkedList<>();
List list1 = new ArrayList<>();
for(int i=0;i
list.add("1");
list1.add("1");
}
long time = System.currentTimeMillis();
//ArrayList
for(int i=0;i
list1.get(i);
}
System.out.println("ArrayList = "+(System.currentTimeMillis()-time));
time = System.currentTimeMillis();
//LinkedList
for(int i=0;i
list.get(i);
}
System.out.println("LinkedList = "+(System.currentTimeMillis()-time));
}
static void test2(){
//LinkedList 和 ArrayList 性能 测试
//ArrayList LinkedList 按照内容查找 效率差不多
final int COUNT = 1000000;
List list = new LinkedList<>();
List list1 = new ArrayList<>();
for(int i=0;i
list.add("1");
list1.add("1");
}
long time = System.currentTimeMillis();
//ArrayList
list1.contains("2");
System.out.println("ArrayList = "+(System.currentTimeMillis()-time));
time = System.currentTimeMillis();
//LinkedList
list.contains("2");
System.out.println("LinkedList = "+(System.currentTimeMillis()-time));
}
//插入元素效率测试
static void test3(){
//LinkedList 和 ArrayList 性能 测试
//ArrayList LinkedList 尾部添加元素 效率差不多
final int COUNT = 10000000;
List list = new LinkedList<>();
List list1 = new ArrayList<>();
long time = System.currentTimeMillis();
//ArrayList
for(int i=0;i
list1.add("1");
}
System.out.println("ArrayList = "+(System.currentTimeMillis()-time));
time = System.currentTimeMillis();
//LinkedList
for(int i=0;i
list.add("1");
}
System.out.println("LinkedList = "+(System.currentTimeMillis()-time));
}
static void test4(){
//LinkedList 和 ArrayList 性能 测试
//ArrayList LinkedList 头部添加元素 LinkedList效率更高
final int COUNT = 1000000;
List list = new LinkedList<>();
list.add("1");
List list1 = new ArrayList<>();
list1.add("1");
long time = System.currentTimeMillis();
//ArrayList
for(int i=0;i
list1.add(1,"1");
}
System.out.println("ArrayList = "+(System.currentTimeMillis()-time));
time = System.currentTimeMillis();
//LinkedList
for(int i=0;i
list.add(1,"1");
}
System.out.println("LinkedList = "+(System.currentTimeMillis()-time));
}
}
五、MySteak
import java.util.Arrays;
/**
* 自定义容器 模拟栈
* 底层使用数组来实现。Object
* 扩容规则 每次扩容到现有容量的1.5倍
*
*/
public class MyStack {
//定义栈的初始化容量
public static final int INIT_CAPACITY = 6;
//栈顶指针 所有对元素的操作都是 通过栈顶指针来完成的。
private int index;
//存放元素数组
private Object[] elementData;
public MyStack() {
elementData = new Object[INIT_CAPACITY];
index = 0;
}
public MyStack(int capacity) {
elementData = new Object[capacity];
index = 0;
}
/**
* 将 e 压入栈顶
* @param e
*/
public void push(E e){
if(isFull()){
//如果栈已满
//先生成一个1.5倍容量的新的数组,然后将原有的元素复制过来
Object[] temp = Arrays.copyOf(elementData, index *3 >>1);
//elementData 指向 新的数组
elementData = temp;
//将 e 装入栈顶
elementData[index] = e;
index ++;
}else{
//将 e 装入栈顶
elementData[index++] = e;
}
}
/**
* 弹栈操作
* @return
*/
public E pop() throws Exception{
if(isEmpty()){
Exception e = new Exception("囊中羞涩,别掏了!");
throw e;
}else{
//先指针下移
index --;
E e = (E)elementData[index];
elementData[index] = null;
return e;
}
}
/**
* 获取栈顶元素,但是不删除
* @return
*/
public E peek()throws Exception{
if(isEmpty()){
Exception e = new Exception("囊中羞涩,别摸了!");
throw e;
}else{
return (E)elementData[index-1];
}
}
/**
* 容器中是否包含 e
* @param e
* @return
*/
public boolean search(E e){
if(isEmpty())
return false;
//如果 e 是 null 判断 elementData 是否有null
if(e == null){
for(int i=0;i
if(elementData[i] == null)
return true;
}
}else{//e 不是null
for(int i=0;i
if(e.equals(elementData[i]))
return true;
}
}
return false;
}
/**
* 判断栈是否满了
* @return
*/
private boolean isFull(){
return index == elementData.length;
}
/**
* 栈是否为空
* @return
*/
public boolean isEmpty(){
return index == 0;
}
/**
* 得到元素的个数
* @return
*/
public int size(){
return index;
}
/**
* 容量
* @return
*/
public int capacity(){
return elementData.length;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(elementData, index));
}
}
六、接口ListIterator
Iterator 的子接口。
ListIterator:是专门针对 List 的子类使用的迭代器。
Iterator 是一次性失效的。而且只能单向的遍历。
ListIterator新增加的功能:
1:增加逆向的遍历元素的方式 hasPrevious() previous() 实现。
2:增加了修改 和 添加元素的方法。
ListIterator 不是一次性失效的,正向遍历之后,可以逆向遍历。
import java.util.ArrayList;
import java.util.ListIterator;
public class TestListIterator {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("China");
list.add("USA");
list.add("UK");
list.add("FR");
//得到容器的ListIterator 对象
ListIterator iterator = list.listIterator();
while (iterator.hasNext()) {
String str = iterator.next();
//让游标回退一格,并返回被跨越的对象
// iterator.previous();
if("USA".equals(str)){
iterator.set("CN-USA");//将当前next 方法返回的对象设置为指定的值
//在当前返回的对象后面的位置插入指定的值
iterator.add("CN-JP");
}
// iterator.hasPrevious();//判断是否有前元素
// iterator.nextIndex();//获得下一个元素的下标
// iterator.previousIndex();//获得前一个元素的下标
System.out.println(str);
}
System.out.println();
while (iterator.hasPrevious()) {
String string = iterator.previous();
System.out.println(string);
}
while (iterator.hasNext()) {
String string = iterator.next();
System.out.println(string);
}
System.out.println(list);
}
}