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);

}

}

 

 

转载于:https://my.oschina.net/u/3854538/blog/1822822