小编ng.*_*bie的帖子

我是Angular和Angular2的初学者.我对工作流程的结构感到困惑.我一直在查看Angular2站点中的示例项目.

如果我错了,请纠正我,但我所知道的是所有的打字稿都是由打字稿编译器转换成javascript的.然后编译的javascript实际上是在浏览器中运行的.

现在,如果我使用ES6导入语句将javascript文件导入typescript,如下所示:

import { NgModule }      from '@angular/core';

为什么我再次需要使用SystemJS来加载它们:

map: {
      // our app is within the app folder
      app: 'app',
      // angular bundles
      '@angular/core': 'npm:@angular/core/bundles/core.umd.js',

我的意思是,这不是反效果吗？查看ts文件的已转换的javascript,它显示所有import语句都转换为require()语句. 首先,require()在ES5 js文件中是如何工作的,如果是这样的话,那么SystemJS是怎么做的.

这让我很困惑.任何帮助将不胜感激.

我是Angular2的新手,很难理解Angular2中的导入和导出是怎么@NgModule 回事.

以下面的代码为例:

@NgModule({
  imports: [
    RouterModule.forChild(heroesRoutes)
  ],
  exports: [
    RouterModule
  ]
})

在导入部分我要导入什么？ 路由器模块,或forChild()函数,或函数forChild()返回的模块？ 哪一个 ？

此外,当我RouterModule再次导出时,文档说明如下 - :

我们的最后一步是重新导出RouterModule.通过重新导出RouterModule,我们的功能模块将在使用我们的路由模块时提供路由器指令.

那么这是否意味着无论什么模块导入上面的NgModule,都可以访问RouterModule中的所有代码？

有点像我在C中编写包含math.h的自定义头文件,如果我现在使用该头文件,我不再需要在我的程序中单独包含math.h.我的比喻是否正确？

有人可以在这里解释核心概念,这样每次看到新代码时我都不会感到难过.

我刚开始学习Java 8中的Stream API和一般的函数式编程,但不是Java新手.我有兴趣了解和理解Stream API如何选择执行计划.

它是如何知道要并行化的哪些部分以及哪些部分不是？甚至存在多少种执行计划？

基本上,我想知道为什么Java 8中的Streams有助于使事情变得更快,以及它如何做到这一点"神奇".

我找不到很多关于它如何运作的文献.

假设我有以下三个数组：

int r[] = {255,255,255};
int g[] = {0,0,0};
int b[] = {255,255,255};

所有数组都将具有相同的长度。

我想将它们转换为Color类型的对象数组：

public class Color {
   int r,g,b;

   public Color(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
   }

}

Color[] arr = new Color[3];

其中每个索引将包含来自 3 个数组的相同索引的 r,g,b。例如，让我们说Color[1] = new Color(r[1],g[1],b[1]);

我如何使用 Java Streams 做到这一点？

代码的 for 循环变体是：

Color arr[] = new Color[r.length];

for(int i=0;i<r.length;i++) {
    Color c = new Color(r[i],g[i],b[i]);
    arr[i] = c; …

我编了从源头GCC，但我似乎无法完全理解的效用gcc编制本身3倍。

这有什么好处？

这个答案说：

• 使用现有的 C 编译器构建新版本的 GCC
• 用您刚刚构建的 GCC 重新构建新版本的 GCC
• （可选）重复步骤 2 以进行验证。

现在我的问题是，一旦第一步完成并构建了编译器，为什么还要浪费时间重建它？

只是为了验证吗？如果是这样，那似乎很浪费。

事情在这里变得更复杂，

这个构建比以前的包更复杂，因为您将更多信息发送到配置脚本中，而 make 目标不是标准的。

我的意思是整个编译器都是用 C 编写的，那么为什么不一次性完成所有事情呢？

三相自举有什么用？

提前致谢。

采取以下来自nodejs事件循环文档的代码：

 // timeout_vs_immediate.js
    setTimeout(() => {
      console.log('timeout');
    }, 0);

    setImmediate(() => {
      console.log('immediate');
    });

根据文档：

例如，如果我们运行以下不在I / O周期（即主模块）内的脚本，则执行两个计时器的顺序是不确定的，因为它受进程性能的约束。

为什么上述说法是正确的？是因为nodejs运行时实际上使用了多个线程来挑选必须执行的回调。

我的直觉是什么：有两个线程为setTimeout和执行回调setImmediate因此，当都可用时，这会导致竞争状态，因此输出将是不确定的。

这是对的吗 ？还是有其他原因导致不确定性？

我试图了解新的功能模型如何Spring Cloud Streams工作以及配置在幕后如何实际工作。

我无法弄清楚的属性之一是spring.cloud.stream.source.

这个属性实际上意味着什么？

我无法理解文档：

请注意，前面的示例没有定义任何源函数（例如，Supplier bean），从而使框架没有触发器来创建源绑定，这对于配置包含函数 bean 的情况来说是典型的。因此，为了触发源绑定的创建，我们使用 spring.cloud.stream.source 属性，您可以在其中声明源的名称。提供的名称将用作创建源绑定的触发器。

如果我不需要怎么办Supplier？

源绑定到底是什么？为什么它很重要？

如果我只想生成消息传递主题怎么办？我还需要这个房产吗？

我也无法理解它是如何在此处的示例中使用的。

采取以下代码，对列表进行排序，然后对其进行过滤：

public static void main(String[] args) {
        List<Integer> list = List.of(3,2,1);
        
        List<Integer> filtered =  list.stream()
                .sorted() // Does sorted() sort the entire array first ? Then pass the entire sorted output to filter ?
                .filter(x -> x < 3)
                .collect(Collectors.toList());
        
        System.out.println(filtered);
    }

整个sort()过程是否先发生，然后传递给filter()？

那么这不是违反了流应该做的事情吗？

我的意思是，他们应该一次处理一个元素。

我是动态编程的新手,还不了解它可以解决的大多数类型的问题.因此,我在理解Jewelry topcoder问题的解决方案时遇到了问题.

有人至少可以给我一些关于代码在做什么的提示吗？

最重要的是这个问题是子集和问题的变体吗？因为这是我正在研究的,以理解这个问题.

这两个功能实际上是在计算什么？为什么我们实际使用两个DP表？

void cnk() {
  nk[0][0]=1;
  FOR(k,1,MAXN) {
    nk[0][k]=0;
  }  

  FOR(n,1,MAXN) {
      nk[n][0]=1;
      FOR(k,1,MAXN) 
        nk[n][k] = nk[n-1][k-1]+nk[n-1][k];
     }
}

void calc(LL T[MAXN+1][MAX+1]) {
  T[0][0] = 1;
  FOR(x,1,MAX) T[0][x]=0;
  FOR(ile,1,n) {
    int a = v[ile-1];
    FOR(x,0,MAX) {
      T[ile][x] = T[ile-1][x];
      if(x>=a) T[ile][x] +=T[ile-1][x-a];
    }
  }
}

如何使用以下逻辑构建原始解决方案？

FOR(u,1,c) {
  int uu = u * v[done];
  FOR(x,uu,MAX)
  res += B[done][x-uu] * F[n-done-u][x] * nk[c][u];
  }
done=p;
}

任何帮助将不胜感激.

在调用某些 Web 服务的 REST API 期间，我使用 Apache HTTP 客户端进行连接池。

奇怪的是，尽管我使用了 HTTP 连接池，但我的性能并没有提高。

我正在使用Apache HTTP 客户端连接到我的 Web 服务，代码如下来自文档：

PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();

cm.setMaxTotal(200);

cm.setDefaultMaxPerRoute(20);

HttpHost host = new HttpHost("abc.com", 80);
cm.setMaxPerRoute(new HttpRoute(host), 50);

CloseableHttpClient httpClient = HttpClients.custom()
        .setConnectionManager(cm)
        .build();

我正在使用 SpringRestTemplate来包装HttpClient使用 Spring 的 Apache的实现HttpComponentsClientHttpRequestFactory。

但即使我不使用连接池，即。使用SimpleClientHttpRequestFactorySpring，我没有得到性能优势。

我的连接仍然需要相同的时间才能完成。

我所做的是实现 HTTP 连接池的正确方法吗？难道我做错了什么？

请让我知道是否需要我方提供更多信息。