Java function returning list

How to return an Array in Java [Practical Examples]

In Java, an array is a container object that can hold a fixed number of values of same type. The length of array is declared at time of creation of an array. Java allows arrays to be passed as a parameter to the other functions and return data from that function. In fact, if we need to return multiple value of same type then returning through an array is the best alternative. Moreover, java always passes an array by reference, so any modification done by the other function would always modify the original array.

There are three different ways to return an array from a function in Java as listed below.

• Return an array of primitive type
• Return an array of objects
• Return a multidimensional array

Method-1: Return an array of primitive type

We can use this approach, if we want to return multiple values of same type from a function. As we know that java does not support return statement with multiple values. So, we can use this concept to return multiple value of any primitive type like int, char, float, double, long etc. from a function.

Example : In this example, we are having a readIntArray() function that returns an integer array. Moreover, we have also used add100() function that adds 100 to each element of an array. As, Java passes array by reference all the modifications done are visible even without returning an array from add100 function.

// Program to demonstrate return an array of primitive type public class ArrayDemo < public static void main(String[] args) < // Creating object of class ArrayDemo m = new ArrayDemo(); // Declaring array and calling function to read array int a[] = m.readIntArray(); // Printing the content of an array System.out.println("Array returned by readIntArray function"); for (int i = 0; i < a.length; i++) < System.out.println(a[i]); >// Calling a function to add 100 to each element in an array m.add100(a); // Printing the content of an array System.out.println("Array after add100 function"); for (int i = 0; i < a.length; i++) < System.out.println(a[i]); >> // function that adds 100 to each element - array passed by reference void add100(int x[]) < for (int i = 0; i < x.length; i++) < x[i] = x[i] + 100; >> // Function that returns an array int[] readIntArray() < int a[] = < 1, 2, 3, 4 >; return a; > >

Array returned by readIntArray function 1 2 3 4 Array after add100 function 101 102 103 104 

Method-2: Return an array of objects

We can use this approach when we need to return multiple objects from the class. It works in the same way as a primitive type array. In other words, we can wrap a multiple type of value inside a class object and return multiple objects from the class.

Example : In this example, we are returning an array of student objects using getStudents() method. Thereafter, it calls the constructor to initialize the name and marks. We are then printing the student marks in a main class.

// Program to return an array of objects import java.io.*; class Student < // Declaring class variables String name; int marks; // Constructor to instantiate class objects. public Student(String n, int m) < // this keyword refers to current instance itself this.name = n; this.marks = m; >> class Main < public static void main(String[] args) < // Calling the method for returning an array of objects of the Student class. Student[] s = getStudents(); // Printing for (int i = 0; i < s.length; i++) System.out.print(s[i].name + " - " + s[i].marks + " marks\n"); >// Function returning an array of objects public static Student[] getStudents() < // Declaring Array of objects of the Student class Student[] a = new Student[4]; // Custom array of objects a[0] = new Student("Ram", 91); a[1] = new Student("John", 66); a[2] = new Student("Dora", 29); a[3] = new Student("Sim", 58); // Returning an array of objects return a; >>

Ram - 91 marks John - 66 marks Dora - 29 marks Sim - 58 marks

Method-3: Return a Multidimensional array

In this approach, we return a multidimensional array from a function. However, it works on the same way as a single dimensional array. The only difference is we have to give multiple [] brackets to indicate the return type.

Example : In this example, we are adding two dimensional arrays and returning from a function.

// Program to return a multidimensional array import java.io.*; class Main < public static void main(String[] args) < // Creating object of a class. Main m = new Main(); // Initializing an array int a[][] = < < 1, 1, 1 >, < 1, 1, 1 >, < 1, 1, 1 >>; // Calling a method to add two arrays int c[][] = m.add(a); // Computing no. of rows and columns in array returned from the function int r = c.length, col = c[0].length; // Printing the result System.out.println("Addition of two array is "); for (int i = 0; i < r; i++) < for (int j = 0; j < col; j++) < System.out.print(c[i][j] + " "); >System.out.println(); > > // Function that adds two array and return a result as an array int[][] add(int x[][]) < int y[][] = < < 1, 1, 1 >, < 1, 1, 1 >, < 1, 1, 1 >>; int r = x.length; int c = x[0].length; int z[][] = new int[r][c]; for (int i = 0; i < r; i++) < for (int j = 0; j < c; j++) < z[i][j] = x[i][j] + y[i][j]; >> return z; > >

 Addition of two array is 2 2 2 2 2 2 2 2 2 

Examples to Return an array from a function

Example 1 : Find repeated words in a string using for loop and while loop

In this example, we have a string containing some repeated words. Here, we are finding the list of words repeated in the given String. For this task, we have to convert String into an array of words which is done using user defined function intowords() that returns an array.

