You basically want a hash table with values that are arrays. You don't have to use $hashtable.get_item or .add

$myHashTable = @{} # creates hash table
$myHashTable.Entry1 = @() #adds an array
$myHashTable.Entry1 += "element1"
$myHashTable.Entry1 += "element2"

This results in the following output:

$myHashTable

Name                           Value                                                                                                                                                                                           
----                           -----                                                                                                                                                                                           
Entry1                         {element1, element2}

$myHashTable.Entry1
element1
element2

You already got a helpful answer for the first part of your question.

This is my try at the second part - how to assign members of nested hash tables. There isn't an easy built-in syntax to set nested values while creating any not-yet-existing parent hash tables, so I've created a reusable function Set-TreeValue for that purpose.

function Set-TreeValue( $HashTable, [String] $Path, $Value, [String] $PathSeparator = '\.' ) {

    # To detect errors like trying to set child of value-type leafs.
    Set-StrictMode -Version 3.0  

    do {
        # Split into root key and path remainder (", 2" -> split into max. 2 parts)
        $key, $Path = $Path -split $PathSeparator, 2

        if( $Path ) {
            # We have multiple path components, so we may have to create nested hash table.
            if( -not $HashTable.Contains( $key ) ) {
                $HashTable[ $key ] = [ordered] @{}
            }
            # Enter sub tree. 
            $HashTable = $HashTable[ $key ]
        }
        else {
            # We have arrived at the leaf -> set its value
            $HashTable[ $key ] = $Value
        }
    }
    while( $Path )
}

Demo:

$ht = [ordered] @{}

Set-TreeValue $ht foo.bar.baz 42   # Create new value and any non-existing parents
Set-TreeValue $ht foo.bar.baz 8    # Update existing value
Set-TreeValue $ht foo.bar.bam 23   # Add another leaf
Set-TreeValue $ht fop 4            # Set a leaf at root level
#Set-TreeValue $ht fop.zop 16      # Outputs an error, because .fop is a leaf
Set-TreeValue $ht 'foo bar' 15     # Use a path that contains spaces

$ht | ConvertTo-Json -Depth 99     # Output the content of the hash table

Output:

{
  "foo": {
    "bar": {
      "baz": 8,
      "bam": 23
    }
  },
  "fop": 4,
  "foo bar": 15
}

NOTE: I've opted to create nested hash tables as OrderedDictionary as these are much more useful than regular ones (e. g. to ensure an order in a JSON output). Remove [ordered] if you want unordered hash tables (which propably have slight performance advantage).

This seems like a bug since the syntax to retrieve the Keys entry is superseding the HashTable's Keys property, though I could see one expecting it to behave either way. According to the Adding a key of 'keys' to a Hashtable breaks access to the .Keys property issue on GitHub, this is a bug but would require a breaking change to correct, so the workaround below was added to the documentation.

According to about_Hash_Tables:

If the key name collides with one of the property names of the HashTable type, you can use PSBase to access those properties. For example, if the key name is keys and you want to return the collection of Keys, use this syntax:

$hashtable.PSBase.Keys

You could also retrieve the property value through reflection...

PS> $ht.GetType().GetProperty('Keys').GetValue($ht)
text1
Keys

I think what you want is something more like this:

$colors = @("black","white","yellow","blue")
$Applications=@{}
Foreach ($i in $colors)
{
    $Applications[$i] = @{
        Colour = $i
        Prod = 'SrvProd05'
        QA   = 'SrvQA02'
        Dev  = 'SrvDev12'
    }
}

I will also point out that Hashtables often need to be handled defensively. Each key must be unique but values do not need to be. Here is the typical method of handling that:

$colors = @("black","white","yellow","blue")
$Applications=@{}
Foreach ($i in $colors)
{
    if($Applications.ContainsKey($i)){
        #Do things here if there is already an entry for this key
    }else{
        $Applications[$i] = @{
            Colour = $i
            Prod = 'SrvProd05'
            QA   = 'SrvQA02'
            Dev  = 'SrvDev12'
        }
    }
}

