标签: java-8

注意:这里已经讨论过这个错误,并且已经提出了各种解决方案来摆脱与java-8的默认实现冲突的jar.

我的问题是这个问题的延伸.

为了完整起见,这里是我也面临的堆栈跟踪,当我用java-8运行代码时:

Feb 29, 2016 12:06:41 PM com.sun.xml.internal.bind.v2.util.XmlFactory createParserFactory
SEVERE: null
org.xml.sax.SAXNotRecognizedException: http://javax.xml.XMLConstants/feature/secure-processing
    at org.apache.xerces.parsers.AbstractSAXParser.setFeature(AbstractSAXParser.java:1487)
    at org.apache.xerces.jaxp.SAXParserImpl.setFeatures(SAXParserImpl.java:145)
    at org.apache.xerces.jaxp.SAXParserImpl.<init>(SAXParserImpl.java:128)
    at org.apache.xerces.jaxp.SAXParserFactoryImpl.newSAXParserImpl(SAXParserFactoryImpl.java:112)
    at org.apache.xerces.jaxp.SAXParserFactoryImpl.setFeature(SAXParserFactoryImpl.java:140)
    at com.sun.xml.internal.bind.v2.util.XmlFactory.createParserFactory(XmlFactory.java:121)
    at com.sun.xml.internal.bind.v2.runtime.unmarshaller.UnmarshallerImpl.getXMLReader(UnmarshallerImpl.java:139)
    at com.sun.xml.internal.bind.v2.runtime.unmarshaller.UnmarshallerImpl.unmarshal(UnmarshallerImpl.java:276)

为了证明冲突的jar确实是问题(如之前共享的链接中所述),我确实将相关代码拉出到另一个项目中并使用java-8成功运行代码(即没有任何错误)最低数量的罐子.到现在为止还挺好.

现在查询:

就我而言,我的遗留项目使用了大约2-3个已知的冲突罐,这些罐由于各种原因而被使用.但是,有一个新模块使用注释驱动的jaxb进行oxm处理.

问题是:我无法摆脱那些旧的和冲突的罐子,因为这几乎使得10%的代码库无法编译.但是,与此同时,我也不希望在新模块中摆脱jaxb/oxm实现.

有没有办法让我可以告诉JVM忽略旧jar并使用java-8附带的默认实现,只要代码执行通过这个新模块？

是否可以IntStream使用索引迭代int数组？

试着这样做:

ByteBuf buf = ...;
int[] anArray = ...;

IntStream.of(anArray).forEach(...); // get index so I can do "anArray[index] = buf.x"

这是JavaScript版本:

var counter = 1;
var incrementor = () => counter++;
incrementor();
console.log(counter);  // 2

是否可以将其写为Java 8 lambda函数来进行这种简单的计数？

如何在windows7机器上同时安装java7和java8.

如果是,那么从java7到java8的顺序和任何开关选项是什么？

我试图详细了解java-8流.

从流上的oracle文档页面:

Streams在几个方面与集合不同:

没有存储.流不是存储元素的数据结构; 相反,它通过计算操作管道传递来自诸如数据结构,数组,生成器函数或I/O通道的源的元素.

流操作和管道

流操作分为中间操作和终端操作,并组合成流管道.

流管道由源(例如集合,数组,生成器函数或I/O通道)组成; 然后是零个或多个中间操作,例如Stream.filter或Stream.map; 和一个终端操作,如Stream.forEach或Stream.reduce.

中间操作返回一个新流

除了文档,我还经历了相关的SE问题:

Java中的流如何影响内存消耗？

引用的所有地方都说由于流操作的管道衬里而没有消耗额外的内存.原始流将通过管道传递.

本杰明博客的一个工作实例:

List<String> myList =
    Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList
    .stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);

但是当中间操作像filter, map and sorted 返回新流时,怎么会不增加内存消耗？我在这里错过了什么吗？

最近我决定通过重构简单的代码片段来研究Java 8.我有以下示例,我试图转换为Java 8表示.

public static void halfTriangle(){
        for(int i=1; i<=4; i++){
            for(int j=1; j<=i; j++){
                System.out.print("* ");
            }
            System.out.println(" ");
        }
    }

我设法想出这样的东西:

public static void halfTriangleJava8(){
        IntStream.range(1, 5)
            .forEach(i -> IntStream.range(1, 5)
                .forEach(j -> System.out.println("* "))
        );
    }

但我不知道我可以留在哪里:

System.out.println(" ");

我尝试过类似的东西:

public static void halfTriangleJava8(){
        IntStream.range(1, 5)
            .forEach(i -> {
                IntStream.range(1, 5);
                System.out.println(" ");
            }
                .forEach(j -> System.out.println("* "))
        );
    }

但它给了我一个我不完全理解的错误."此表达式的目标类型必须是功能接口".

我相信这是一个非常简单的错误,但我今天才开始研究Java 8,所以任何帮助都会非常感激.

据我所知,如果我有一个带有两个过滤器的流,它们将与字节码中的&&结合使用.

例如

IntStream.range(1,10)
  .filter(i -> i % 2 == 0)
  .filter(i -> i % 3 == 0)
  .sum();

会像i%2 == 0 && i%3 == 0.

偷看会影响这个吗？

如果你在第一个文件管理器后偷看你得到2468,如果你偷看第二个,你只得到6(当然).

但如果你偷看这两个地方

IntStream.range(1,10)
            .filter(integer -> integer % 2 == 0)
            .peek(i-> System.out.print(i))
            .filter(integer -> integer % 3 == 0)
            .peek(i-> System.out.print(i))
            .sum();

你得到24668.

我的假设是,这必然意味着操作在某种程度上是由于窥视调用而分开的.就像是

if(i%2==0)
  peek
  if(i%3==0)

这是真的,如果是这样会影响性能(我认为不会).

private static <K, V extends Comparable<? super V>> Map<K, V>
    sortByValue( Map<K, V> map )
    {
        Map<K, V> result = new LinkedHashMap<>();
        Stream<Map.Entry<K, V>> st = map.entrySet().stream();

        st.sorted( Map.Entry.comparingByValue() )
                .forEachOrdered( e -> result.put(e.getKey(), e.getValue()) );

        return result;
    }

这是这篇文章的一个例子.有用.问题是它按升序排序.如何将其更改为降序？

我可以这样做:

public static <K, V extends Comparable<? super V>> Map<K, V>
sortByValue( Map<K, V> map )
{
    List<Map.Entry<K, V>> list =
            new LinkedList<Map.Entry<K, V>>( map.entrySet() );
    Collections.sort( list, new Comparator<Map.Entry<K, V>>()
    {
        public int compare( Map.Entry<K, V> o1, …

我想同时运行一些任务,所以我有一个代码如下:

for(final Task task : tasks){
    (new Thread(){public void run(){
        task.run(args);
}}).start();

我怎么知道所有任务何时完成(任务量可以变化),以便我可以在完成所有任务后运行某些东西？

System.out.println("All tasks are finished");

尝试使用流过滤集合,并尝试将以下lambda传递给filter()一个Set,它在标题中给出了一个神秘的错误:

unmatchedIncomingFields.stream().filter(s-> s.matches(fieldMatchPattern))

同时,创建Predicate对象有效:

unmatchedIncomingFields.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return s.matches(fieldMatchPattern);
    }
});

根据JLS,如果每个控制路径返回一个值,则lambda主体是"值兼容的".matches()总是被调用并且总是返回一个布尔值,所以我不明白问题是什么.

我也尝试了相同lambda的各种变体 - 有和没有括号和参数类型,并使用表达式和块返回体.