List
1)ArrayList (类似于数组,只是以一个集合元素的形式进行存储)
集合中,元素可以重复
add(); //追加元素,接受的是一个Object所以当使用原生数据类型的时候,需要包裹类,转换为类的对象,在使用转换成基本数据类型,进行输出
例子如下截图:
get(); //获取元素,返回的类型为Object,所以一般需要使用强制类型转换
remove(); //删除信息,使用索引删除信息的原理是删除后,后面的向前移动(注意再次使用的时候,下标越界);也可以使用直接输入元素进行删除(元素重复应该注意)
indexof(); //只要找到一个就返回了,后面有重复的也不在查找索引值了
toArray();
public Object[] toArray() //在最后类型转换的时候,Object[]不能转换为Integer[]
查看源代码得出:ArrayList的底层实现,是使用的一个Object[]数组实现的,各种方法和数组的算法类似,适合数据的搜索。
2) LinkedList
预备知识(链表---模仿北京圣思园)
a. 单向链表的例子
package com.Test.java;
public class Node {
String data;
Node next;
public Node() {
}
public Node(String data) {
this.data = data;
}
}
package com.Test.java;
public class NodeTest {
public static void main(String[] args) {
//不同单向链表的例子
Node node1 = new Node("node1");
Node node2 = new Node("node2");
Node node3 = new Node("node3");
node1.next = node2;
node2.next = node3;
System.out.println(node1.next.next.data);
System.out.println("------------------");
//在单向链表中添加一个节点
Node node4 = new Node("node4");
node1.next = node4;
node4.next = node2;
System.out.println(node1.next.next.next.data);
System.out.println("------------------");
//删除node4
node1.next = node2;
node4.next = null;
System.out.println(node1.next.next.data);
//循环单向链表
node3.next = node1;
System.out.println("------------------");
System.out.println(node1.next.next.next.data);
}
}
b. 双向链表的例子
package com.Test.java;
public class Node2 {
String data;
Node2 previous;
Node2 next;
public Node2(){
}
public Node2(String data) {
this.data = data;
}
}
package com.Test.java;
public class Node2Test {
public static void main(String[] args) {
//双向链表的例子
Node2 node1 = new Node2("node1");
Node2 node2 = new Node2("node2");
Node2 node3 = new Node2("node3");
//实现node1 and node2的双向循环
node1.next = node2;
node2.previous = node1;
//实现node2 and node3的双向循环
node2.next = node3;
node3.previous = node2;
//实现node3 and node1的双向循环
node3.next = node1;
node1.previous = node3;
System.out.println(node1.next.next.previous.previous.data);
System.out.println("------------------");
//添加一个node4插入到node1 and node2之间
Node2 node4 = new Node2("node4");
//实现node1 and node4的双向循环
node1.next = node4;
node4.previous = node1;
//实现node4 and node2的双向循环
node4.next = node2;
node2.previous = node4;
System.out.println(node1.next.next.previous.data);
System.out.println("-------------------");
//删除node4这个节点的链接
node1.next = node2;
node2.previous = node1;
node4.previous = null;
node4.next = null;
System.out.println(node1.next.next.previous.previous.data);
}
}
c. LinkedList对栈和队列的操作的例子
package com.Test.java;
import java.util.LinkedList;
/**
* 使用LinkedList,进行队列的操作
* @author 卢林
*/
public class QueueTest {
private LinkedList list = new LinkedList();
//实现队列的放入
public void put(Object o) {
list.addLast(o);
}
//实现队列的取出,因为要连续取出,所以不使用getFirst()
public Object get() {
return list.removeFirst();
}
//判断队列是否为空,如果为null,就返回true,反之,则返回false
public boolean isEmpty() {
return list.isEmpty();
}
public static void main(String[] args) {
QueueTest myQueue = new QueueTest();
//向队列中存放三个元素
myQueue.put("one");
myQueue.put("two");
myQueue.put("three");
//依次取出队列中的元素
System.out.println(myQueue.get());
System.out.println(myQueue.get());
System.out.println(myQueue.get());
//返回的队列是否为null的值
System.out.println(myQueue.isEmpty());
}
}
package com.Test.java;
import java.util.LinkedList;
/**
* 使用LinkedList,进行栈的操作
* @author 卢林
*/
public class StackTest {
private LinkedList list = new LinkedList();
//压栈的操作,放入第一个元素
public void push(Object o) {
list.addFirst(o);
}
/**
* 从栈中弹出最后放入的那个元素
* 因为是弹出,所以要进行删除操作
* @return return pop's first element
*/
public Object pop() {
return list.removeFirst();
}
/**
* 从栈中调用一下放入的最后一个元素
* 不进行删除操作
* 也可以使用getFirst(),效果一样
* 但是最好使用那个peekFirst()
* @return peek's first element
*/
public Object peek() {
return list.peekFirst();
}
//如果栈中元素为null就返回true,反之,则返回false
public boolean isEmpty() {
return list.isEmpty();
}
public static void main(String[] args) {
StackTest myStack = new StackTest();
//放置元素
myStack.push("a");
myStack.push("b");
myStack.push("c");
//取出被弹出栈的元素的值
System.out.println(myStack.pop());
System.out.println(myStack.pop());
System.out.println(myStack.pop());
//输出栈此时的状态(null or not null)
System.out.println(myStack.isEmpty());
System.out.println("---------------");
//重新压栈测试
myStack.push("a");
myStack.push("b");
myStack.push("c");
//进行调用,不删除的操作
System.out.println(myStack.peek());
System.out.println(myStack.peek());
System.out.println(myStack.peek());
//输出栈此时的状态(null or not null)
System.out.println(myStack.isEmpty());
}
}
查看源代码得出:LinkedList的底层是使用双向链表实现的,适合数据的删除和插入, LinkedList中所维护的是一个个的Entry对象。
由于以上代码有注解,所以就不文档说明了