Question: ```
       for (int rowNum = 1; rowNum < sheet.getLastRowNum(); rowNum++) {
            Row row = sheet.getRow(rowNum);
            Employee instance = methodToGetInstance(parameters);
            originalList.add(instance);
        }
        List<Employee> copy = new ArrayList<>(originalList);
        List<Employee> totalCopy = new ArrayList<>(originalList);
        while (startDate.isBefore(ChronoLocalDate.from(SecurityUtils.now().plusMonths(3)))) {
            int index = 0;
            for (Employee instance : copy) {
                instance.setStartDateTime(startDateTime);       //here i'm updating the value in copyList
                instance.setEndDateTime(startDateTime.plusHours(24));
                totalCopy.add(instance);               
                index++;
            }
        }

```

Here i m updating values in instance which is from Copied List it also affecting the OriginalList.

Please help me to resolve this issue...!!

Answer: 
They are completely different.

Using `async`/`await` allows you to consume Promises in a flat manner in your code, without nesting callbacks or hard-to-read `.then` chains. For example:

```
const doSomething = async () => {
  await asyncStep1();
  await asyncStep2();
  await asyncStep3();
};

```

where each async step returns a Promise.

`await` only allows you to "delay" code in a block if you already have a Promise to work with (or something that you convert to a Promise).

`setTimeout` is not similar at all to `async`/`await` - `setTimeout` doesn't consume a Promise or have anything to do with Promises at all. `setTimeout` allows you to queue a callback to be called later, after the timeout time has finished.

Unlike `await`, `setTimeout` does not delay code in a block - rather, you pass it a *callback*, and the callback gets called later.
`setTimeout` allows you to delay execution for an approximate amount of time.

```js
let log = () => console.log('log');

// invokes `log()` after a delay
setTimeout(log, 1000);
```

`async/await` helps you deal with promises without function handlers; it's just syntactic sugar. It doesn't actually delay execution.

```js
let promise = Promise.resolve(5);

let main = async() => {
  // without await
  promise.then(value => console.log(value));

  // with await
  console.log(await promise);
};

main();
```