There's good information in the existing answers, but given your question's generic title, let me try a systematic overview:

• You do not need to convert a hashtable to a [pscustomobject] instance in order to use dot notation to drill down into its entries (properties), as discussed in the comments and demonstrated in iRon's answer.

  • A simple example:

    @{ top = @{ nested = 'foo' } }.top.nested  # -> 'foo'
    

  • See this answer for more information.

• In fact, when possible, use of hashtables is preferable to [pscustomobject]s, because:

  • they are lighter-weight than [pscustomobject] instances (use less memory)
  • it is easier to construct them iteratively and add / remove entries on demand.

Note:

• The above doesn't just apply to the [hashtable] type, but more generally to instances of types that implement the [System.Collections.IDictionary] interface or its generic counterpart, System.Collections.Generic.IDictionary[TKey, TValue]], notably including ordered hashtables (which are instances of type System.Collections.Specialized.OrderedDictionary, which PowerShell allows you to construct with syntactic sugar [ordered] @{ ... }).

• Unless noted, hashtable in the following section refers to all such types.

In cases where you do need to convert a [hasthable] to a [pscustomobject]:

While many standard cmdlets accept [hasthable]s interchangeably with [pscustomobjects]s, some do not, notably ConvertTo-Csv and Export-Csv (see GitHub issue #10999 for a feature request to change that); in such cases, conversion to [pscustomobject] is a must.

Caveat: Hasthables can have keys of any type, whereas conversion to [pscustomobject] invariably requires using string "keys", i.e. property names. Thus, not all hashtables can be faithfully or meaningfully converted to [pscustomobject]s.

• Converting non-nested hashtables to [pscustomobject]:

  • The syntactic sugar PowerShell offers for [pscustomobject] literals (e.g., [pscustomobject] @{ foo = 'bar'; baz = 42 }) also works via preexisting hash; e.g.:

    $hash = @{ foo = 'bar'; baz = 42 } 
    $custObj = [pscustomobject] $hash   # Simply cast to [pscustomobject]
    

• Converting nested hashtables, i.e. an object graph, to a [pscustomobject] graph:

  • A simple, though limited and potentially expensive solution is the one shown in your own answer: Convert the hashtable to JSON with ConvertTo-Json, then reconvert the resulting JSON into a [pscustomobject] graph with ConvertFrom-Json.

    • Performance aside, the fundamental limitation of this approach is that type fidelity may be lost, given that JSON supports only a few data types. While not a concern with a hashtable read via Import-PowerShellDataFile, a given hashtable may contain instances of types that have no meaningful representation in JSON.

  • You can overcome this limitation with a custom conversion function, ConvertFrom-HashTable (source code below); e.g. (inspect the result with Format-Custom -InputObject $custObj):

    $hash = @{ foo = 'bar'; baz = @{ quux = 42 } } # nested hashtable
    $custObj = $hash | ConvertFrom-HashTable # convert to [pscustomobject] graph
    

ConvertFrom-HashTable source code:

Note: Despite the name, the function generally supports instance of types that implement IDictionary as input.

function ConvertFrom-HashTable {
  param(
    [Parameter(Mandatory, ValueFromPipeline)]
    [System.Collections.IDictionary] $HashTable
  )
  process {
    $oht = [ordered] @{} # Aux. ordered hashtable for collecting property values.
    foreach ($entry in $HashTable.GetEnumerator()) {
      if ($entry.Value -is [System.Collections.IDictionary]) { # Nested dictionary? Recurse.
        $oht[[object] $entry.Key] = ConvertFrom-HashTable -HashTable $entry.Value # NOTE: Casting to [object] prevents problems with *numeric* hashtable keys.
      } else { # Copy value as-is.
        $oht[[object] $entry.Key] = $entry.Value
      }
    }
    [pscustomobject] $oht # Convert to [pscustomobject] and output.
  }
}