为什么Java.UTL.SET<V>接口不提供get(object o)方法?[关闭]

而purity参数确实使方法 get(Object) 值得怀疑的是,潜在的意图并非毫无意义。

有各种类和接口族,它们可以稍微重新定义 equals(Object) .我们只需查看集合接口即可。例如,ArrayList和LinkedList可以相等;它们各自的内容只需要是相同的,并且顺序相同。

因此,有很好的理由找到 匹配 集合中的元素。也许一个更清晰的表达意图的方法是

public interface Collection<E> extends ... {
  ...
  public E findMatch(Object o) throws UnsupportedOperationException;
  ...
}

注意,这个API的值比集合中的值更大。

至于这个问题本身,我没有任何理论来解释为什么省略这样一个操作。我会这么说的 最小跨度集参数 不适用,因为集合API中定义的许多操作都是由便利性和效率驱动的。

问题是:集合不用于“获取”对象,而是用于添加和测试存在性。 我知道你在找什么,我遇到了类似的情况,最后使用了一个相同对象的关键点和价值图。

编辑:只是为了澄清: http://en.wikipedia.org/wiki/Set_(abstract_data_type)

几年前我在Java论坛上遇到过同样的问题。他们告诉我已经定义了集合接口。无法更改,因为它将破坏集合接口的当前实现。然后,他们开始说胡话,就像你在这里看到的:“set不需要get方法”,并开始钻我,地图必须始终用于从一个集合中获取元素。

如果仅将集合用于数学运算(如交集或并集),则可以使用contains()即可。但是,集合中定义了集合来存储数据。我用关系数据模型解释了set中的need get()。

在下面的内容中,SQL表类似于类。列定义属性(称为Java中的字段),记录表示类的实例。所以一个物体就是一个向量场。有些字段是主键。它们定义对象的唯一性。这就是Java中的容器()所做的事情:

class Element {