public class Main < public static void main(String[] args) < // Declaring and initializing the variables String s = "Life is like a book. Life is like a cup of tea. Life is like a rose garden. Life is like a dream"; int count; // Object creation Main m = new Main(); //Converts the string into lowercase s = s.toLowerCase(); // Calling a function to convert string to words array String w[] = m.intowords(s); // Finding repeated words in the string System.out.println("Finding repeated words in a string : "); int i = 0; while (i < w.length) < count = 1; for (int j = i + 1; j < w.length; j++) < if (w[i].equals(w[j])) < count++; // Setting w[j] to 0 again to avoid printing visited word w[j] = "0"; >> //Displays the repeated word if count is greater than 1 if (count > 1 && w[i] != "0") System.out.println(w[i]); i++; > > // Splitting the string to words for comparision String[] intowords(String x) < String w[] = x.split(" "); return w; >>

Finding repeated words in a string : life is like a 

Example 2 : Return a float array from a function

In this example, we are having a function getvalue() consisting of three float variables that is required to be returned to main. So, we create an float array to return the same.

// Program to return an array from a function class Main < public static float[] getvalue() < float a1 = 10.5f; float a2 = 20.5f; float a3 = 30.5f; return new float[] < a1, a2, a3 >; //returns array > public static void main(String args[]) < float[] a = getvalue(); for (int i = 0; i < a.length; i++) < System.out.println(a[i]); >> >

Summary

The knowledge of Returning an array from a function in Java is very useful while working on a real time applications. It’s important to note that in java arrays are passed as a reference so any modifications done outside the function is visible to the original array. In this tutorial, we covered three different approaches to return an array in Java. As per the requirement of an application, we can choose an appropriate approach. We learned in detail about this approaches with an example. All in all, this tutorial, covers everything that you need to know in order to have a clear view on returning an array in Java.

References

Didn’t find what you were looking for? Perform a quick search across GoLinuxCloud

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

For any other feedbacks or questions you can either use the comments section or contact me form.

Thank You for your support!!

Leave a Comment Cancel reply

Java Tutorial

• Set Up Java Environment
  • Set Up Java on Linux
  • Set up Java with BlueJ IDE
  • Set up Java with VSC IDE
  • Set up Java with Eclipse IDE
  • Java Multiline Comments
  • Java Variables
  • Java Global Variables
  • Java Date & Time Format
  • Different Java Data Types
  • Java Booleans
  • Java Strings
  • Java Array
  • Java Byte
  • Java convert list to map
  • Java convert double to string
  • Java convert String to Date
  • Java convert Set to List
  • Java convert char to int
  • Java convert long to string
  • Java Operators Introduction
  • Java Boolean Operators
  • Java Relational Operators
  • Java Arithmetic Operators
  • Java Bitwise Operators
  • Java Unary Operators
  • Java Logical Operators
  • Java XOR (^) Operator
  • Java Switch Statement
  • Java If Else Statement
  • Java While Loop
  • Java For / For Each Loop
  • Java Break Continue
  • Java Nested Loops
  • Java throw exception
  • Java Try Catch
  • Java Accessor and Mutator Methods
  • Java main() Method
  • IndexOf() Java Method
  • Java ListIterator() Method
  • Java create & write to file
  • Java read file
  • Java Parameter
  • Java Argument
  • Java Optional Parameters
  • Java Arguments vs Parameters
  • Java Arrays.asList
  • Java HashSet
  • Java Math
  • Java HashMap vs Hashtable vs HashSet
  • Java LinkedList
  • Linked List Cycle
  • Java List vs LinkedList
  • Java ArrayList vs LinkedList

  Источник

  Java best practice: Return a List, not a LinkedList

  As I started to mention in another blog post, your Java code will be more flexible when you learn to return more-general object references. In most cases other developers only need to see your interface, not your implementation. Put another way, does it matter to anyone else if you used a LinkedList or an ArrayList? If it doesn’t matter, then return a List, or perhaps even a Collection.

  As a specific example, a Java method that returns a LinkedList or ArrayList will be more flexible if it returns a more-general reference, such as a List , or better yet, a Collection . Here’s an example of a method that returns a LinkedList :

  // before: method returns a LinkedList reference private LinkedList getList()

  That code is too-specific. At least 99% of the time other developers don’t need to know that you’re really creating a LinkedList . You’re much better off returning just a plain old List , or better yet, a Collection , like this:

  // after: method returns a Collection reference private Collection getList()

  The reference you return should really depend on the functionality you want to support. Because a LinkedList implements a List, and a List has a Collection as an interface, you really need to know what methods those interfaces support to make this decision. But it’s worth taking a moment to learn them, and to then keep your code more general (again, interface versus implementation details).

  Источник