Java 通用编写器/输出器。读卡器对迭代器是什么，写卡器对X是什么？

在Java中，用于拉取对象（而不是字符）的抽象版本是

问题是有一个抽象版本的

可追加的

，或者我可以推送对象（即接口）

过去我只是制作自己的界面，如：

public interface Pusher<T> {
    public void push(T o);
}

我在这里使用的是

可追加的

，但我更愿意使用

推送器

回调。相信我一次

最后，我之前选择的另一个选择是完全违反番石榴的或

功能

（尽管这看起来更糟）。它违反了契约，因为这些目标是幂等的（尽管我认为如果您一直返回

true

）

番石榴所提供的东西对Python的生成器来说是有点奇怪的，这要归功于它的特性

我添加了一个，但我同意他们的观点，即添加这样的基本内容并不是他们的工作。

最接近的是，但没有太多使用

public update(Observable o, Object arg)

我不会用Iterable代替Reader，我会创建一个您选择的消费者

一种常见的模式是不使用接口，而是使用注释

e、 g

---

当该类作为侦听器添加时，它订阅

更新

、

插入

和

删除

对象，并忽略任何其他对象。这允许一个对象以类型安全的方式订阅不同类型的消息。

主题可以有多个视图：

迭代器的对偶是。迭代器“使用”集合中的值，生成器“提供”它们。但发电机和作家有点不同。对于作者来说，您可以决定何时将元素推入其中。另一方面，生成器为您逐个提供一系列值。Java对生成器没有任何特定的语言支持。另见

与迭代器相反的是，您可以将值推入其中。我认为Java对此没有任何抽象概念。我看到的结束是Scala的（忽略了

clear（）

方法）

---

现在在几个项目中，我已经为此定义了一个我称之为接收器的东西：

---

方法希望从这样一个源中提取

T

类型的项目，需要一个

source类型的参数，这是我决定做的（我认为这是其他人给出的最好的选择：p）

我将向后移植Java8的Lambda类（
Java.util.functions.*
）。特别是这个：

/**
 * Performs operations upon an input object which may modify that object and/or
 * external state (other objects).
 *
 * <p>All block implementations are expected to:
 * <ul>
 * <li>When used for aggregate operations upon many elements blocks
 * should not assume that the {@code apply} operation will be called upon
 * elements in any specific order.</li>
 * </ul>
 *
 * @param <T> The type of input objects to {@code apply}.
 */
public interface Block<T> {
/**
 * Performs operations upon the provided object which may modify that object
 * and/or external state.
 *
 * @param t an input object
 */
void apply(T t);

// Some extension methods that I'll have to do with below.
}

/**
*对输入对象执行操作，该操作可能会修改该对象和/或
*外部状态（其他对象）。
*
*所有块实现都应：
*

*
用于对多个元素块进行聚合操作时
*不应假定将调用{@code apply}操作
*元素的任何特定顺序
*
*
*@param{@code apply}的输入对象类型。
*/
公共接口块{
/**
*对提供的对象执行可能修改该对象的操作
*和/或外部状态。
*
*@param t输入对象
*/
无效申请（T）；
//下面我将介绍一些扩展方法。
}

基本上，我将创建一个新的名称空间，如
com.snaphop.backport.java.util.functions.*
，并移动接口，使它们与Guava一起工作。显然，我没有lambda语法或扩展方法，但我可以解决这些问题。理论上，当Java8面世时，我只需要做一个名称空间切换
 只适用于CharSequences。脑海中最接近的东西是。也就是说，我不认为你所看到的
阅读器
和
迭代器
之间的类比有什么意义。IO子系统具有如此低级别接口的原因可能不是信息隐藏；相反，我要说的是，他们正在公开本机低级API，以便能够编写高性能自定义IO代码（用于数据库或网络服务器），而无需缓冲开销。（或者，因为无论是谁设计了IO API，他都热衷于体系结构。Python似乎只需要一个IO抽象就可以了。）@millimoose让我给你一个有用的例子。从一个数据库中提取一个巨大的结果集，你希望客户端提供，以处理进入的对象流。是的，我一直使用Guava的事件系统来处理类似的事情，但它更适合于一个长期运行的系统，而不是像writer或reader这样的一次性对象。@PeterPudlak我通过使用Guava的发电机来绕过Java没有发电机的问题。顺便说一句，我知道作家、发电机和收藏之间的区别。所以#1对其他人来说是很好的评论，它几乎是对我的侮辱。@AdamGent抱歉，我不是那个意思，你在你的问题中没有提到你知道发电机。没问题。我想你看到了在我编辑之前发表文章。我非常喜欢Python的生成器。我喜欢
InterruptedException
的想法。如果你看看这个例子，我已经提出了
\isAccepting（）的想法
方法，但只是为了与
迭代器
保持一致。但我更喜欢你的方法。至于
生成器
，当Python问世时我非常喜欢它，我只是将Guava的AbstractIterator子类化，但这仅仅是因为有太多东西与
迭代器
一起工作。我还将调用接口
消费者
（Sink）和
生产者
（Source）。我避开了“消费者”和“生产者”这两个词因为我从调用者的角度来构建接口：调用者本身不知道是在生成还是公开某些东西；他只知道他有一个获取东西的来源。同样，他也不知道是否有东西在消耗他的贡献；他只知道有一个地方可以放下它们。我忘了告诉我关于
源代码
@Subscriber
public void onUpdate(Update update) { }

@Subscriber
public void onInsert(Insert insert) { }

@Subscriber
public void onDelete(Delete delete) { }

interface Sink<T> {
  void put(T contribution);
}

interface Source<T> {
  T get();
}

interface Sink<T> {
  void put(T contribution) throws InterruptedException;
}


interface Source<T> {
  T get() throws InterruptedException;
}

/**
 * Performs operations upon an input object which may modify that object and/or
 * external state (other objects).
 *
 * <p>All block implementations are expected to:
 * <ul>
 * <li>When used for aggregate operations upon many elements blocks
 * should not assume that the {@code apply} operation will be called upon
 * elements in any specific order.</li>
 * </ul>
 *
 * @param <T> The type of input objects to {@code apply}.
 */
public interface Block<T> {
/**
 * Performs operations upon the provided object which may modify that object
 * and/or external state.
 *
 * @param t an input object
 */
void apply(T t);

// Some extension methods that I'll have to do with below.
}