如何在 java 中创建分层数据对象

Question

I have received below data set from the third party database.

AccNo  AccName  CurrentRef  PrevRef  TimeStamp
001    FCA      001         0        T00
001    FCB      002         001      T01
021    FCA      003         002      T02
011    XZA      012         0        T00
011    XZC      013         012      T01
022    YAA      021         0        T00

To identify one account we need to track all the previous reference of an account. If its previous reference is 0 then it means it is the first entry of the account in data set. From the above data set,

First three rows belongs to one account. (CurrentRef - 003, its previous references - 002,001)

Fourth and fifth rows belong to another account. (CurrentRef - 013, PrevRef - 012)

And so on.

I need a collection which can group this data on the basis of PreviousRef so that below information can be received in a single object,

(AccountNo-latest, Complete VO (AccNo, AccName, CurrentRef, PrevRef, TimeStamp)-latest, List of Previous References)

For above data set, T02 is latest timestamp, T00 is the oldest timestamp. A record is latest if it's CurrentRef doesn't belong to PrevRef of any record. I need below result in a list-

[021, (021, FCB, 003, 002, T02), (002,001)],
[011, (011, XZC, 013, 012, T01), (012)],
[022, (022, YAA, 021, 0, T00), ()]


  

Answer 1

In a comment you said there is no unique identifier for these records. That is a problem.

Not only could we be dealing with duplicate elements, but there is a larger issue.

You run the possibility of infinite recursion, ie Record A's previous record is Record B and record B's previous record is Record A. Not to mention other cycles of arbitrary repetition, going forwards and backwards.

Instead of solving the problem as it is now, consider modifying your structure so there is a unique identifier.

If there is a unique identifier, we could easily solve this by converting each record to a Linked List Node, overriding the Object.hashcode() with this unique identifier, and inserting it into a HashMap which is an O(1) operation. If the previous ref is 0, we can stop here. If not, we also want to visit the HashMap node at that previous ref and set its next to the current node. This way we have a breadcrumb trail of nodes. This is also another constant time O(1) operation.

Therefore, it follows for all records to be put into a HashMap, we spend O(n) time building the breadcrumb HashMap.

After, we can do another O(n) traversal to collect the desired list.

Something like:

List result = hashmap.filter(node -> node.previous == null).collect(Collectors.toList())

To receive a list of the origin nodes (which have links to their next refs since we built up the breadcrumb).

This is likely the cleanest and fastested possible solution in 2*O(n)=O(n) time.