小编Era*_*ran的帖子

我正在尝试为存折APN创建服务器端实现,但服务器不喜欢设备给我的推送令牌.如果我将令牌发送到Apple的沙箱服务器,它会向我发送"无效令牌"响应.如果我将令牌发送到Apple的生产服务器,它会将反馈服务中的令牌作为我应该从列表中删除的令牌返回.至少我知道APN证书和服务器的连接工作正常.

我的iPhone 4s已启用开发.为开发和生产启用了APP ID,并在配置文件中启用了设备.我已经验证了32字节二进制令牌数据相对于从设备发送的字符串令牌是正确的.

我的一个问题是,设备中的存折如何确定使用哪个令牌(开发与生产)？我现在更喜欢使用沙箱环境,但我不确定如何"选择"它.

我已经看到类似的主题,但没有一个似乎有这个问题的答案.我真的很沮丧,因为我觉得我很接近这项工作!提前感谢任何建议!

我正在使用新的谷歌云消息

(GoogleCloudMessaging gcm =
           GoogleCloudMessaging.getInstance (context);)

我正在关注这个例子,它非常好并且完美地工作:

https://github.com/commonsguy/cw-omnibus/tree/master/Push/GCMClient2

通过这个例子,我可以在GCM中注册,但是我尝试取消注册失败了.

在文档中表明您应该使用以下意图:

com.google.android.c2dm.intent.UNREGISTER

并使用如下:

 Intent unregIntent = new Intent ("com.google.android.c2dm.intent.UNREGISTER");
     unregIntent.putExtra ("app", PendingIntent.getBroadcast (this, 0, new Intent (), 0));
     StartService (unregIntent);

不工作......

正如我所说,寄存器工作正常,但不知道如何取消注册.

我必须做的不仅仅是意图吗？我究竟做错了什么？

我感谢任何帮助

感谢致敬

我正在创建一个应用程序,它不断使用推送通知作为用户之间通信的方式(各种消息).这整个考验似乎让我有点疯狂,所以这里有几个我无法找到答案的问题.

1. 我发现未经过身份验证的Web服务(没有证书的服务)会被限制为每个订阅每天500次推送通知MPNS.但是,在试图找到限制时,我无法在任何地方找到这样的提及WNS.是否存在这些限制/要求WNS？

2. 充其量,我发送了很多推送通知(即每个活跃用户每秒1-3次).我知道这可能会耗尽最小设备的电池寿命(我的目标通常是Windows 8设备),但轮询服务器以获取更新也是如此.我的方法具有响应速度快的优点,但我不确定推送(原始)通知是否适用于此类通信.还有其他选择吗？基本上我由于移动网络的性质而放弃了持久连接选项(连接可能会丢失)

3. 这两者之间的实际差异是什么？

也许我对这个术语有点混淆,其他一些消息来源暗示我甚至不能四处走动MPNS,但却不能WNS做到这一点？

我不确定这是否是发布这些问题的正确媒体,但我希望有人能够对此有所了解.

看起来我可以list.forEach(a -> a.stuff())直接在我的收藏中调用,而不是list.stream().forEach(a -> a.stuff()).我何时会使用另一个(parallelStream()旁边......)？

我使用了TreeMap键是a的位置String,值是类型Integer.当我输出Map对象时,它不按排序顺序打印.

这是我使用的代码:

TreeMap<String, Integer> m = new TreeMap<String, Integer>();
m.put("Hello", 1);
m.put("world", 2);
m.put("Zertt", 5);
m.put("Hello", 1);
m.put("world", 2);
System.out.println("map : " + m);

我希望输出像这样排序:

map:{Hello = 1,world = 2,Zertt = 5}

但相反,我得到了这个:

map:{Hello = 1,Zertt = 5,world = 2}

我有一个与Java 8中的lambda表达式相关的问题.

