Task: Binary strings




Go: package main

import (
    "bytes"
    "fmt"
)








func main() {
    
    
    
    b := []byte{'b', 'i', 'n', 'a', 'r', 'y'}
    fmt.Println(b) 
    

    
    
    
    
    var c []byte
    c = b
    fmt.Println(c)

    
    
    
    
    
    fmt.Println(bytes.Equal(b, c)) 

    
    
    
    
    
    
    d := make([]byte, len(b)) 
    copy(d, b)                
    
    d[1] = 'a'
    d[4] = 'n'
    fmt.Println(string(b)) 
    fmt.Println(string(d))

    
    
    
    fmt.Println(len(b) == 0)

    
    
    
    
    
    z := append(b, 'z')
    fmt.Printf("%s\n", z) 

    
    
    sub := b[1:3]
    fmt.Println(string(sub))

    
    
    
    
    
    
    f := bytes.Replace(d, []byte{'n'}, []byte{'m'}, -1)
    fmt.Printf("%s -> %s\n", d, f)

    
    
    
    
    rem := append(append([]byte{}, b[:1]...), b[3:]...)
    fmt.Println(string(rem))
}


Java: module BinaryStrings
    {
    @Inject Console console;
    void run()
        {
        Byte[] mutableBytes = new Byte[];       
        Byte[] fixedLength  = new Byte[10];     
        Byte[] literal      = [0, 1, 7, 0xff];  
        console.print($|String creation and assignment:
                       |  mutableBytes={mutableBytes}
                       |  fixedLength={fixedLength}
                       |  literal={literal}
                       |
                     );

        console.print($|Check if a string is empty:
                       |  mutableBytes.empty={mutableBytes.empty}
                       |  fixedLength.empty={fixedLength.empty}
                       |  literal.empty={literal.empty}
                       |
                     );

        mutableBytes += 0;                      
        mutableBytes.add(1);                    
        mutableBytes.addAll(#07FF);             
        console.print($|Append a byte to a string:
                       |  mutableBytes={mutableBytes}
                       |
                     );

        console.print($|String comparison:
                       |  mutableBytes==literal = {mutableBytes==literal}
                       |  fixedLength==literal = {fixedLength==literal}
                       |
                     );

        fixedLength = new Byte[4](i -> literal[i]);     
        val clone = fixedLength.clone();                
        console.print($|String cloning and copying:
                       |  fixedLength={fixedLength}
                       |  clone={clone}
                       |
                     );

        console.print($|Extract a substring from a string:
                       |  mutableBytes[1..2]={mutableBytes[1..2]}
                       |  fixedLength[0..2]={fixedLength[0..2]}
                       |  literal[2..3]={literal[2..3]}
                       |
                     );

        for (Int start = 0; Int index := fixedLength.indexOf(0x01, start); start = index)
            {
            fixedLength[index] = 0x04;
            }
        console.print($|Replace every occurrence of a byte in a string with another string:
                       |  fixedLength={fixedLength}
                       |
                     );

        for (Int start = 0; Int index := mutableBytes.indexOf(#0107, start); start = index)
            {
            mutableBytes.replaceAll(index, #9876);
            }
        console.print($|Replace every occurrence of a string in a string with another string:
                       |  mutableBytes={mutableBytes}
                       |
                     );

        console.print($|Join strings:
                       |  mutableBytes+fixedLength+literal={mutableBytes+fixedLength+literal}
                       |
                     );
        }
    }