ArrayList is a mutable container class, though, so you don't actually need a setter at all: simply have callers call getStringList() and then mutate the ArrayList themselves:

public final class DataHolder {
  private final ArrayList<String> stringList = new ArrayList<>();

  public ArrayList<String> getStringList() {
    return stringList;
  }
}

public static void main(String[] args) {
  DataHolder data = new DataHolder();
  data.getStringList().add("foo");
}

On the other hand, the more common requirement is to prevent callers from being able to mutate internal data structures, so that your class can actually enforce its invariants on its data. ArrayList is always mutable, so if you need to return an ArrayList but you don't want your private state to be modified, you'll need to copy:

public ArrayList<String> getStringList() {
  return new ArrayList<String>(stringList);
}

Alternatively, if possible, it's better to widen the return type and then return some other implementation that your class can use to enforce its invariants. For example, if you don't want people to modify your ArrayList using a getter method, you could widen the type from ArrayList<String> to List<String> and use an unmodifiable implementation, for example:

public List<String> getStringList() {
  return Collections.unmodifiableList(stringList);
}

On the other hand, for the setter, it depends on how you want to handle the values. Normally a setFoo method replaces the contents of foo, which you can of course do:

public void setStringList(ArrayList<String> stringList) {
  this.stringList = stringList;
}

But most likely you want to also widen the type you will accept. For example, you could accept any Collection instead of just an ArrayList:

public void setStringList(Collection<String> strings) {
  this.stringList = new ArrayList<>(strings);
}

It may be more useful, however, to instead expose methods to mutate the underlying list in other ways. For example, perhaps you simply want to support adding new items to the list:

public void addString(String string) {
  this.stringList.add(string);
}

public void addStrings(Collection<String> strings) {
  this.stringList.addAll(strings);
}

If you do decide to expose a setter that replaces the value, you probably want to first check it for correctness. Since your class initializes the ArrayList in an instance initializer, most likely you don't expect it will ever be null. So you should throw an exception if it is:

public void setStringList(List<String> stringList) {
  if (stringList == null) {
    throw new NullPointerException("stringList must not be null");
  }
  this.stringList = stringList;
}

Java 7 added a new Objects.requireNonNull method for exactly this purpose.

Example -

import java.util.ArrayList;
import java.util.List;

public class Test {

List<String> list = null;

public List<String> getList() {
    return list;
}

public void setList(List<String> list) {
    this.list = list;
}

public static void main(String[] args) {
    Test test = new Test();
    List<String> sample = new ArrayList<String>();
    sample.add("element 1");
    test.setList(sample);
    List<String> sample1 = test.getList();
}
}

It depends on what you are trying to do, in some cases keeping it somewhat immutable is useful, which looks like what you are going for. You can write the methods a bit more concisely like so.

private int[] myArray = {1,2,3,4,5};
private ArrayList<Integer> myArrayList = new ArrayList<Integer>();

public int[] getMyArray()
{
    return Arrays.copyOf(myArray, myArray.length);
}

public ArrayList<Integer> getMyArrayList()
{
    return new ArrayList<>(myArrayList);
}

public void setMyArray(int[] newArray)
{
    this.myArray =  Arrays.copyOf(newArray, newArray.length);
}

public void setMyArrayList(ArrayList<Integer> newArrayList)
{
    this.myArrayList = new ArrayList<>(newArrayList);
}

While you can have setters and getter of List type, you should think carefully about their implementation, because most lists are mutable. For instance, assume that you want to validate that the jobs list is not empty.

public void setJob(List<Employee> jobs) {
  if (jobs.isEmpty()) throw new RuntimeException();
  this.job = jobs;
}

Now the following code produces an employee without jobs:

Employee e = ...;
e.setJobs(jobs);
jobs.clear();
//the employee now has no jobs :-(

You can avoid this issue by making a defensive copy

public void setJob(List<Employee> j) {
  this.job = new ArrayList<>(j);
}

The same applies to the getter. If you implement it as:

public List<Employee> getJobs() {
   return this.jobs;
}

you are allowing the caller to modify the private job list without invoking the corresponding setter: myEmployee.getJobs().clear().

In this case, you may return an unmodifiable list instead of returning the inner object.

public List<Employee> getJobs() {
   return java.util.Collections.unmodifiableList(this.jobs);
}    

You can just call set with the List you have created or return a new one by calling get:

SCHOOL school = new SCHOOL();
school.setStudents(studentList);

List<STUDENT> students = school.getStudents();

You could also input data directly to a SCHOOL class with such a method

public void addStudent(STUDENT student) {
    students.add(student);
}

or this one where you don't have to create a STUDENT yourself

public void addStudent(String names, int age) {
    STUDENT student = new STUDENT();        
    student.setNames(names);
    student.setAge(age);
    students.add(student);
}

you would need and index to get a STUDENT from a SCHOOL

public STUDENT getStudent(int index) {
    return students.get(index);
}

Use

mi.get(i).setname(rs.getString("name"));

A multi-dimensional array is also a 1-dimensional array: int[a][b][c] is really just int[a*b*c], so the problem boils down to, how do you provide access safely? Simply like this:

public class Foo {
    private int[] array;

    public Foo(int[] array) {
        this.array = Arrays.copyOf(array, array.length);
    }

    /** @return a copy of the array */
    public int[] getArray() {
        return Arrays.copyOf(array, array.length);
    }
}

That's it.

Callers have a safe copy of the array and can use it in the full normal way arrays are used. No need for delegator methods.

Your problem is the following:

In "NewClass2" you have

1. a constructor for int pages, String released, String title and int isbn
2. a constructor for () {nothing}

To get every book of your ArrayList you could replace the following line

NewClass2 book = new NewClass2(listTest);
book.printInfo();

to

for (NewClass2 book : listTest){
    book.printInfo();
}

This would print the info of every book inside the ArrayList.

I hope that I could help you.