集合 - 走看看

zoukankan html css js c++ java

集合
集合

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map，今天我们主要学习Collection集合，在day04时讲解Map集合。

单列集合Collection
- Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。
从上面的描述可以看出JDK中提供了丰富的集合类库，为了便于初学者进行系统地学习，接下来通过一张图来描述整个集合类的继承体系。

Collection中的常用几个子类（java.util.List集合、java.util.Set集合）。

List接口

List接口特点：
1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

Set接口

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

HashSet集合

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。

HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

在JDK1.8之前，哈希表底层采用数组+链表实现，而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

LinkedHashSet集合

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

Collections工具类
- java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
- public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
- public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
- public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
- public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
双列集合Map

Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map接口中定义了很多方法，常用的如下：
- public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
- public V remove(Object key): 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
- public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
- boolean containsKey(Object key) 判断集合中是否包含指定的键。
- public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
- public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
HashMap<K,V>：

存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap<K,V>：

HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

属性集Properties类

构造方法：
- public Properties() :创建一个空的属性列表。
基本的存储方法
- public Object setProperty(String key, String value) ：保存一对属性。
- public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
- public Set<String> stringPropertyNames() ：所有键的名称的集合。
与流相关的方法：
- public void load(InputStream inStream)：从字节输入流中读取键值对。
补充知识点

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。
```
public class HelloJDK9 {  
    public static void main(String[] args) {  
        Set<String> str1=Set.of("a","b","c");  
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
        System.out.println(str1);  
        Map<String,Integer> str2=Map.of("a",1,"b",2);  
        System.out.println(str2);  
        List<String> str3=List.of("a","b");  
        System.out.println(str3);  
    }  
} 
```
需要注意以下两点：

1:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如 HashSet，ArrayList等待；

2:返回的集合是不可变的；

Stream流

说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结
果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

Stream的更优写法：

下面来看一下借助Java 8的Stream API，什么才叫优雅：
```
import java.util.ArrayList;
import java.util.List;
public class Demo03StreamFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.stream()
           .filter(s ‐> s.startsWith("张"))  
            .filter(s ‐> s.length() == 3)
            .forEach(System.out::println);
    }
}
```
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码
中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

获取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
获取一个流非常简单，有以下几种常用的方式：
- 所有的 Collection 集合都可以通过 stream 默认方法获取流；
- Stream 接口的静态方法 of 可以获取数组对应的流。
根据Collection获取流

首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。
```
import java.util.*;
import java.util.stream.Stream;
public class Demo04GetStream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // ...
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        // ...
        Stream<String> stream2 = set.stream();
        Vector<String> vector = new Vector<>();
        // ...
        Stream<String> stream3 = vector.stream();
    }
}
```
根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流
需要分key、value或entry等情况：
```
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
public class Demo05GetStream {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        // ...
        Stream<String> keyStream = map.keySet().stream();
        Stream<String> valueStream = map.values().stream();
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
    }
}
```
根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法
of ，使用很简单：
```
import java.util.stream.Stream;
public class Demo06GetStream {
    public static void main(String[] args) {
        String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
        Stream<String> stream = Stream.of(array);
    }
}
```
备注： of 方法的参数其实是一个可变参数，所以支持数组。

常用方法
- 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
  法均为延迟方法。）
- 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
  用。本小节中，终结方法包括 count 和 forEach 方法。
备注：本小节之外的更多方法，请自行参考API文档。

逐一处理：forEach

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。
```
void forEach(Consumer<? super T> action);
```
该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。

复习Consumer接口：
```
java.util.function.Consumer<T>接口是一个消费型接口。
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
```
基本使用：
```
import java.util.stream.Stream;
public class Demo12StreamForEach {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
        stream.forEach(name‐> System.out.println(name));
    }
}
```
过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：
```
Stream<T> filter(Predicate<? super T> predicate);
```
该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

复习Predicate接口：