        public int hashCode() {return sumOfKeyFields()}
        public boolean equals(Object e) {keyField1.equals(e) && keyField2.equals(e) && ..}

我不知道数据库的内部结构。但是,在定义表时,只指定一次键字段。只需用@primary注释关键字段。在向表中添加记录时,不需要第二次指定键。您不会像在映射中那样将键与数据分离。 SQL表是集合。它们不是地图。然而,它们提供了get()。 除了保持唯一性和contains()检查之外。

在《计算机编程艺术》中,D.Knuth在介绍搜索时也这么说:

本章的大部分内容都是研究一个非常简单的搜索 问题:如何查找与给定 识别。

你看,数据是用标识存储的。不是指向数据的标识,而是 带标识的数据 . 他继续说:

例如,在数字应用程序中,我们可能需要 求f(x),给定x和f值的表;在a中 非数值应用,我们可能想找到英语 翻译一个给定的俄语单词。

看起来他开始谈论地图。然而,

一般来说,我们假设已经存储了一组n条记录, 问题是找到合适的。我们通常要求 要区分的n个键,以便每个键唯一地标识其 记录。所有记录的集合称为 桌子 或 文件 , 其中“table”一词通常用于表示一个小文件,以及 “文件”通常用于表示一个大表。大文件或 文件组通常称为 数据库 .

搜索算法被称为参数k, 问题是找出哪个记录的键是k。虽然 搜索的目的是找到记录中存储的信息 与k相关,本章中的算法通常忽略 除了钥匙本身以外的一切。在实践中我们可以找到 一旦找到k,相关数据;例如,如果k出现在 位置表+i,关联的数据(或指向它的指针)可能是 在位置表+I+1中

也就是说,搜索将定位记录的密钥文件,而不应将密钥“映射”到数据。两者都位于同一个记录中,作为Java对象的文件。也就是说,搜索算法像在集合中那样检查记录的关键字段,而不是像在映射中那样检查某个远程键。

我们有n项要分类,我们将称之为 记录 和 n条记录的整个集合称为 文件 . 各 记录RJ有一个键KJ,它控制排序过程。附加的 除钥匙外,数据通常也存在;这是一个额外的“卫星” 信息“除了必须携带外,对分类没有任何影响。 作为每个记录的一部分。

在他关于排序的讨论中,我看不到需要在一个额外的“密钥集”中复制密钥。

…[“计算机编程艺术”,第6章,引言]

实体集 集合或设置特定实体类型的所有实体 [http://wiki.answers.com/q/what_is_entity_and_entity_set_in_dbms] 单个类的对象共享其类属性。同样,在数据库中做记录。它们共享列属性。

集合的特殊情况是类范围,它是 属于该类的所有对象的集合。类范围允许 将类视为关系

…[“数据库系统概念”,第6版]

基本上,类描述了所有实例的公共属性。关系数据库中的表也一样。 "The easiest mapping you will ever have is a property mapping of a single attribute to a single column." 这就是我所说的情况。

在证明对象和数据库记录之间的类比(同构)上,我太冗长了,因为有一些愚蠢的人不接受它(证明他们的集合不能有 得到 方法)

你在重播中看到,那些不理解这一点的人怎么会说用get设置是多余的?这是因为它们滥用的映射(它们强制使用它来代替集合)引入了冗余。他们的put调用(obj.getkey(),obj)存储两个键:作为对象一部分的原始键和映射的键集中的一个副本。重复就是冗余。它还涉及到更多的代码膨胀和浪费运行时消耗的内存。我不知道DB的内部结构,但是良好设计和数据库规范化的原则认为这种复制是坏主意。- there must be only one source of truth . 冗余意味着可能会发生不一致:密钥映射到具有不同密钥的对象。不一致是冗余的表现。 Edgar F. Codd proposed DB normalization 只是为了消除冗余及其推断的不一致性。教师对规范化有明确的认识: Normalization will never generate two tables with a one-to-one relationship between them. There is no theoretical reason to separate a single entity like this with some fields in a single record of one table and others in a single record of another table

所以,我们有4个参数,为什么使用映射来实现get-in集是不好的:

1. 当我们有一组独特的物体时,地图是不必要的。
2. 映射在运行时存储中引入了冗余
3. map在db中引入代码膨胀(在集合中)
4. 使用映射与数据存储规范化相矛盾

即使你不知道记录集的思想和数据规范化,与集合一起玩,你也可以自己发现这个数据结构和算法,就像我们,Or.Eclipse。KEYED HASSET和C++ STL设计者所做的那样。

我因为指出这些想法而被禁止参加太阳论坛。偏执是反对理性的唯一论据,这个世界被偏执者所统治。他们不想看到概念以及事物是如何不同/改进的。他们只看到真实世界,无法想象Java集合的设计可能有缺陷并可以改进。向这些人提醒基本原理是危险的。他们教导你他们的盲目,如果你不服从,他们就会惩罚你。

新增DEC 2013: SICP also says that DB is a set with keyed records rather than a map :

典型的数据管理系统花费大量时间 访问或修改记录中的数据,因此需要 一种访问记录的有效方法。这是通过识别 作为识别键的每个记录的一部分。现在我们代表 数据库作为一组记录。

好吧,如果你已经从集合中“得到”了这个东西,你不需要得到它,对吗?;-)

我认为你使用地图的方法是正确的。听起来像是您试图通过equals()方法“规范化”对象,我一直按照您的建议使用映射来完成这项工作。

我不确定你是在寻找一个解释为什么集合是这样的,还是一个简单的解决问题的方法。其他的答案涉及前者,所以这里有一个对后者的建议。

您可以迭代集合的元素,并使用equals()方法测试它们中的每个元素是否相等。它易于实现,不易出错。显然,如果您不确定元素是否在集合中,请事先使用contains()方法进行检查。

例如,与hashset的contains()方法相比,这是不高效的,后者可以“查找”存储元素,但不会返回它。如果您的集合可能包含许多元素,那么它甚至可能是使用“较重”的解决方案(如您提到的映射实现)的原因。但是,如果这对你来说很重要(我确实看到了拥有这种能力的好处),那么它可能是值得的。

所以我理解你可能有两个相等的物体,但它们不是同一个例子。

如

Integer a = new Integer(3);
Integer b = new Integer(3);

在这种情况下,a.等于(b),因为它们指的是相同的内在值,但a!=b,因为它们是两个不同的对象。

还有集合的其他实现,例如 IdentitySet 在项目之间进行不同的比较。

不过,我认为你正在尝试将不同的哲学应用到Java。如果你的对象是相等的(a.equals(b)),尽管a和b有不同的状态或含义,这里有一些问题。您可能希望将该类拆分为两个或多个实现公共接口的语义类,或者重新考虑.equals和.hashcode。

如果你有Joshua Bloch的 Effective Java 请看一看“重写等于时遵守一般合同”和“最小化可变性”这两章。

只需使用地图解决方案…treeset和hashset也是这样做的,因为它们由treemap和hashmap备份,所以这样做没有任何惩罚(实际上,它应该是一个最小的增益)。

您还可以扩展您最喜欢的集合来添加get()方法。

[]

我认为,对于给定的一些集合实现,您的唯一解决方案是迭代其元素以找到一个等于()的元素,然后在集合中找到匹配的实际对象。

K target = ...;
Set<K> set = ...;
for (K element : set) {
  if (target.equals(element)) {
    return element;
  }
}

如果你把它看作一个数学集合,你可以得到一种找到物体的方法。
与仅包含要查找的对象的对象集合相交。如果交集不是空的,则集合中只剩下您要查找的项。

public <T> T findInSet(T findMe, Set<T> inHere){
   inHere.retainAll(Arrays.asList(findMe));
   if(!inHere.isEmpty){
       return inHere.iterator().next();
   }
   return null;
}

它不是最有效的内存使用方法,但在功能和数学上都是正确的。

我想要集合中已经存在的确切对象实例,而不是.equals()返回true的可能不同的对象实例。

这没有道理。假设你这样做:

Set<Foo> s = new Set<Foo>();
s.Add(new Foo(...));
...
Foo newFoo = ...;

你现在这样做:

s.contains(newFoo)

如果只希望集合中的对象为==newfoo时为true,请使用对象标识实现foo的equals和hashcode。或者,如果您试图将多个相等的对象映射到一个规范的原始对象,那么映射可能是正确的选择。

我认为期望值是,相等实际上代表了某种平等,而不仅仅是两个对象具有相同的主键。如果等号表示两个真正相等的物体,那么一个GET是多余的。您想要的用例建议使用一个映射,可能是一个不同的键值,它表示一个主键,而不是整个对象,然后适当地实现equals和hashcode。

Functional Java 具有一个持久集(由红/黑树支持)的实现,附带地包括 split 方法似乎可以满足您的需要。它返回三个值:

1. 在找到的对象之前出现的所有元素的集合。
2. 类型的对象 Option 如果集合中存在找到的对象,则为空或包含该对象。
3. 在找到的对象之后出现的所有元素的集合。

您可以这样做:

MyElementType found = hayStack.split(needle)._2().orSome(hay);

Object fromSet = set.tailSet(obj).first();

if (! obj.equals(fromSet)) fromSet = null;

做你想要的。我不知道为什么Java隐藏它。

比如,我有一个用户名和ID的用户POJO。 ID保持equals和hashcode之间的协定。 名称不是对象相等的一部分。 我想根据某个地方的输入更新用户的名称,比如,ui。

由于Java集不提供get方法,所以需要在代码中迭代该集合,并在找到相等对象(即ID匹配时)更新名称。

如果您有get方法,则此代码可能已被缩短。

Java现在有各种各样的愚蠢的东西,比如JavaDB和增强的for循环,我不明白为什么在这个特殊的情况下它们是纯粹的。

我也有同样的问题。我通过将集合转换为地图,然后从地图中获取它们来修复它。我用这种方法:

public Map<MyObject, MyObject> convertSetToMap(Set<MyObject> set)
{
    Map<MyObject, MyObject> myObjectMap = new HashMap<MyObject, MyObject>();

    for(MyObject myObject: set){
        myObjectMap.put(myObject, myObject);
    }
    return myObjectMap
}

现在,您可以通过如下方式调用此方法从集合中获取项:

convertSetToMap(myset).get(myobject);

您可以重写类中的等号,让它只检查诸如id或name之类的特定属性。

如果您在Java错误列表中提出了这个请求,我们可以投票表决。我认为至少方便类java.util.collections只需要一个集合和一个对象 它的实现方式类似于

searchSet(Set ss, Object searchFor){

        Iterator it = ss.iterator();
        while(it.hasNext()){
            Object s = it.next();
            if(s != null && s.equals(searchFor)){
                return s;
            }
        }

这显然是set api的缺点。

简单地说,我想在我的集合中查找一个对象并更新它的属性。

我必须循环通过我的(散列)集才能到达我的对象…叹息…

我同意我希望看到set实现提供一个get()方法。

作为一个选项,在对象实现(或可以实现)java.lang.comparable的情况下,可以使用treeset。然后,通过调用heiling()或floor()来获取get()类型函数,然后检查结果是否为非空并等于比较对象,例如:

TreeSet myTreeSet<MyObject> = new TreeSet();
:
:

// Equivalent of a get() and a null-check, except for the incorrect value sitting in
// returnedMyObject in the not-equal case.
MyObject returnedMyObject = myTreeSet.ceiling(comparisonMyObject);

if ((null != returnedMyObject) && returnedMyObject.equals(comparisonMyObject)) {
:
:
}

没有get的原因很简单:

如果你需要从集合中得到对象x是因为你需要从x中得到一些东西,而你没有这个对象。

如果您没有对象,那么您需要一些方法(键)来定位它。…它的名字,一个曾经的数字。这就是地图的正确之处。

map.get(“key”)—>x!

集合没有键,您需要遍历它们来获取对象。

那么,为什么不添加一个方便的get(x)->x

这没有道理,因为你已经有了x,纯粹主义者会说。

但是现在把它看作非纯粹主义者,看看你是否真的想要这样:

假设我使对象y,wich与x的等号相匹配,这样就设置了。得到(y)->x。volia,然后我可以访问我以前拥有的x的数据。例如,x有一个名为get flag()的方法,我想得到它的结果。

现在看看这个代码。

Y

x=map.get(y);

所以y等于(x)真!

但是…

y.flag()==x.flag()=false。(他们不是平等的吗?)

所以,你看,如果设置允许你得到这样的对象,它肯定是打破平等的基本语义。稍后,你将与X的小克隆生活在一起,所有的克隆都宣称它们是相同的,当它们不是的时候。

你需要一张地图,来储存东西,然后用钥匙来检索。

我知道在一个集合中只允许一个符合.equals()的对象实例,并且如果已经有一个等价的对象,则不应该“需要”从集合中获取对象,但我仍然希望有一个.get()方法,该方法返回给定一个等价对象作为参数的集合中对象的实际实例(或空值)。呃。

简单的接口/API在实现过程中提供了更多的自由。例如,如果 Set 接口将简化为单个 contains() 方法我们得到一个函数编程的典型集合定义——它只是一个谓词,实际上没有存储任何对象。对于java.util.enumset也是这样-它只包含每个可能值的位图。

这只是一个意见。我相信我们需要理解,我们有几个Java类,没有字段/属性,即只有方法。在这种情况下,不能通过比较函数来度量equals,这样的一个例子是requesthandlers。请参阅下面的JAX-RS应用程序示例。在这个上下文中,集合比任何数据结构都更有意义。

@ApplicationPath("/")
public class GlobalEventCollectorApplication extends Application {
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new HashSet<Class<?>>();
        classes.add(EventReceiverService.class);
        classes.add(VirtualNetworkEventSerializer.class);
        return classes;
    }
}

要回答您的问题,如果您有一个浅层的Employee对象(即只有Empid,它在Equals方法中用于确定唯一性),并且如果您希望通过在集合中执行查找来获得深层对象,则集合不是数据结构,因为它的用途不同。

列表是有序的数据结构 . 所以它遵循插入顺序。因此,您输入的数据将在插入时的准确位置可用。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);

list.get(0); // will return value 1

记住这是一个简单的数组。

集合是无序的数据结构 . 所以它没有顺序。您在特定位置插入的数据将在任何位置都可用。

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
//assume it has get method
set.get(0); // what are you expecting this to return. 1?.. 

但它会返回其他东西。因此,在集合中创建get方法没有任何意义。

**注意****对于我使用int类型的解释,这同样适用于对象类型。

我想你已经回答了自己的问题:这是多余的。

set提供set contains(object o),它提供所需set get(object o)的等效身份测试,并返回一个布尔值,如预期的那样。