如何在Java8中使用收集器和流自动递增hashmap的键

我不熟悉Java8:

流

和

收集器

类

我正在阅读一个文件，其内容需要保存在

LinkedHashMap

中，其中其

是文件的行号，其

分别是每行的内容

在这里，我想使用

流

概念，但我不能使用

收集器.toMap

自动增加

，需要将其保存在

LinnkedHashMap

对象中。相反，我得到的是例外情况

以下是我正在尝试的代码：

List List=new ArrayList（）；
整数计数=0；
try（BufferedReader br=Files.newBufferedReader（path.get（fileName）））{
//br以流的形式返回并将其转换为列表
list=br.lines（）.collect（Collectors.toList（））；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
list.forEach（System.out:：println）；
映射文件numWithContentMapper=list.stream（）
.collect（收集器.toMap（n->n+1，s1->s1））；

尝试以下代码：

public static void main(String[] args)  {
    List<String> list = Arrays.asList("A", "B", "C");
    list.forEach( System.out::println );

    AtomicInteger i = new AtomicInteger(0);
    Map<Integer, String> fileNumWithContentMapper = list.stream()
                .collect( Collectors.toMap( n->i.incrementAndGet(),s1->s1));

    System.out.println(fileNumWithContentMapper);
}

publicstaticvoidmain（字符串[]args）{
List=Arrays.asList（“A”、“B”、“C”）；
list.forEach（System.out:：println）；
AtomicInteger i=新的AtomicInteger（0）；
映射文件numWithContentMapper=list.stream（）
.collect（Collectors.toMap（n->i.incrementAndGet（），s1->s1））；
System.out.println（fileNumWithContentMapper）；
}

尝试以下代码：

public static void main(String[] args)  {
    List<String> list = Arrays.asList("A", "B", "C");
    list.forEach( System.out::println );

    AtomicInteger i = new AtomicInteger(0);
    Map<Integer, String> fileNumWithContentMapper = list.stream()
                .collect( Collectors.toMap( n->i.incrementAndGet(),s1->s1));

    System.out.println(fileNumWithContentMapper);
}

publicstaticvoidmain（字符串[]args）{
List=Arrays.asList（“A”、“B”、“C”）；
list.forEach（System.out:：println）；
AtomicInteger i=新的AtomicInteger（0）；
映射文件numWithContentMapper=list.stream（）
.collect（Collectors.toMap（n->i.incrementAndGet（），s1->s1））；
System.out.println（fileNumWithContentMapper）；
}

您可以使用

IntStream.range

：

IntStream.range(0, list.size())
         .boxed()
         .collect(Collectors.toMap(Function.identity(), i -> list.get(i)));

---

另一个选项是使用

LineNumberReader

API。

您可以使用

IntStream.range

：

IntStream.range(0, list.size())
         .boxed()
         .collect(Collectors.toMap(Function.identity(), i -> list.get(i)));

---

另一个选项是使用

LineNumberReader

API。

有很多方法可以实现这一点。但在这里，我将解释我的方式：

1.设置

IntStream

对象的大小。 首先，只要有对象的

列表（即
e
可以是
字符串
，
整数
，
对象
，等等），就可以使用
IntStream
类将其转换为
映射
。此类是一个原始int值元素序列，支持顺序和并行聚合操作。这意味着它就像一个巨大的柜台。如果我们已经有了一个计数器，我们需要设置一些限制，
IntStream.range（int start，int end）
方法将帮助我们。此方法将以增量步骤1返回从
start
（包含）到
end
（独占）的顺序
IntStream
。因此，如果您想创建一个具有
列表大小的
IntStream
，请使用以下命令：

List number=Arrays.asList（4,5,4,3）；
IntStream=IntStream.range（0，number.size）；

2.基于
IntStream
对象准备
Stream
对象。
现在，我们有一个与您的
列表大小相同的计数器，但我们需要一个
映射。现在我们要使用
IntStream.boxed（）
。此方法返回一个
流
，该流由该流的元素组成，每个元素被装箱为一个
整数
。这是一个
流
。我们差不多完成了

streamstreamboxed=Stream.boxed（）；

3.将
流
对象转换为
映射
对象
最后，我们可以使用
Stream.collect（）方法创建映射。此方法对该流的元素执行可变缩减操作。如果没有
Collectors.toMap（）
方法的帮助，这种减少将变得复杂。此收集器可用于将流元素收集到映射实例中。为此，我们需要提供两个函数：
keyMapper
和
valueMapper
。
键映射器
将用于从
流
元素中提取
映射
键，
值映射器
将用于提取与给定
关联的
。对于我们的示例，我们将使用
映射
。
keyMapper
将使用
i->i
提取
steamBoxed
流的值，
valueMapper
应该是
numbers
列表的值，我们将使用
i->numbers获取这些值。获取（i）
如下：

Map result=streamBoxed.collect（Collectors.toMap（i->i，i->numbers.get（i）））

4.结合所有步骤
这三个部分可以组合在一个简单的代码中：

List number=Arrays.asList（4,5,4,3）；
映射结果=IntStream
.范围（0，数字.大小）；//IntStream
.boxed（）；//流动
.collect（Collectors.toMap（i->i，i->numbers.get（i））//Map

此外，您会发现一些作者更喜欢使用
Function.identity（）
方法作为
keyMapper
，使用
numbers:：get
lambda表达式作为
valueMapper
他们为什么使用这些表达式？只是出于偏好。
Function.identity（）
方法将始终返回相同的实例。因此，使用
Function.identity（）
而不是
i->i
可能会节省一些内存。但是，
i->i
比
Function.identity（）
更具可读性，但这是因为它创建了自己的实例，并且具有独特的实现类消耗了更多内存。
：：
lambda表达式只是一个方法引用捕获

但是，我如何将此应用于我的解决方案？
那么像这样,

最终列表；
...
//列表初始化；
list=br.lines（）.collect(
public class Someclass{
static int j=0;
static int count(int de){
    return de++;
}
    public static void main(String[] args) {
     List<String> list =  Arrays.asList("Vishwa","Ram","Mohan","Sohan");
        Map<Integer,String> map;
        map = list.stream().collect(Collectors.toMap(s->{count(j);return j++;}, Function.identity()));
        map.forEach((k,v)-> {
                         System.out.print(k+"  ");
                         System.out.println(v);
    });
    }
}

Stream.of("A", "B", "C").collect(TreeMap<Integer, String>::new
    ,(map, element) -> map.put(Optional.ofNullable(map.lastEntry()).map(e -> e.getKey() + 1).orElse(1), element)
    ,(m1, m2) -> {})
    .forEach((i, e) -> System.out.println(i + " " + e));

1 A 
2 B
3 C