小编Edw*_*rzo的帖子

我想我理解强类型,但每次我查找弱类型的例子时,我最终会找到编程语言的例子,这些语言只是自动强制/转换类型.

例如,在本文中名为Typing:Strong vs. Weak,Static vs. Dynamic表示Python是强类型的,因为如果你试图:

蟒蛇

1 + "1"
Traceback (most recent call last):
File "", line 1, in ? 
TypeError: unsupported operand type(s) for +: 'int' and 'str'

但是,在Java和C#中这样的事情是可能的,我们并不认为它们只是因为弱类型.

Java的

  int a = 10;
  String b = "b";
  String result = a + b;
  System.out.println(result);

C#

int a = 10;
string b = "b";
string c = a + b;
Console.WriteLine(c);

在另一篇名为Weakly Type Languages的文章中,作者说Perl是弱类型的,因为我可以将字符串连接到数字而反之亦然,而不进行任何显式转换.

Perl的

$a=10;
$b="a";
$c=$a.$b;
print $c; #10a

所以同样的例子使得Perl弱类型,但不是Java和C#？ …

我正在玩Java 8,以了解如何作为一等公民的功能.我有以下代码段:

package test;

import java.util.*;
import java.util.function.*;

public class Test {

    public static void myForEach(List<Integer> list, Function<Integer, Void> myFunction) {
      list.forEach(functionToBlock(myFunction));
    }

    public static void displayInt(Integer i) {
      System.out.println(i);
    }


    public static void main(String[] args) {
      List<Integer> theList = new ArrayList<>();
      theList.add(1);
      theList.add(2);
      theList.add(3);
      theList.add(4);
      theList.add(5);
      theList.add(6);
      myForEach(theList, Test::displayInt);
    }
}

我想要做的是使用方法引用displayInt将方法传递给方法myForEach.编译器会产生以下错误:

src/test/Test.java:9: error: cannot find symbol
      list.forEach(functionToBlock(myFunction));
                   ^
  symbol:   method functionToBlock(Function<Integer,Void>)
  location: class Test
src/test/Test.java:25: error: method myForEach in class Test cannot be applied …

可选用于表示可为空的对象,此类的一些用途包括

1. 作为方法返回类型,作为返回null的替代方法,
   表示没有可用的值
2. 区分"未知"(例如,不存在于地图中)和"已知没有值"(存在于地图中,值为
   Optional.absent())
3. 在不支持null的集合中包装可存储的引用以进行存储(尽管还有其他几种方法应该首先考虑)

对于第一种情况,我是否需要在所有可空的返回方法中返回Optional？

我最近开始学习CPU和操作系统是如何工作的,我对使用提供多任务处理的操作系统的单CPU机器的操作感到困惑.

因此,假设我的机器有一个CPU,这意味着,在任何给定时间,只有一个进程可以运行.

现在,我只能假设操作系统用来控制对宝贵CPU时间的访问的调度程序也是一个过程.

因此,在该机器中,用户进程或调度系统进程在任何给定时间点运行,但不是两者都运行.

所以这是一个问题:

一旦调度程序将CPU的控制权交给另一个进程,它如何重新获得CPU时间再次运行以进行其调度工作？我的意思是,如果当前运行的任何给定进程没有放弃(产生)CPU,那么调度程序本身如何再次运行并确保正确的多任务处理？

到目前为止,我一直在思考,如果用户进程通过系统调用请求I/O操作,那么在系统调用中我们可以确保为调度程序再次分配一些CPU时间.但我甚至不确定这是否有效.

另一方面,如果有问题的用户进程本质上是CPU绑定的,那么从这个角度来看,它可以永远运行,永远不会让其他进程,甚至调度程序再次运行.

假设时间分片调度,我不知道调度程序如何在执行另一个进程时切片时间,甚至不运行？

我非常感谢您在此方面提供的任何见解或参考.

这个新的界面模型是如何工作的以及它是什么

• 由此产生的钻石问题
• 此实现的多重继承特性
• 以及使用接口实现的优先级？

我有一个项目,我使用sl4j与log4j.我最近为我的项目添加了一些新的依赖项,我添加的其中一个新依赖项包括对logback-classic的传递依赖,其中包括sj4j的另一个绑定.

我想摆脱logback,但我不知道我的哪些直接依赖项添加了传递依赖项,以便我可以排除它.

在maven中,我知道如何获取整个依赖关系图以确定哪个是传递依赖的来源,但我不知道如何使用gradle执行此操作.

有谁知道如何使用gradle获取传递依赖的源依赖？

我正在编写一小段代码,我在内部处理可变映射中的数据,而后者又有可变列表.

