常用容器

List

链表，是一个接口；

初始化

List<Integer> list = new ArrayList<>;//长数组，支持下标随时访问，访问的时间复杂度是O(1);

List<Integer> list = new LinkList<>;//双链表，访问为线性访问，时间复杂度为O(n);

函数

List<Integer> list = new ArrayList<>;

//x.add(),在末尾添加一个元素；
list.add(9);
list.add(2);
list.add(6);//打印输出为[9,2,6]

//x.clear(),清空List里的元素；
list.clear();

//x.size(),返回List里的长度
int sz = list.size();

//x.isEmpty(),若为空，则返回true;
bool flag = list.isEmpty();

//x.gets(i),获得第i个元素；
for(int i = 0 ; i < list.size() ; i++)
{
int a = list.gets(i);
}

//x.set(i , num),将下标为i的值改为num;
for(int i = 0 ; i < list.size() - 1 ; i++)
{
int a = list.set(i , list.gets(i + 1) + 1);
}

Stack

栈，并不是接口，是一个实现，一个类；

初始化

//注意初始化内不能写int，要写其对象Integer;
Stack<Integer> stk = new Stack<>();

函数

Stack<Integer> stk = new Stack<>();

stk.push(9);//压入元素

int tmp = stk.pop();//弹出并且返回栈顶元素

int x = stk.peek();//返回栈顶元素

bool flag = stk.empty();//栈是否为空

int sz = stk.size();//返回长度

stk.clear();//清空栈

Queue

队列，是一种接口，分为双队列和优先队列；

初始化

Queue<Integer> q = new LinkedList<>();//双队列；

Queue<Integer> q = new PriorityQueue<>();//优先队列，默认是小根堆，队列顶部到底部从小到大排列；

Queue<Integer> q = new PriorityQueue<>(Collection.reverseOrder());//将优先队列改为大根堆；

函数

Queue<Integer> q = new LinkedList<>();

q.add(9);//在队列尾部添加元素

int t = q.remove();//删除并返回队头元素

bool flag = q.isEmpty();//队列是否为空；

int sz = q.size();//获得队列长度；

int h = q.peek();//返回队头；

q.clear();//清空

Set

接口，可以使用哈希表和平衡树；

哈希表遍历输出不一定是有序输出，随机顺序输出；

平衡树则是必然有序，从小到大遍历，维护性质更强，但是运行效率会降低；

初始化

Set<Integer> set = new HashSet<>();

TreeSet<Integer> set = new TreeSet<>();

函数

Set<Integer> set = new HashSet<>();

set.add(9);//将9加入哈希表;

bool flag = set.contains(9);//检查哈希表中是否包含某个值；

set.remove(9);//删除元素9；

int num = set.size();//返回元素个数；

bool e = set.isEmpty();//检查set是否为空;

set.clear();//清空；

平衡树独有的二分查找

TreeSet<Integer> set = new TreeSet<>();

int num = set.ceiling(9);//找到第一个大于等于9的元素值，并返回，否则返回null；

int tmp = set.floor(9);//找到第一个小于等于9的元素值，并返回，否则返回null；

Map

维护一种映射；

同样有哈希表和平衡树的两种模式；

初始化

Map<String , Integer> map = new HashMap<>();

函数

Map<String , Integer> map = new HashMap<>();

map.put("顶真" ， 15);//将关键字映射为对应的值；

int num = map.get("顶真");//获得关键字的对应值，否则返回null；

bool flag = map.containsKey("顶真");//关键字是否存在；

map.remove("顶真");//移除关键字；

int num = map.size();//返回元素个数；

bool e = map.isEmpty();//检查map是否为空;

map.clear();//清空；

//以下两个通常一起用
Map.Entry<String , Integer> entry;//Map中的对象类型；
Map.entrySet();//获取Map中的所有对象的集合;

for(Map.Entry<String , Integer> entry:map.entrySet())//遍历哈希表，但是仍然是无序的；
{
    int i = entry.getValue();//获得值；
    String s = entry.getKey();//获得关键字；

}

TreeMap独家

TreeMap<String , Integer> map = new TreeMap<>();

for(Map.Entry<String , Integer> entry:map.entrySet())//遍历平衡树，现在是有序的，String为关键字时，按字典序来编排，Integer为关键字时，按数字大小来排；
{
    int i = entry.getValue();//获得值；
    String s = entry.getKey();//获得关键字；

}

map.put("顶真" ， 15)；

Map.Entry<String , Integer> up_num = map.ceilingEntry("顶真");//返回字典序大于等于"顶真"的第一个元素，不存在则返回null

Map.Entry<String , Integer> de_num = map.floorEntry("顶真");//返回字典序小于等于"顶真"的第一个元素，不存在则返回null