此前我们已经学习过 java.util.stream.Predicate 函数式接口，其中唯一的抽象方法为：
```
boolean test(T t);
```
该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法
将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

基本使用：

Stream流中的 filter 方法基本使用的代码如：
```
import java.util.stream.Stream;
public class Demo07StreamFilter {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter(s ‐> s.startsWith("张"));
    }
}
```
在这里通过Lambda表达式来指定了筛选的条件：必须姓张。

映射：map

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：
```
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
```
该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

复习Function接口：

此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：
```
R apply(T t);
```
这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。

基本使用：

Stream流中的 map 方法基本使用的代码如：
```
import java.util.stream.Stream;
public class Demo08StreamMap {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("10", "12", "18");
        Stream<Integer> result = original.map(str‐>Integer.parseInt(str));
    }
}
```
这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对
象）。

统计个数：count

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：
```
long count();
```
该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：
```
import java.util.stream.Stream;
public class Demo09StreamCount {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter(s ‐> s.startsWith("张"));
        System.out.println(result.count()); // 2
    }
}
```
取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。方法签名：
```
Stream<T> limit(long maxSize);
```
参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：
```
import java.util.stream.Stream;
public class Demo10StreamLimit {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}
```
跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：
```
Stream<T> skip(long n);
```
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：
```
import java.util.stream.Stream;
public class Demo11StreamSkip {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 1
    }
}
```
组合：concat

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：
```
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
```
备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

该方法的基本使用代码如：
```
import java.util.stream.Stream;
public class Demo12StreamConcat {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
    }
}
```
补充知识点

用方法引用改进代码
```
public class Demo02PrintRef {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
    public static void main(String[] args) {
       printString(System.out::println);  
    }
}
```
请注意其中的双冒号 :: 写法，这被称为“方法引用”，而双冒号是一种新的语法，方法引用符。

语义分析：

例如上例中， System.out 对象中有一个重载的 println(String) 方法恰好就是我们所需要的。那么对于
printString 方法的函数式接口参数，对比下面两种写法，完全等效：
- Lambda表达式写法： s -> System.out.println(s);
- 方法引用写法： System.out::println
第一种语义是指：拿到参数之后经Lambda之手，继而传递给 System.out.println 方法去处理。
第二种等效写法的语义是指：直接让 System.out 中的 println 方法来取代Lambda。两种写法的执行效果完全一
样，而第二种方法引用的写法复用了已有方案，更加简洁。

通过super引用成员方法：
- Lambda表达式： () -> super.sayHello()
- 方法引用： super::sayHello
通过this引用成员方法：
- Lambda表达式： () -> this.buyHouse()
- 方法引用： this::buyHouse
类的构造器引用：
- Lambda表达式： name -> new Person(name)
- 方法引用： Person::new
数组的构造器引用：
- Lambda表达式： length -> new int[length]
- 方法引用： int[]::new
查看全文

相关阅读:
通用人工智能离我们还有多远？
自动化机器上的物联网网关的目的是什么？
提效降本，您不可不知道的云架构秘诀
 “影子物联网”：日益增长的企业安全盲区
 查找练习 hash——出现过的数字
 查找练习 hash——出现过的数字
 数据结构上机实验之二分查找
 数据结构上机实验之二分查找
 简单字符串比较
 简单字符串比较

原文地址：https://www.cnblogs.com/dutf/p/14091504.html

集合

集合

单列集合Collection

List接口

ArrayList集合

LinkedList集合

Set接口

HashSet集合

LinkedHashSet集合

Collections工具类

双列集合Map

HashMap<K,V>：

LinkedHashMap<K,V>：

属性集Properties类

补充知识点

Stream流

获取流

根据Collection获取流

根据Map获取流

根据数组获取流

常用方法

逐一处理：forEach

过滤：filter

映射：map

统计个数：count

取用前几个：limit

跳过前几个：skip

组合：concat

补充知识点