Function with variable parameter type

Question

I have these two functions which are basically the same:

private Order getOrder( List<Order> orders, String gcsId )
{
    Predicate<Order> predicate = c -> c.getGcsId().equals( gcsId );
    Order obj = orders.stream().filter( predicate ).findFirst().get();
    return obj;
}

private OrderLine getOrderLine( List<OrderLine> orderLines, String gcsId )
{
    Predicate<OrderLine> predicate = c -> c.getGcsId().equals( gcsId );
    OrderLine obj = orderLines.stream().filter( predicate ).findFirst().get();
    return obj;
}

The only difference is the type of the first parameter. How can I create a single function with the first parameter having a variable type?

Edit: This is how I call those functions in another method of the same class:

Order order = getOrder( orders, orderId );
OrderLine orderLine = getOrderLine( order.getOrderLines(), orderLineId );

Can you create an interface that both classes implent, then use the interface as the parameter type? — Erich Kitzmueller
– Erich Kitzmueller, Commented Jun 8, 2017 at 6:36
Do OrderLine and Order share any common super class or interface? — luk2302
– luk2302, Commented Jun 8, 2017 at 6:37
Well, from the name is it necessary ? they seems to share the same variable, so is there any relation between those ? (I believe they should) — AxelH
– AxelH, Commented Jun 8, 2017 at 6:38
@AxelH an order (got from the first function) includes a list of orderLines — neptune
– neptune, Commented Jun 8, 2017 at 6:39

Endery · Accepted Answer · 2017-06-08 06:41:45Z

3

First you should create an interface like that and your classes should implement this interface:

public interface IOrder {

   String getGcsId();
}

public class Order implements IOrder {
  // Content of your class
}

public class OrderLine implements IOrder {
  // Content of your class
}

After that you can write your method like that using generics:

private <T extends IOrder> T getOrder( List<T> orders, String gcsId )
{
    Predicate<T> predicate = c -> c.getGcsId().equals( gcsId );
    T obj = orders.stream().filter( predicate ).findFirst().get();
    return obj;
}

answered Jun 8, 2017 at 6:41

Endery

1,16817 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

JB Nizet · Accepted Answer · 2017-06-08 06:44:13Z

Either make them implement a common interface, which defined the getGcsId() method, and use

private <T extends CommonInterface> T getFirstWithGcsId(List<T> orders, String gcsId) {
    Predicate<T> predicate = c -> c.getGcsId().equals(gcsId);
    T obj = orders.stream().filter(predicate).findFirst().get();
    return obj;
}

Or change the signature of the method to pass it a function which knows how to extract the gcsId:

private <T> T getFirstWithGcsId(List<T> orders, String gcsId, Function<T, String> gcsIdExtractor) {
    Predicate<T> predicate = c -> gcsIdExtractor.apply(c).equals(gcsId);
    T obj = orders.stream().filter(predicate).findFirst().get();
    return obj;
}

But this method is so simple that, frankly, if you don't have any common interface, I would just inline it. It's basically one line of code:

Order firstOrder = orders.stream().filter(o -> o.getGcsId().equals(gcsId)).findFirst().get();

You should also avoid calling get() on an Optional in general. Rather prefer something like

Order firstOrder = orders.stream().filter(o -> o.getGcsId().equals(gcsId)).findFirst().orElseThrow(() -> new IllegalStateException("no first order with gcsId " + gcsId));

ΦXocę 웃 Пepeúpa ツ · Accepted Answer · 2017-06-08 06:43:26Z

1

If you give a List of Order you return an Ornder, if you give an define a generic method instead:

private <T extends Foo> T getOrder(List<T > orders, String gcsId) {
    Predicate<T> predicate = c -> c.getGcsId().equals(gcsId);
    T obj = orders.stream().filter(predicate).findFirst().get();
    return obj;
}

where Foo interface is

interface Foo {
    String getGcsId();
}

class OrderLine implements Foo {

    @Override
    public String getGcsId() {
        return something;
    }

}

class Order implements Foo {

    @Override
    public String getGcsId() {
        return something;
    }

}

edited Jun 8, 2017 at 6:43

answered Jun 8, 2017 at 6:35

ΦXocę 웃 Пepeúpa ツ

48.4k17 gold badges77 silver badges102 bronze badges

Comments

Rosário P. Fernandes · Accepted Answer · 2017-06-08 09:10:51Z

You should create an Interface. See below:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class SomeFunctionsRefactored {

    public static void main(String[] args) {
        Order simpleOrder = new SimpleOrder();
        Order lineOrder = new LineOrder();
        String gcsId;
        List<Order> simpleOrders = new ArrayList(Arrays.asList(simpleOrder));
        List<Order> lineOrders = new ArrayList(Arrays.asList(lineOrder));

        Order order = getOrder(simpleOrders, "Hi I'm a simple order");
        System.out.println(order.getGcsId());  // Hi I'm a simple order

        order = getOrder(lineOrders, "Hi I'm a line order");
        System.out.println(order.getGcsId());  // Hi I'm a line order

    }

    private static Order getOrder(List<Order> orders, String gcsId) {
        Predicate<Order> predicate = c -> c.getGcsId().equals(gcsId);
        return orders.stream().filter(predicate).findFirst().get();
    }

The interface:

interface Order {
    public String getGcsId();
}

class SimpleOrder implements Order {
    String gcsId = "Hi I'm a simple order";

    public String getGcsId() {
        return gcsId;
    }

}

class LineOrder implements Order {
    String gcsId = "Hi I'm a line order";

    public String getGcsId() {
        return gcsId;
    }
}

gajju_15 · Accepted Answer · 2017-06-08 07:41:02Z

0

One way that you can perform instance of test after taking list as a parameter, but your List is parameterized. if you have anything that is parameterized,

List<Foo> fooList = new ArrayList<Foo>();

The Generics information will be erased at runtime. Instead, this is what the JVM will see

   `List fooList = new ArrayList();`

This is called type erasure. The JVM has no parameterized type information of the List (in the example) during runtime.

Since the JVM has no information of the Parameterized type on runtime,

there's no way you can do an instanceof of ArrayList.

So better you keep your both function to work.

answered Jun 8, 2017 at 7:41

gajju_15

5274 silver badges17 bronze badges

Collectives™ on Stack Overflow

Function with variable parameter type

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related