考虑以下Message课程:

  public class Message implements MessageBase 
  {  
      private String id;
      private String message;
      private String author;
      private Long timestamp;

      public Message()
      {
          this.id=null;
          this.message=null;
          this.author=null;
          this.timestamp= null;
      }

      public Message(String id, String message,String author,Long timestamp)
      {
          this.id=id;
          this.message=message;
          this.author=author;
          this.timestamp= timestamp;
      }

      public String getId() 
      {
          return id;
      }

      public void setId(String id) 
      {
          this.id = id;
      }

      public String getMessage() 
      {
          return message;
      }

      public void setMessage(String message) 
      {
          this.message = message;
      }

      public String …

我正在学习核心java中的静态块功能.

public class ClassResolution {
    static class Parent {
        public static String name = "Sparsh";
        static {
            System.out.println("this is Parent");
            name = "Parent";
        }
    }

    static class Child extends Parent {
        static {
            System.out.println("this is Child");
            name = "Child";
        }
    }

    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println(Child.name);
    }
}

我认为输出将是:

this is Parent 
this is Child 
Child

但实际输出是:

this is Parent
Parent

而且我不知道为什么.

当reduce()在并行流上使用该操作时,OCP考试书指出reduce()参数必须遵守某些原则.这些论点如下:

1. 必须定义标识,使得对于流u中的所有元素,combiner.apply(identity,u)等于u.
2. 累加器运算符op必须是关联的和无状态的,(a op b) op c等于a op (b op c).
3. 组合器运算符还必须是关联的和无状态的并且与标识兼容,以便对于所有u和t combiner.apply(u, accumulator.apply(identity, t))等于accumulator.apply(u,t).

考试书提供了两个例子来说明这些原则,请参阅下面的代码:

关联的示例:

System.out.println(Arrays,asList(1,2,3,4,5,6))
.parallelStream()
.reduce(0,(a,b) -> (a-b))); //NOT AN ASSOCIATIVE ACCUMULATOR

OCP书中对此有何说法:

它可能会输出-21,3或其他一些值,因为累加器函数违反了associativity属性.

身份要求的示例:

System.out.println(Arrays.asList("w","o","l","f"))
.parallelStream()
.reduce("X", String::concat));

OCP书中对此有何说法:

如果我们使用的身份参数不是真正的身份值,您可以看到其他问题.它可以输出XwXoXlXf.作为并行过程的一部分,标识将应用于流中的多个元素,从而导致非常意外的数据.

我不明白这些例子.使用累加器示例,累加器以0 -1 = -1然后-1 -2开始,其中= -3然后-6等等一直到-21.我明白,因为生成的arraylist不同步,结果可能是不可预测的,因为竞争条件等的可能性,但为什么累加器不关联？Woulden也不会(a+b)导致不可预测的结果？我真的没有看到示例中使用的累加器有什么问题,以及为什么它不是关联的,但是我仍然不能完全理解关联原则是什么.

我也不了解身份的例子.据我所知,如果4个独立的线程同时开始与身份一起累积,那么结果确实可能是XwXoXlXf,但这与身份参数本身有什么关系呢？究竟什么是适当的身份才能使用呢？

我想知道是否有人可以更多地了解这些原则.

谢谢

在map函数中Stream我们可以将一个对象转换为另一个对象,因此我们可以Stream将包含3个A类元素的一个转换为另一个StreamB类型的3个元素.

如何根据条件将3个类型的元素转换A Stream为6个或更多类型的元素B Stream？

在代码方面.

我们可以做的

Stream<B> converted = original.map( a -> new B(a) );

但我们怎么能这样做呢？

Steam<B> converted = original.map( a -> { 
    if(a.split()){
        return [ new B(a), new B(a) ];
    }else return new B(a);
});

我无法找到并理解如何做到这一点.谢谢你.

我已经看到很多方法,其中一个新类在lambda方法引用中实例化,但似乎无法理解为什么.何时是new方法引用中需要的关键字？

例如,以下传递编译:

UnaryOperator<String>stringToUpperCase = String::toUpperCase;

但这不是:

UnaryOperator<String>stringToUpperCase = new String()::toUpperCase;