ArrayList类:
特点:
1.底层依赖数组实现,数组的添加删除等操作依赖动态扩容
2.可以存储null值
3.线程不安全,效率高
4.元素可重复
5.增加和删除效率低,查询和修改效率高
什么是数据结构?--数据存储方式
数据的存储方式具体是看集合是怎么添加的
研究ArrayList的add方法即可
package com.sxt.listsondemo;
import java.util.ArrayList;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("张三");
list.add("王五");
list.add(null);
// list.add(null);
System.out.println(list);
// 去除重复元素
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i+1; j < list.size(); j++) {
if (list.get(i).equals(list.get(j))) {
list.remove(j);
j--;
}
}
}
System.out.println(list);
}
}
Vecotor类:
特点:
1.底层依赖数组实现,数组的添加删除等操作依赖动态扩容
2.可以存储null值
3.线程安全,效率低
4.元素可重复
5.增加和删除效率低,查询和修改效率高
6.本质就是旧版的ArrayList,有很多自己旧版的增删查改的方法
以及旧版迭代器
方法:
E elementAt(int index)
Enumeration<E> elements()
E firstElement()
E lastElement()
void addElement(E obj)
void insertElementAt(E obj, int index)
void removeAllElements()
void removeElementAt(int index)
void setElementAt(E obj, int index)
vector几种遍历方式
1.toArray
2.迭代器
while/for
3.foreach
4.普通for get+size
5.列表迭代器
正向 逆向 从任意位置,任意区间迭代
6.旧版普通for
7.旧版迭代器
AbstractCollection 的toString方法
package com.sxt.listsondemo;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("隔壁老王");
v.addElement("隔壁老李");
v.addElement("隔壁老周");
v.addElement("隔壁老孙");
Iterator it = v.iterator();
// while (it.hasNext()) {
// System.out.println(it.next());
// }
// Enumeration et = v.elements();
// while (et.hasMoreElements()) {
// System.out.println(et.nextElement());
// }
// for (int i = 0; i < v.size(); i++) {
// System.out.println(v.elementAt(i));
// }
System.out.println(v.firstElement());
System.out.println(v.lastElement());
}
}
Stack:栈结构集合
栈结构集合 Stack
特点:
1.底层数据结构是栈结构的集合,先进后出 后进先出
2.继承自Vector类,也有自己栈结构所有特有的方法
方法:
boolean empty()
测试此堆栈是否为空。
E peek()
查看此堆栈顶部的对象,而不从堆栈中删除它。
E pop() 取
删除此堆栈顶部的对象,并将该对象作为此函数的值返回
E push(E item) 存
将项目推送到此堆栈的顶部。
int search(Object o)
返回一个对象在此堆栈上的基于1的位置。
EmptyStackException: 空栈异常
产生原因:栈中没有元素可以取出
解决办法:弹栈之前做相应的判断
vector几种遍历方式
1.toArray
2.迭代器
while/for
3.foreach
4.普通for get+size
5.列表迭代器
正向 逆向 从任意位置,任意区间迭代
6.旧版普通for
7.旧版迭代器
8.栈结构遍历方式
package com.sxt.listsondemo;
import java.util.Stack;
public class StackDemo {
public static void main(String[] args) {
Stack s = new Stack();
// s.add("A");
// s.add("B");
// s.add("C");
s.push("A");
s.push("B");
s.push("C");
// System.out.println(s);
// Object e = s.pop();
// System.out.println(e);
// System.out.println(s.pop());
// System.out.println(s.pop());
// System.out.println(s.pop());
// if (!s.isEmpty()) {
// System.out.println(s.pop());
// }
//
// while (!s.isEmpty()) {
// System.out.println(s.pop());
// }
// System.out.println(s.peek()); // C
// System.out.println(s.pop());
// System.out.println(s);
//
// System.out.println(s.peek()); // B
// System.out.println(s);
// 查看栈中索引
System.out.println(s.search("A"));
s.pop();
System.out.println(s.search("A"));
}
}
Queue:队列
队列结构的集合: Queue
特点:
1.底层数据结构是队列,先进先出
抛出异常 返回特殊值
插入 add(e) offer(e)
移除 remove() poll()
检查 element() peek()
package com.sxt.listsondemo;
import java.util.ArrayDeque;
import java.util.Queue;
public class QueueDemo {
public static void main(String[] args) {
Queue queue = new ArrayDeque();
// queue.add("A");
// queue.add("B");
// queue.add("C");
// queue.clear();
// System.out.println(queue.element());
// System.out.println(queue.remove());
queue.offer("A");
queue.offer("B");
queue.offer("C");
queue.clear();
System.out.println(queue.poll());
System.out.println(queue.peek());
}
}
Deque双端队列
双端队列结构的集合
Deque
特点:
1.底层数据结构是双端队列
双端队列结构的集合
Deque
特点:
1.底层数据结构是双端队列
堆栈方法 等效 Deque 方法
push(e) addFirst(e)
pop() removeFirst()
peek() peekFirst()
vector几种遍历方式
1.toArray
2.迭代器
while/for
3.foreach
4.普通for get+size
5.列表迭代器
正向 逆向 从任意位置,任意区间迭代
6.旧版普通for
7.旧版迭代器
8.栈结构遍历方式
9.队列结构遍历方式
package com.sxt.listsondemo;
import java.util.ArrayDeque;
import java.util.Deque;
public class DequeDemo {
public static void main(String[] args) {
Deque deque = new ArrayDeque();
// deque.addFirst("A");
// deque.addFirst("B");
// deque.addFirst("C");
// System.out.println(deque);
// System.out.println(deque.removeFirst());
// while (!deque.isEmpty()) {
// System.out.println(deque.removeFirst());
// }
// deque.addLast("A");
// deque.addLast("B");
// deque.addLast("C");
// System.out.println(deque);
deque.push("A");
deque.push("B");
deque.push("C");
System.out.println(deque.pop());
System.out.println(deque.pop());
System.out.println(deque.pop());
// System.out.println(deque.pop());
}
}