public class Main
{
 public static void main( final java.lang.String[] args )
 {
   final java.lang.String[] a = { "A1", "A2", "B1" };
   final java.lang.String[] b = { "B1", "B2" };

   final java.util.Set<java.lang.String> set =
   new java.util.HashSet<java.lang.String>();

   set.addAll( java.util.Arrays.asList( a ));
   set.addAll( java.util.Arrays.asList( b ));

   final java.lang.String[] c = set.toArray( a );

   java.lang.System.out.println
   ( java.util.Arrays.toString( c )); }}

[A2, A1, B2, B1]

guys?

Have you considered using a static initializer block?

They are handy when a static variable needs initializing and the
initialization is too complicated to go in the variable declaration.

If you put it after the declarations of A, B, ... there will be no
forward reference problems.

Patricia

[snip]

No need for a special StringSet class...

You really should use List instead of String[], but I'll show you both
ways:

import java.util.*;

public class Main {
 public static final String[] A = { "A1", "A2", "B1" };
 public static final String[] B = { "B1", "B2" };
 public static final String[] V;
 static {
    Set<String> stringSet = new
LinkedHashSet<String>(Arrays.asList(A));
    stringSet.addAll(Arrays.asList(B));
    V = stringSet.toArray(new String[stringSet.size()]);
 }
}

The problem with that approach, is that A and B and V are still
mutable!
V[0] = "B1" will have an effect you don't want.

import java.util.*;

public class MainWithCollection {
 public static final List<String> A =
       Collections.unmodifiableList(Arrays.asList("A1", "A2", "B1"));
 public static final List<String> B =
       Collections.unmodifiableList(Arrays.asList("A1", "B1", "B2"));
 public static final List<String> V;
 static {
    Set<String> stringSet = new LinkedHashSet<String>(A);
    stringSet.addAll(B);
    ArrayList<String> stringList = new ArrayList<String>(stringSet);
    stringList.trimToSize();
    V = Collections.unmodifiableList(stringList);
 }
}

If they are in the same class, then you have to declare them in the
order you expect them to be initialized.  The compiler won't let you
refer to them before they are.  You can use a static initializer (such
as I did) to explicitly initialize them in a particular order.

Now, if you have many arrays/lists to add together (more than just A
and B), you might consider two things: One, loading this data from an
external source (data file, for instance), and at the very least, use
a for-loop to iterate over them:

public class Main {
  public static final Object[] a1 = {1, 2, 3};
  public static final Object[] a2 = {1, 2, 3};
  public static final Object[] a3 = {1, 2, 3};
  public static final Object[] a4 = {1, 2, 3};

  static {
      for (Object[] arr : new Object[][] {a1, a2, a3, a4}) {
      }
  }
}

Or similarly with the List version.

The more I think about this, the more I think you should separate out
these strings into an external file, and not have them be public nor
static.  What is it that you're trying to achieve?

use static init code.  Inside the static init, the inits must be done
in order.

see http://mindprod.com/jgloss/array.html