我想将我的数据暴露给API用户,但为了避免任何不安全的数据发布,我想在不可变集合中公开它,即使内部由可变集合处理也是如此.

class School {

    val roster: MutableMap<Int, MutableList<String>> = mutableMapOf<Int, MutableList<String>>()

    fun add(name: String, grade: Int): Unit {
        val students = roster.getOrPut(grade) { mutableListOf() }
        if (!students.contains(name)) {
            students.add(name)
        }
    }

    fun sort(): Map<Int, List<String>> {
        return db().mapValues { entry -> entry.value.sorted() }
                .toSortedMap()
    }

    fun grade(grade: Int) = db().getOrElse(grade, { listOf() })
    fun db(): Map<Int, List<String>> = roster //Uh oh!
}

我设法只在我的类的公共API中公开Map和List(它是不可变的),但我实际暴露的实例仍然具有固有的可变性.

这意味着API用户可以简单地将我返回的地图强制转换为ImmutableMap,并获得对我的类内部的宝贵私有数据的访问权限,这些私有数据旨在受到这种访问的保护.

我找不到在收集工厂方法一个拷贝构造函数mutableMapOf()或mutableListOf(),所以我想知道什么是将可变集合到一个不变的一个最好的和最有效的方式.

有什么建议或建议吗？

这是一个问题,第一个代码清单编译得很好(JDK 1.6 | JDK 1.7):

ArrayList<String> a = new ArrayList<String>();
String[] s = a.toArray(new String[0]);

但是,如果我将List引用声明为原始类型:

ArrayList a = new ArrayList();
String[] s = a.toArray(new String[0]);

我收到编译器错误,说明String[]是必需的,但是Object[]找到了.

这意味着我的编译器将泛型方法解释为返回,Object[]尽管String[]它接收了一个as参数.

我加倍检查了toArray(myArray)方法签名:

<T> T[] toArray(T[] a);

因此,它是一个参数化方法,其类型参数<T>与List(即<E>)的类型参数无关.

我不知道在这里使用原始类型如何影响使用独立类型参数的参数化方法的评估.

• 有谁知道为什么这段代码不能编译？
• 有没有人知道记录这种行为的任何参考？

我将首先说我是Java开发人员,学习用C#编程.因此,我将我所知道的与我正在学习的东西进行比较.

我已经玩C#generics几个小时了,我已经能够在C#中重现我在Java中所知道的相同的事情,除了使用协方差和逆变的几个例子.我正在阅读的这本书在这个主题上并不是很好.我肯定会在网上寻求更多信息,但是当我这样做时,也许你可以帮我找到以下Java代码的C#实现.

一个例子胜过千言万语,我希望通过寻找一个好的代码示例,我将能够更快地吸收它.

协方差

在Java中,我可以这样做:

public static double sum(List<? extends Number> numbers) {
    double summation = 0.0;
    for(Number number : numbers){
        summation += number.doubleValue();
    }
    return summation;
}

我可以使用以下代码:

List<Integer> myInts = asList(1,2,3,4,5);
List<Double> myDoubles = asList(3.14, 5.5, 78.9);
List<Long> myLongs = asList(1L, 2L, 3L);

double result = 0.0;
result = sum(myInts);
result = sum(myDoubles)
result = sum(myLongs);

现在我确实发现C#仅在接口上支持协方差/逆变,只要它们已被明确声明(out/in).我想我无法重现这个案例,因为我找不到所有数字的共同祖先,但我相信如果存在共同的祖先,我可以使用IEnumerable来实现这样的事情.因为IEnumerable是协变类型.对？

有关如何实施上述列表的任何想法？请指出我正确的方向.是否有所有数字类型的共同祖先？

逆变

我试过的逆变例如下.在Java中,我可以将一个列表复制到另一个列表中.

public static void copy(List<? extends Number> source, List<? super Number> destiny){
    for(Number number : source) {
       destiny.add(number);
    } …

我有一个由一组微服务构建的应用程序.一个服务接收数据,通过Spring JPA和Eclipse链接持久保存,然后向第二个服务发送警报(AMQP).

根据特定条件,第二个服务然后针对持久数据调用RESTfull Web服务以检索保存的信息.

我注意到有时RESTfull服务返回一个空数据集,即使数据先前已保存过.查看持久服务的代码,已使用save而不是saveandflush,因此我假设数据没有快速刷新以供下游服务查询.

• saveandflush是否有成本,我应该感到厌倦,或者默认使用它是否合理？
• 它是否能确保下游应用程序的数据可用性的即时性？

我应该说原始的持久性函数包含在内 @Transactional