A method declared as

void X(Object... values){};

is similar to a method declared as

void X(Object[] values){};

and can be called with an Object[], though only the first can be called with a variable number of arguments. You can convert your list to an array of using List.toArray(), so that you can call X(list.toArray()). Here's example code demonstrating:

import java.util.Arrays;

public class VarargsExample {

    public static void foo( Object... args ) { 
        System.out.println( "foo: "+Arrays.toString( args ));
    }

    public static void bar( Object[] args ) {
        System.out.println( "bar: "+Arrays.toString( args ));
    }

    public static void main(String[] args) {
        // only foo can be called with variable arity arguments
        foo( 1, 2, 3 );
        // bar( 4, 5, 6 ); // won't compile 

        // both methods can be called with object arrays
        foo( new Object[] { 7, 8, 9 } );
        bar( new Object[] { 10, 11, 12 } );

        // so both can be called with List#toArray results
        foo( Arrays.asList( 13, 14, 15 ).toArray() );
        bar( Arrays.asList( 16, 17, 18 ).toArray() );
    }
}

foo: [1, 2, 3]
foo: [7, 8, 9]
bar: [10, 11, 12]
foo: [13, 14, 15]
bar: [16, 17, 18]

String... equals a String[] So just convert your list to a String[] and you should be fine.

You'll have to convert the List<String> to a String array in order to use it in the 'varargs' parameter of dummyMethod. You can use toArray with an extra array as parameter. Otherwise, the method returns an Object[] and it won't compile:

List<String> names = getNames();
dummyMethod(names.toArray(new String[names.size()]));

Use the String-Array to pass the parameters in. The main-Method has only the args parameter.

Java Doc: Main Method

You can pass all owners into the array, then put a limiter String into it (which can't be an owner or consumer) and then put all consumers into the array. In the main you iterate over the args-array and create two arrays of it.

What you are trying to do is add wrong elements in a list.

The list you students is a list of Student. So as pointed out earlier, students.add() would only accept objects of type Student.

You will have to do something like:

System.out.println("- Add Student Info -");
String name = ""; //Get name from user
Date dob = new Date(); //Get DOB from user
String[] friends = new String[]{"Friend1", "Friend2"}; //Get a list of friends from user
String school = ""; //Get school from user

students.add(new Student(name, dob, friends, school));
//OR students.add(0, new Student(name, dob, friends, school)); //Replace 0 with any index

The solution depends on the answer to the question - are all the parameters going to be the same type and if so will each be treated the same?

If the parameters are not the same type or more importantly are not going to be treated the same then you should use method overloading:

public class MyClass
{
  public void doSomething(int i) 
  {
    ...
  }

  public void doSomething(int i, String s) 
  {
    ...
  }

  public void doSomething(int i, String s, boolean b) 
  {
    ...
  }
}

If however each parameter is the same type and will be treated in the same way then you can use the variable args feature in Java:

public MyClass 
{
  public void doSomething(int... integers)
  {
    for (int i : integers) 
    {
      ...
    }
  }
}

Obviously when using variable args you can access each arg by its index but I would advise against this as in most cases it hints at a problem in your design. Likewise, if you find yourself doing type checks as you iterate over the arguments then your design needs a review.

To parse the list of arguments you are just missing a parameter when constructing your ArgumentParser, from your code:

// note that "main" should be your class name not your main method IIRC
ArgumentParser parser = ArgumentParsers.newFor("main").build();

parser.addArgument("-l", "--list")
      .nargs("*") // Here is the trick, this will accept 0 or N arguments
      .help("Argument list to parse");

And same as in your Python answer link nargs will also accept + which means it requires at least one argument.

To parse/get the list of arguments you would need:

//I'm assuming you have a main method with args parameter here
Namespace ns = parser.parseArgs(args);
List<String> list = ns.getList("list");

System.out.println("Parsed list: " + list);

For this call java main --list arg1 arg2 arg3 it will output:

Parsed list: [arg1, arg2, arg3]

Change the method definition to something as follows

public static void function(int number, List<String> listname) {
  for (int i = 0; i < listname.size(); ++i) {
    System.out.print(listname.get(i) + ": ");
  }
  System.out.println(number);
}

What you need is a Tuple class:

public class Tuple<E, F, G> {
    public E First;
    public F Second;
    public G Third;    
}

Then you can iterate over the list of the tuple, and look at each entry in the tuple.

List<Tuple<Integer, String, String> listOfTuple;
for (Tuple<Integer, String, String> tpl: listOfTuple){
    // process each tuple
    tpl.First ... etc
}

You can convert your List<String> to a String[] with the toArray(IntFunction<T[]> generator) method that was added in Java 11:

String[] strings = list.toArray(String[]::new);

Or to pass it directly:

CsvSchema schema = csvMapper.typedSchemaFor(PersonDetailsCSVTemplate.class)
    .withHeader()
    .sortedBy(list.toArray(String[]::new))
    .withColumnSeparator(',')
    .withComments();

On Java 8, use the overload of toArray that takes an array:

CsvSchema schema = csvMapper.typedSchemaFor(PersonDetailsCSVTemplate.class)
    .withHeader()
    .sortedBy(list.toArray(new String[list.size()]))
    .withColumnSeparator(',')
    .withComments();

Or:

CsvSchema schema = csvMapper.typedSchemaFor(PersonDetailsCSVTemplate.class)
    .withHeader()
    .sortedBy(list.toArray(new String[0]))
    .withColumnSeparator(',')
    .withComments();

If the array is too small, it will create one of the necessary size, based on the element type of the array you pass in. That is why passing in a zero-length array will work.

You can declare

public void method2(Double... doubles) {
}

See the Java varargs documentation for details.

Q: How can i pass the items from a list as individual arguments to a function?

A:

List<Integer> exampleList = new ArrayList<Integer>();

// Use this for a few specific items in the list
public void Example1(Integer arg1, Integer arg2, Integer argc);
...
Example1 (exampleList.get(0), exampleList.get(1), exampleList.get(2));

// Use this to pass many items (just pass the whole list)
public void Example2(List<Integer> args);
...
Example2 (exampleList);