You can't use a method reference, since you have no way of passing the int argument to it.

Therefore, use a lambda expression instead:

lines.forEach(s -> chunker.splitFileByMaxRows(s,someInt));

you could just use a forEach:

listModel.forEach(model -> {
    try {
        new UpDateData().bankData(model.getCust_id(), model.getBank_id(), model.getDate());
    } catch(){
         .... handle
    }
})

Because Consumer is a functional interface, your lambda function can implicitly satisfy it. So when you do

list.forEach(i -> System.out.println(i));

what you're doing conceptually (more below) is

list.forEach(new Consumer<String>() {
    @Override
    public void accept(String i) {
        System.out.println(i);
    }
});

The instance is then passed into forEach, which calls its accept method for each entry in the list.

From a comment you made on the question:

I am confused which method is invoked first. Is it the "forEach()" or the "accept ()" because both of them are working togather!

The order of things is:

• An instance of the anonymous class is created (in effect, via the invokedynamic operation)
• forEach is called, passing in that reference
• forEach's code calls accept repeatedly, each time passing one of the list items into it (which it receives as i)

Note I said conceptually. An anonymous class isn't really created by the compiler; instead, a new bytecode operation called invokedynamic is used to create the consumer instance.

WARNING
As mentioned in comments, Using peek() for production code is considered bad practice
The reasson is that "According to its JavaDocs, the intermediate Stream operation java.util.Stream.peek() “exists mainly to support debugging” purposes."
As a consequence, this proposed solution SHOULD NOT be used.

Forgot to relate to the first code snippet. I wouldn't use forEach at all. Since you are collecting the elements of the Stream into a List, it would make more sense to end the Stream processing with collect. Then you would need peek in order to set the ID.

List<Entry> updatedEntries = 
    entryList.stream()
             .peek(e -> e.setTempId(tempId))
             .collect (Collectors.toList());

For the second snippet, forEach can execute multiple expressions, just like any lambda expression can :

entryList.forEach(entry -> {
  if(entry.getA() == null){
    printA();
  }
  if(entry.getB() == null){
    printB();
  }
  if(entry.getC() == null){
    printC();
  }
});

However (looking at your commented attempt), you can't use filter in this scenario, since you will only process some of the entries (for example, the entries for which entry.getA() == null) if you do.

Move your try/catch inside the loop?

    items.forEach(item -> {
        try {
            getData(item);
        } catch (Exception e) {
            e.printStackTrace();
        }
    });

There are three kinds of method references that can be used when a single value is available from the stream:

1. A parameter-less method of the streamed object.

   class Observer {
       public void act() {
           // code here
       }
   }
   
   observers.forEach(Observer::act);
   
   observers.forEach(obs -> obs.act()); // equivalent lambda
   

   The streamed object becomes the this object of the method.

2. A static method with the streamed object as parameter.

   class Other {
       public static void act(Observer o) {
           // code here
       }
   }
   
   observers.forEach(Other::act);
   
   observers.forEach(obs -> Other.act(obs)); // equivalent lambda
   

3. A non-static method with the streamed object as parameter.

   class Other {
       void act(Observer o);
   }
   
   Other other = new Other();
   observers.forEach(other::act);
   
   observers.forEach(obs -> other.act(obs)); // equivalent lambda
   

There is also a constructor reference, but that is not really relevant to this question.

Since you have an external value temp, and you want to use a method reference, you can do the third option:

class Temp {
    private final BigDecimal temp;
    public Temp(BigDecimal temp) {
        this.temp = temp;
    }
    public void apply(TemperatureObserver observer) {
        observer.react(this.temp);
    }
}

Temp tempObj = new Temp(temp);

observers.forEach(tempObj::apply);

java.util.Properties extends Hashtable<Object,Object>.

Therefore you'll have to cast the key and value to String in order to call your method (assuming all the keys and values are actually Strings) :

properties.forEach( (key, value) -> this.addOption((String) key, (String) value));

The alternative is to change the signature of your method to :

public void addOption(Object key, Object value)

To iterate on a section of the original list, use the subList method:

list.subList(1, list.length()-1)
    .stream() // This line is optional since List already has a foreach method taking a Consumer as parameter
    .forEach(...);