I have the below code

What is my $stream = streamname; meant to do? "streamname" is a bare word, and without strict it will be interpreted as a literal string. What for?

my $xlink,@xlinkpaths;
[download]

This doesn't do what you want. To give my a list, you have to wrap the list in parens:

perl -Mstrict -ce 'my $xlink,@xlinkpaths'
Global symbol "@xlinkpaths" requires explicit package name at -e line 
+1.
-e had compilation errors.

perl -Mstrict -ce 'my($xlink,@xlinkpaths)'
-e syntax OK
[download]

but in

the parens are gratuitous.

    foreach $xlink (@xlinks) { 
         @xlinkpaths =  
    }
[download]

Missing right hand side of assignment. Ok, you ask for that in

1)

First, you don't want to assign to @xlinkpaths, but append to it. Use push. Then, to get the text after /./, you could use a regular expression:

    foreach $xlink (@xlinks) { 
         push @xlinkpaths, $xlink =~ m{incl -s streamname /./(.+)}; 
    }
[download]

Look up the match operator m// (used as m{} here) in perlop.
The match operator returns 1 upon success; if used in list context (this is the case with push) it returns 1, if no captures are used (a capture is what is caught by parens, in the above code (.+), otherwise it returns the captures.
Captures are stored in $1, $2, $3, ...

The above code could have been written as

    foreach $xlink (@xlinks) {
         $xlink =~ m{incl -s streamname /./(.+)};
         push @xlinkpaths, $1;
    }
[download]

which gives you the possibility to not include empty matches via a statement modifier:

         push @xlinkpaths, $1 if $1;
[download]

2)

As you have already learned by now, use push to append to an existing array. Use unshift to prepend to an existing array. Your final @xlinkpaths looks like prepending.

unshift @exclpaths, @xlinkpaths;
[download]

Your code - after cleanup and inserting mising bits - could look like

use strict; 
use warnings;
my( $xlink,@xlinkpaths );
my $stream = streamname;
my @xlinks = (`cmd to get xlinks`) ;

foreach $xlink (@xlinks) {
    push @xlinkpaths, $xlink =~ m{incl -s streamname /./(.+)};
}

my @exclpaths = (
    "wefwfewf/fewfff/",
    "btrtbrtb/gbrgbrg/rttty/",
 );
unshift @exclpaths, @xlinkpaths;
[download]

and appears to do what you want.

The first part worked fine. But before prepend(or)after the array, i would like to have the @xlinkpaths contents also in the same pattern as @exclpaths. That is
1.every value should end with '/'
2. should be enclosed within quotes ""
3. Should have comma ',' at end
How can I achieve this? I want to maintain the same exisitng format in @exclpaths array

1.every value should end with '/'
2. should be enclosed within quotes ""
3. Should have comma ',' at end

See the concatenation operator '.' in perlop, Additive Operators, and substr.

Read perlop. All of it.

I want to maintain the same exisitng format in @exclpaths array

The format in your @exclpaths is its representation in code. Inside the array, the strings are not enclosed within double quotes, and they don't have a comma at the end:

my @exclpaths = (
    "wefwfewf/fewfff/",
    "btrtbrtb/gbrgbrg/rttty/",
 );
print $_,"\n" for @exclpaths;
__END__
wefwfewf/fewfff/
btrtbrtb/gbrgbrg/rttty/
[download]

If you want decorations, just add them:

my @exclpaths = (
    "wefwfewf/fewfff/",
    "btrtbrtb/gbrgbrg/rttty/",
 );
print "\"$_\",\n" for @exclpaths;
__END__
"wefwfewf/fewfff/",
"btrtbrtb/gbrgbrg/rttty/",
[download]

perl -le'print map{pack c,($-++?1:13)+ord}split//,ESEL'

First, do yourself a big favour and add strictures (use strict; use warnings;) to every script you write.

The answer to both questions is the same: use push.

For the first part, you can use map (which takes a list of elements and returns a new one computed from elements of the first) and regexes

@xlinkpaths = 
    map 
    { 
        if (/xlink (.+?) /) # if xlink has been found, and characters 
+captured
        { $1; }             # yield the captured data
        else
        { (); }             # yield 0 elements
     } @xlinks;             # Do this for all elements of @xlinks
[download]

To concatenate two arrays (in the order you gave), just do: @exclpaths = (@xlinkpaths, @exclpaths);, or unshift @exclpaths, @xlinkpaths;, whatever looks clearer to you (if your lists are not really big, both are equivalent). See unshift or push.

In my $xlink,@xlinkpaths; the variable @xlinkpaths is not affected by the my, which will give you an error if you use strict (using strict will tell you where most of your mistakes are, so you should do it).

For the most part if you find yourself writing significant code in a map, use a for loop instead. Your 7 line confusing map requiring multiple comments becomes:

for my $xlink (@xlinks) {
    push @xlinkpaths, $1 if $xlink =~ /xlink (.+?) /;
}
[download]

Although you could instead write it:

@xlinkpaths = map {/xlink (.+?) / ? $1 : ()} @xlinks;
[download]

Perl is the programming world's equivalent of English

or even

@xlinkpaths = map /xlink (.+?)/, @xlinks;
[download]

you think you're getting undefs (but you're not in this case)? simply prepend  grep defined,  map ...

Well, yes, you are right. Actually I started with the short version that Anonymous Monk gave, and I thought it would be confusing for someone not used to reading that sort of things. I should have gone for your first solution when I wanted to make it more verbose.

In the interest of balancing clarity and robustness with map, I would suggest the following as an example.

map { 
    /xlink (.+?) /;
    $1 ? $1 : ();
     } @xlinks
[download]

Of course the trinary operator here is not needed. However, oen problem I have seen with map is accidently clobbering the return values if I am not careful. Therefore if I have a conditional in the return, I try to use a trinary operator at the very end.

BTW, I don't mind putting significant code in a map block. However one does have to be careful about it. I think if the code gets too much, one is better off usually putting the code in a function and calling that rather than going with a for loop.