JAVASE——集合框架-优快云博客

方法名	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数
public Object[] toArray()	把集合中的元素，存储到数组中

Collection<String> list = new ArrayList<>();

//添加元素
list.add("xxx");
//获取集合的元素个数
list.size();
//删除集合元素
list.remove("xxx");
//集合转换为数组
Object[] arr = list.toArray();

Collection集合遍历方式

迭代器遍历

用来遍历集合的专用方式，在java中迭代器的代表是iterator

Iterator<E> iterator()

返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素。

Collection<String> names = new ArrayList<>();
names.add("xxx1");
names.add("xxx2");
names.add("xxx3");
names.add("xxx4");
1、得到这个集合的迭代器对象
Iterator<String< it = names.iterator();
2、使用一个while循环来遍历
while(it.hasNext()){
    String name = it.next();
    System.out.println(name);
}

增强for循环

for (元素的数据类型变量名：数组或者集合) {

}

Collection<String> c = new ArrayList<>();
...
for(String s : c) {
    System.out.println(s);
}

Lambda表达式

Collection<String> names = new ArrayList<>();
names.add("xxx1");
names.add("xxx2");
names.add("xxx3");
names.add("xxx4");

names.forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});
简化的话
names.forEach(s -> System.out.println(s));

List集合

特点：

因为支持索引，所以多了很多与索引相关的方法

void add(int index,E element)

E remove(int index)

E set(int index,E element)

E get(int index)

List<String> names = new ArrayList<>();
    names.add("xxx1");
    names.add("xxx2");
    names.add("xxx3");
    names.add("xxx4");
    
    names.add(2, "xxx02");
    names.remove(1);
    names.set(2,"xxx03");
    names.get(2);

ArrayList底层原理

ArrayList底层是基于数组存储数据的。
LinkedList底层是基于链表存储数据的。

数组的特点：

查询速度快（是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据耗时相同。
增删数据效率低：可能需要把后面很多的数据进行前移。

链表的特点：

链表的数据是一个一个独立的结点组成的，结点在内存中是不连续的，每个结点包含数据值和下一个结点的地址。

查询慢，无论查询哪个数据都要从头开始找。

链表增删相对快

Set集合

无序、不重复、无索引

HashSet：无序、不重复、无索引
LinkedHashSet：有序、不重复、无索引
TreeSet：排序、不重复、无索引

Map集合

键值对集合，格式{key1=value1，key2=value2，...}

所有键是不允许重复的，值可以重复

Map系统集合的特点是都是由键决定的，值只是一个附属品，值是不做要求的

HashMap：无序、不重复、无索引
LinkedHashMap：有序、不重复、无索引
TreeMap：按照大小默认升序排序、不重复、无索引

Map<String,Integer> map = new HashMap<>();
map.put("xxx1",20);
map.put("xxx2",10);
map.put("xxx3",30);
map.put("xxx2",40);
map.put("xxx4",50);
map.put(null,null);

Map集合的常用方法

Map<String,Integer> map = new HashMap<>();
//添加数据
map.put("xxx1",20);
map.put("xxx2",10);
map.put("xxx3",30);
map.put("xxx2",40);
map.put("xxx4",50);
map.put(null,null);

map.get("xxx1");//根据键取值
map.containsKey("xxx1");//判断是否包含某个值

Map集合的遍历

键找值

先获取Map集合全部的键，再通过遍历键来找值

Map<String,Integer> map = new HashMap<>();
map.put("xxx1",20);
map.put("xxx2",10);
map.put("xxx3",30);
map.put("xxx2",40);

//1、提起Map集合的全部键到一个set集合中
Set<String> keys = map.keySet();
//2、遍历Set集合，得到每一个键
for (String key : keys) {
    Integer value = map.get(key);
    System.out.println(key + "=" + value);
}

键值对

把键值对看成一个整体进行遍历（难度较大）

Set <Map.Entry<K,V>> entrySet()

获取所有“键值对”的集合

Set <Map.Entry<String, Double> entries = map.entrySet();

Map<String,Integer> map = new HashMap<>();
map.put("xxx1",20);
map.put("xxx2",10);
map.put("xxx3",30);
map.put("xxx2",40);

//1、把Map集合转换成Set集合，里面的元素类型都是键值对类型(Map.Entry<String,Integer>)
Set<Map.Entry<String,Integer>> entries = map.entrySet();

for (Msp.Entry<String, Integer> entry: entries) {
    String key = entry.getKey();
    Integer value = entry.getValue();

实现类

HashMap：无序、不重复、无索引
LinkedHashMap：有序、不重复、无索引
TreeMap：按照大小默认升序排序、不重复、无索引

Stream流

可以用于操作集合或者数组的数据

Stream流大量的结合了Lambda的语法风格来编程，功能强大，性能高效，代码简洁，可读性好。

list.stream().filter(s -> s.startWith("x")).filter(s -> s.length()==3).collect(Collectors.toList());

1、获取Stream流
2、调用流水线的各种方法
3、获取处理的结果

获取Stream流方法

获取集合的Stream流

default Stream<E> stream()

Collection<String> list = new ArrayList<>();
Stream<String> s1 = list.stream();

Map<String, Integer> map = new HashMap<>();
获取键流
Stream<String> s2 = map.keySet().stream();
获取值流
Stream<String> s3 = map.value().stream();

获取数组的Stream流

public static <T> Stream<T> stream(T[] array)

Stream<String> s5 = Arrays.stream(names);

Stream流的中间方法

Stream<T> filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤
Stream<T> sorted()	对元素进行升序排序
Stream<T> sorted(Comparator<? super T> comparator)	按照指定规则排序
Stream<T> limit(long maxSize)	获取前几个元素
Stream<T> skip(long n)	跳过前几个元素
Stream<T> distinct()	去除流中重复的元素
<R> Stream<R> map(Function<? super T,? extends R> mapper)	对元素进行加工，并返回对应的新流
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流

Stream流的终结方法

void forEach(Consumer action)	对此流运算后的元素执行遍历
long count()	统计此流运算后的元素个数
Optional<T> max(Comparator<? super T> comparator)	获取此流运算后的最大值元素
Optional<T> min(Comparator<? super T> comparator)	获取此流运算后的最晓值元素