As commented, the Add() method on an ArrayList outputs the index into which the new item is added. To suppress this output, just do $null = $newobj.Add($nobj) or [void]$newobj.Add($nobj)

As for the Remove() method in a Generic List, it works for me if I specify the object to remove correctly:

$Collection = New-Object System.Collections.Generic.List[System.Object]
$items = 'foo', 'bar', 'baz'
foreach ($item in $items) {
    $obj = New-Object PSCustomObject
    $obj | Add-Member -NotePropertyName Property1 -NotePropertyValue $item
    $obj | Add-Member -NotePropertyName Property2 -NotePropertyValue ""
    $obj | Add-Member -NotePropertyName Property3 -NotePropertyValue ""
    $Collection.Add($obj)

    # or simply do
    # $Collection.Add([PsCustomObject]@{Property1 = $item; Property2 = ''; Property3 = ''})
}

To create a copy of the collection, you can do:

$newCollection = [PsCustomObject[]]::new($Collection.Count)
$Collection.CopyTo($newCollection)

Remove one object from the original $Collection:

Collection | Where-Object {$_.Property1 -eq 'bar'}
[void]$Collection.Remove(Collection

Output:

Property1 Property2 Property3
--------- --------- ---------
foo                          
baz                          

I can't get that constructor to work either. This however seems to work:

# $temp = Get-ResourceFiles
$resourceFiles = New-Object System.Collections.ArrayList($null)
$resourceFiles.AddRange($temp)

You can also pass an integer in the constructor to set an initial capacity.

What do you mean when you say you want to enumerate the files? Why can't you just filter the wanted values into a fresh array?

Edit:

It seems that you can use the array constructor like this:

$resourceFiles = New-Object System.Collections.ArrayList(,$someArray)

Note the comma. I believe what is happening is that when you call a .NET method, you always pass parameters as an array. PowerShell unpacks that array and passes it to the method as separate parameters. In this case, we don't want PowerShell to unpack the array; we want to pass the array as a single unit. Now, the comma operator creates arrays. So PowerShell unpacks the array, then we create the array again with the comma operator. I think that is what is going on.

# Copy the array here
$FruitsCopy = @()
$FruitsCopy = $FruitsCopy + $FruitsOriginal