蓝桥杯复习3

ArrayList (Vector)

简述

ArrayList 类可以实现可增长的对象数组。

构造方法

ArrayList<> arr1 = new ArrayList<>();
ArrayList<> arr2 = new ArrayList<>(int initialCapacity);

增删改查

//增加
arr1.add(e element);
arr1.add(int index,e element);

//删除
arr1.remove(int index);
arr1.clear();

//修改
arr1.set(int index,e element);

//查询
arr1.get(int index);
arr1.indexOf(Object o);
arr1.lastIndexOf(Object o);

容器大小 与 空判断

arr1.size();
arr1.isEmpty();

数组 与 字符串 转换

arr1.toArray();
arr1.toString();

拷贝

//method one
ArrayList<Integer> arr1 = new ArrayList<>();
ArrayList<Integer> arr2 = new ArrayList<>();
arr1 =arr2; // Arr1之前的值会自动被垃圾回收
//method two
ArrayList<Integer> arr1 = new ArrayList<>();
// 将arr2的值拷贝给arr1
ArrayList<Integer> arr2 = new ArrayList<>(arr1);

LinkedList (List)

简述

–[ LinkedList是List 接口的链接列表实现。
–[ 实现所有可选的列表操作，并且允许所有元素（包括null）。
–[ 除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。
–[ 这些操作允许将链接列表用作堆栈、队列或双端队列。

构造方法

LinkedList<> list1 = new LinkedList<>();

增删改查

//增加
list1.add(e element);
list1.addFirst(e element);
list1.addLast(e element);
list1.offer(e element);
list1.push(E e);

//删除
list1.poll();
list1.peek();
list1.element();
list1.clear();
list1.pop();
list1.remove();
list1.remove(int index);

//修改


//查询
list1.indexOf(Object o)
//返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
list1.lastIndexOf(Object o)
//返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
list1.getFirst();
list1.getLast();

容器大小 与 空判断

list1.size();

遍历

迭代器

Iterator iterator=students.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
}

for循环和get方法

for(int i = 0; i < n; i++)
    System.out.println(E.get(i))
for(int x : E){ 
	System.out.println(x);
}

stack和queue

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

HashMap

简述

HashMap是基于哈希表的 Map 接口的实现，是无序的。

构造方法

HashMap<> map1 = new HashMap<>();

增删改查

//增加
map1.put(K key, V value);

//删除
map1.remove(K key);
map1.clear();

//修改


//查询
map1.containsKey(Object key)//如果包含指定键，返回true
map1.containsValue(Object value)//如果包含指定值， 返回true
map1.isEmpty();
map1.get(Object key)//返回指定键所映射的值；

TreeMap

简述

TreeMap是基于红黑树实现的，是有序的， 可进行排序。
此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销

类似于 HashMap 的 API

clear()//清空
containsKey(Object key)//如果包含指定键，返回true
containsValue(Object value)//如果包含指定值， 返回true
get(Object key)//返回指定键的值， 如果不存在返回null
firstKey()//返回此映射中当前第一个（最低）键。
lastKey()返回映射中当前最后一个（最高）键
ceilingKey(K key)返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
floorKey(K key)返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。

HashMap和TreeMap的遍历方式

1. 使用增强for

TreeMap<Integer, String> m = new TreeMap<>();
m.put(1,"A");
m.put(2,"B");
for(String value : m.values()){
	System.out.print(value);
}
TreeMap<Integer, String> m = new TreeMap<>();
m.put(1,"A");
m.put(2,"B");
for(int k : m.keySet()){
	System.out.print(m.get(k));
}

HashSet

简述

HashSet基于哈希表实现，无序。

API

add(E e)//如果容器中不包含此元素，则添加。

clear()//清空
remove()// 如果指定元素在此set中则移除

contains(Object o)//查询指定元素是否存在，存在返回true
isEmpty()// 判空
size()//返回元素数量

iterator()//返回此容器的迭代器

TreeSet

简述

基于红黑树实现。有序。

API

add(E e)// 如果不存在，则添加。

clear()//清空
remove()// 如果指定元素在此set中则移除

contains(Object o)//查询指定元素是否存在，存在返回true
isEmpty()// 判空
size()//返回元素数量

iterator()//返回此容器的迭代器

Tree

TreeSet和TreeMap可以二分查找一个比当前元素大的最小元素，或者比当前元素小的最大元素。

ceiling(E e)//返回一个大于等于当前元素的最小元素，不存在返回null
floor(E e)//返回一个小于等于当前元素的最大元素，不存在返回null

higher(E e)//返回此 set 中严格大于给定元素的最小元素,不存在返回null
lower(E e)//返回此set中严格小于给定元素的最大元素，不存在返回null

first()//返回第一个元素
last()//返回最后一个元素

PriorityQueue

简述

翻译过来就是优先队列，本质是一个堆， 默认情况下堆顶每次都保留最小值，每插入一个元素，仍动态维护堆顶为最小值。

构造

PriorityQueue<Integer> Q = new PriorityQueue<>(); // 初始化

增删改查

add(E e)//将指定的元素插入此优先级队列。
offer(E e) // 将指定元素插入此优先队列

peek() // 获取第一个元素，及最小或最大元素
poll() // 获取并移除第一个
clear()//清空
remove(Object o) // 移除指定元素

contains(Object o) // 如果包含指定元素返回true
iterator()//返回在此队列中的元素上进行迭代的迭代器。
size() // 返回元素个数

大根堆的两种方式

1. java中的优先队列默认是小根堆。
2. 使用自定义比较器
   将所有数据变为之前自身的负数之后在插入， 因为添加个负号就相当于是逆序了嘛。
   【1 < 2 < 3 取负之后变为 -1 > - 2 > - 3】

//method one
A=new PriorityQueue<>(new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO 自动生成的方法存根
				return o2-o1;
			}
});

//method two
B=new PriorityQueue<>((x,y) -> (y-x));