Methods, variables, and constructors that are declared private can only be accessed within the declared class itself.Private access modifier is the most restrictive access level. Class and interfaces cannot be private.Variables that are declared private can be accessed outside the class, if public getter methods are present in the class.Using the private modifier is the main way that an object encapsulates itself and hides data from the outside world.ExampleThe following class uses private access control - public class Logger {    private String format;    public String getFormat() {       return this.format;    }    public void setFormat(String ... Read More

Following program creates an array with null values. Convert it a list with not-null values only and then get the array of that list.Exampleimport java.util.ArrayList; import java.util.List; public class Tester { public static void main(String[] args) { String[] array = {"I", null, "love", null, "Java" }; List values = new ArrayList(); for(String data: array) { if(data != null) { values.add(data); } } String[] target = values.toArray(new String[values.size()]); for(String data: target) { System.out.println(data + " "); } } }OutputI love Java

Yes, an array can be returned from a java function. See the example below − Example public class Tester { public static void main(String[] args) { int[] array = getData(); for(int i: array) { System.out.println(i); } } public static int[] getData() { int[] dataArray = {1, 2, 3, 4}; return dataArray; } } Output 1 2 3 4

Following program print the sum of the all the numbers in an array.Examplepublic class Tester {    public static void main(String[] args) {       int[] dataArray = {1, 2, 3, 4};       int sum = 0;       for(int i: dataArray) {          sum += i;       }       System.out.println(sum);    } }Output10

The array is faster in case of access to an element while List is faster in case of adding/deleting an element from the collection.

LinkedList should be used where modifications to a collection are frequent like addition/deletion operations. LinkedList is much faster as compare to ArrayList in such cases. In case of read-only collections or collections which are rarely modified, ArrayList is suitable.

Following example will showcase conversion of a Unicode String to UTF8 byte[] and UTF8 byte[] to Unicode byte[] using Reader and Writer classes.ExampleIOTester.javaimport java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.Reader; import java.io.Writer; import java.nio.charset.Charset; import java.text.ParseException; public class I18NTester {    public static void main(String[] args) throws ParseException, IOException {    String input = "This is a sample text" ;    InputStream inputStream = new ByteArrayInputStream(input.getBytes());    //get the UTF-8 data Reader    reader = new InputStreamReader(inputStream, Charset.forName("UTF-8"));        //convert UTF-8 to Unicode    int data = reader.read();    while(data != ... Read More

Following program reverses an int array.Examplepublic class Tester {    public static void main(String[] args) {       int[] numbers = {1,2,3,4,5};       //swap the numbers till the midpoint comes       for (int start = 0, end = numbers.length - 1;       start

To make things simple, convert the array to list and then print it.Exampleimport java.util.Arrays; import java.util.List; public class Tester {    public static void main(String[] args) {       Integer[] numbers = {1,2,3,4,5};       List list = Arrays.asList(numbers);       System.out.println(list);    } }Output[1,2,3,4,5]

Use Arrays.copyOfRange() method to get a subarray.Exampleimport java.util.Arrays; public class Tester {    public static void main(String[] args) {       int[] array = new int[] {1, 2, 3, 4, 5};       int[] subArray = Arrays.copyOfRange(array, 0, 2);       System.out.println("Array: ");       for(int i = 0; i < array.length; i++) {          System.out.print(array[i] + " ");       }       System.out.println("Sub array: ");       for(int i = 0; i < subArray.length; i++) {          System.out.print(subArray[i] + " ");       }    } }OutputArray: 1 2 3 4 5 Sub array: 1 2