So I have a problem that has been holding me up for quite some time, I think my brain is just fried and it may just need a different perspective. I figured gamers often tend to be programmers, plus I don't have any other active forum accounts, so...

I'm trying to create a class that deals extensively with a large collection of objects of type T, ie T is a generic type. So the class might look like:

class Processor < T > {
Processor(List< T > vals) {
DoStuffWith(vals);
}
}

This Processor class frequently needs to pass an object from the generic collection to various worker classes that are built to expect objects of that type (these classes are provided in the constructor, so are also generic, and are activated through an abstract parameter passing method).

so now the class might look like

class Processor < T > {
Processor(List< T > vals, Worker< T >[] workers) {
DoStuffWith(vals, workers);
}
}

These worker classes often need to check if other objects exist in the set (ie if vals contains). One example might be if the processor class is dealing with 2D points. If the worker class is passed x:4 y:5, it may want to check if x:4 y:6 exists. However the only way I understand to do this, is to create an x=4 y=6 instance and check if it exists in the set, by ensuring the generic object's .equals and .hashcode methods would return true on such a case and such a case only. (working in Java ftr, but compiling to JavaScript with GWT, though I think this is more a general Object Oriented question)

This seems dodgy to me, as I'm instancing a class only to compare (and this could happen many many many times). I could create an abstract key object that the generic class must provide to at least reduce the bloat of instancing a compare key, but this still seems wrong.

What I'd prefer is to compare on a primitive so that no new class needs to be initialised when checking if one exists in the set. (so all elements in val might now exist in a hashmap of primitive->instance, where primitive might be an Integer hash)

Or, alternatively, to know if there is some better & faster way of checking if a multi-featured object exists in a set of objects that are abstract.

If I was only working with one Val class type, I could just use a static Integer key() method, that takes the few parameters that are necessary (eg x & y). But since I'm using abstracts, I can't declare such a key generator method. (ie no abstract static methods)

Does this even make sense to any body else? And is any body else pro enough to know what solutions might exist? I tried reaching the ideal blood-alcohol concentration level to achieve programming godhood, but it just induced outsourcing my question to the internets.

That might be a best solution. A new object would iterate over a list checking .equals(), I'm not sure if it has some indexing tricks to speed it up based on the hashcode. Iterating over the list to find every instance seems really undesirable, the list and number of checks could be huge.

edit: I'm actually thinking in terms of solutions involving muilti-dimensional arrays that are instanced based on some 'important properties' feature of the class used in the generic/abstract slot. Wouldn't account for gaps in the set, but could be nulled by default so it just checks if one exists at those indexes. (assuming all features are essentially ints)

I'm slightly drunk now.

I was thinking something along those lines, but my head isn't clear enough to see how to do it. (there's a million other more complex things at play in the actual scenario, but I've tried to boil it down to the one thing making it difficult for me to proceed at this point)

edit: Oh wait I see what you mean now, that could be right. Will consider that my best option, big ty.

Essentially I want to do a lot of it (dozens of times per worker, and hundreds of workers per problem), and I would prefer for it to be able to be as fast as possible (especially if the implementation means magnitudes of difference in execution speed). It's one of the most fundamental pieces of my project, and if it's slow the quality of the whole project will suffer. I would prefer for it to be as fast as possible regardless of size, but collection sizes are expected to be in the tens of thousands.

But yes I'm starting to realise I had been basing my approach around the Java ArrayList and HashMap .contains() restrictions. I should consider creating my own space for the problem, perhaps the contains() check could be abstract, and implemented as per best for the properties of the generic object type. (which might for example involve going with hast's selection in a provided set-control object)

Yep I know it's early to be considering when I don't even know how fast it will run, but truth be told I can't see any one complete way to do it, so am trying to decide on an approach and ensure I do it "correctly" the first time. It's a very big subsystem (with many more problems I haven't mentioned) and every single piece is inter-related and abstractable (it's a system that will be used for many different purposes), so sorting out how I'm going to stick the pieces together so that enums etc can be switched and types genericesed while still being fast is proving to be a real pain.

That is essentially what I was trying to do, the problem was in that I couldn't create a new hashkey without instancing a new object, as the objects are all abstract and there can't be an abstract static hash function on the important parameters.

The number of objects won't change in usage.

Now I've realised I can still have a static HashValue(params) function in my data classes, it just won't be in the abstract definition. The workers that expect that class can still use it. The question is now how does the set ensure the collection is mapped on the same hashkey. I can tell it to use the HashKey() property, but there's no guarantee that will pass through the undefined static calculator or get the same result.

Think I'm just going to make a set object, and require the implementation to handle the actual storing and looking up requests.