Collections
collection
|
Queue
| 实现类PriorityQueue
Deque 接口 ：双端队列
|
实现类 ArrayDeque，LinkedList
package day23;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/** Collections */
public class TestCollections {
public static void main(String[] args) {
List <Integer> list = new ArrayList<>();
//向集合中加多个元素
Collections.addAll(list, 11,22,33,44,35,77,99,23);
System.out.println(list);
//自然排序
Collections.sort(list);
System.out.println(list);
//指定排序方式
// Collections.sort(list,(n1,n2) -> n2 - n1);
// System.out.println(list);
//查找指定元素在集合中出现的位置索引
System.out.println(Collections.binarySearch(list,33));//3
//寻找集合中的最大最小元素
System.out.println(Collections.max(list));//99
System.out.println(Collections.min(list));//11
//查找指定元素在集合中出现的次数
Collections.addAll(list, 33,33,33,33,33);
System.out.println(list);
System.out.println(Collections.frequency(list, 33));//6
System.out.println(Collections.frequency(list, 8888));//0
//反转集合元素
Collections.reverse(list);
System.out.println(list);
//对集合元素进行填充，全部替换
Collections.fill(list, 111);
System.out.println(list);
}
}
Queue数据结构：队列
队列：是一组操作受限的线性表。只能在队尾增加，队头删除。先进先出 添加 删除 获取列表头元素 操作失败时
add remove element 会产生异常
offer poll peek 不会产生异常，而是返 回特定的值
package day23;
import java.util.LinkedList;
import java.util.Queue;
public class TestQueue {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<>();
//入队
q.add(22);
q.offer(11);
q.offer(33);
System.out.println(q);
q.forEach(System.out :: println);
System.out.println("---------------------");
//出队
// System.out.println(q.remove());
// System.out.println(q.poll());//null
while(q.size() > 0){
System.out.println(q.poll());
//只会获得队头元素，不会移除
// System.out.println(q.element());
}
System.out.println(q);
}
}
Deque添加 删除 获取列表头元素 操作失败时
addFirst,addLast remove element 会产生异常
offer poll peek 不会产生异常，而是返 回特定的值 package day23;
import java.util.ArrayDeque;
import java.util.Deque;
public class TestDeque {
public static void main(String[] args) {
Deque <String> d = new ArrayDeque<>();
/* //入队
d.addLast("aa");
d.addLast("bb");
d.addLast("cc");
//出队
while(d.size() >0){
System.out.println(d.pollFirst());
}*/
//入队
d.add("aa");
d.offer("bb");
d.offer("cc");
//出队
while(d.size() >0 ){
System.out.println(d.poll());
}
//----------------栈:后进先出----------------------
//用队列的方法模拟栈
/* d.addFirst("aa");
d.offerFirst("bb");
d.offerFirst("cc");
//出栈
while(d.size() >0){
System.out.println(d.pollFirst());
}*/
//----------------直接栈操作-------------------
d.push("aa");
d.push("bb");
d.push("cc");
}
}
Map接口：存储键值对（映射）
Map 接口
| 实现类 HashMap ——子类LinkedHashMap；HashTable —— Propeties类
接口SortedMap
package day23;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class TestMap {
public static void main(String[] args) {
//Map<Integer,String> map = new HashMap<>();
Map<Integer,String> map = new LinkedHashMap<>();
//添加
map.put(11, "aa");
map.put(22, "bb");
map.put(33, "cc");
map.put(null, null);//可包含null
//查看集合中键值对的数量
System.out.println(map.size());
System.out.println(map);
System.out.println(map.keySet());//键是唯一的
System.out.println(map.values());
Set <Integer> set = new HashSet<>();
map.put(33, "xyz");
System.out.println(map);
//判断键值对的数量是否为0，为0返回ture
System.out.println(map.isEmpty());
//判断是否包含指定参数的key键，包含返回ture
System.out.println(map.containsKey(33));
//判断是否包含指定参数的值，包含返回ture
System.out.println(map.containsValue("cc"));
//删除指定键对应的集合中的键值对信息
map.remove(33);
//清空
map.clear();
}
}package day23;
// 遍历
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
public class TestMapIterator {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<>();
map.put(11, "aa");
map.put(22, "bb");
map.put(33, "cc");
System.out.println(map);
//1.集合提供的方法
/* map.forEach(new BiConsumer<Integer,String>(){
@Override
public void accept(Integer t ,String u){
System.out.println(t+","+u);
}
});*/
map.forEach((k,v) -> System.out.println( k + "," +v));
//2.迭代器提供的方法，各自遍历键的集合和值的集合
map.keySet().iterator().forEachRemaining(System.out::println);
//3.整体作为一个键值对遍历
Iterator <Entry<Integer,String>>i = map.entrySet().iterator();
while(i.hasNext()){
Entry<Integer, String> e = i.next();//键值对
System.out.println(e);
System.out.println(e.getKey());
System.out.println(e.getValue());
}
map.entrySet().iterator().forEachRemaining(e -> System.out.println(e+ ","+e.getKey()+","+e.getValue()));
}
}
HashMap,LinkedHashMap,TreeMap,Hashtable的区别无序 HashMap：线程非安全。可以存储空键和空值 Hashtable：线程安全的，性能低 有序
LinkedHashedMap：按照添加的顺序 TreeMap：key，自然升序排序，自己指定顺序 Stream流操作聚集运算。 聚集： 统计运算。 特点：临时性的，一次性操作，效率高方法
末端方法 ：一次性消耗掉这个流
中间方法：会创建出一个新的流
package day23;
import java.util.ArrayList;
import java.util.List;
import java.util.function.IntPredicate;
import java.util.stream.IntStream;
public class TestStream {
public static void main(String[] args) {
IntStream i = IntStream.builder().add(11).add(22).add(33).build();
//---------------------末端方法------------------
// System.out.println(i.max().getAsInt());//33
//
// //最小值
// IntStream i1 = IntStream.builder().add(11).add(22).add(33).build();
// System.out.println(i1.min().getAsInt());
//
// //和
// IntStream i2 = IntStream.builder().add(11).add(22).add(33).build();
// System.out.println(i2.sum());
//
// //平均
// IntStream i3 = IntStream.builder().add(11).add(22).add(33).build();
// System.out.println(i3.average().getAsDouble());
//
// //个数
// IntStream i4 = IntStream.builder().add(11).add(22).add(33).build();
// System.out.println(i4.count());
//判断流中的所有数据是否满足条件
// System.out.println(i.allMatch(new IntPredicate() {
//
// @Override
// public boolean test(int value) {
//
// return value > 20;
// }
// }));
// System.out.println(i11.allMatch(v -> v>10));
//只要有一个满足条件就返回ture
// System.out.println(i.anyMatch(v -> v>20));
//---------------------中间方法------------------
//会返回一个新的流
//i.filter( v -> v > 20).forEach(System.out::println);
//---------------------Stream流对集合进行聚合运算------------------
List <Integer> list = new ArrayList<>();
list.add(222);
list.add(333);
list.add(444);
list.stream().forEach(System.out::println);
System.out.println("-----------------------------------");
list.stream().filter( v -> v >200).forEach(System.out::println);
System.out.println(list.stream().filter( v -> v >200).count());
}
}过滤接口
package day23;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
/** 过滤器接口 */
class Student{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
public class TestPredicate {
public void check(List<Student> stus,Predicate<Student> p){
for(Student stu :stus){
if(p.test(stu)){
System.out.println(stu);
}
}
}
public static void main(String[] args) {
List<Student> stus = new ArrayList<>();
Student zhangsan = new Student("zhangsan",31);
Student lisi= new Student("lisi",34);
Student wangwu = new Student("wangwu",20);
Collections.addAll(stus, zhangsan,lisi,wangwu);
new TestPredicate().check(stus,new Predicate <Student>(){
@Override
public boolean test(Student t) {
return t.getAge() > 30 && t.getName().contains("g");
}
});
new TestPredicate().check(stus, t -> t.getAge() > 30 && t.getName().contains("g"));
}
}
|
收藏
淘帖
踩
奈斯
