Re: static initialization of arrays

From:

Johan <johanditmar@gmail.com>

Newsgroups:

comp.lang.java.programmer

Date:

Tue, 16 Oct 2007 00:23:39 -0700

Message-ID:

<1192519419.126180.117110@k35g2000prh.googlegroups.com>

Thanks for all the replies, people. What I'm trying to achieve is
illustrated by the following 'code':

class Base
{
  static final String[] A = {1, 2, 3};
  static final String[] B = {3, 4, 5};
  static final String[] C = {...};
  ...
};

class Derived1
{
  static final String[] V = A union B;
}

class Derived2
{
  static final String[] V = A union B union C;
}

So I'm really trying to write a collection of static final arrays (or
lists) in my baseclass and then combine them in various ways in
different derived classes. Because A, B etc are in a different class,
I am worried about the initialisation problem. I know that base
objects are constructed before derived objects, bur I'm not so sure if
this is true for static objects.

The reason that I used arrays rather than lists is that I thought they
would more efficient (otherwise you would have to constuct a linked
list from an array and then use that to populate the set). I know this
is not an issue, as it happens during static initialization, but it's
a force of habit :-)

Thanks,

Johan

On Oct 16, 5:13 am, Daniel Pitts <googlegrou...@coloraura.com> wrote:

On Oct 15, 3:33 pm, Johan <johandit...@gmail.com> wrote:

Hi guys,

I started to write some Java today, see the code below. What I want to
do is produce a static array V from several static arrays A, B, ...,
but I don't want V to have any duplicate elements. I was wondering if
there is a better way of coding this up?

[snip]

import java.util.*;

class StringSet extends TreeSet<String>
{
    public void addAll( String[] strings )
    {
        for (String s: strings )
        {
            add( s );
        }
    }

};

No need for a special StringSet class...

class Main
{
    private static final String[] A = { "A1", "A2", "B1" };
    private static final String[] B = { "B1", "B2" };
    ...

    private static final StringSet S =
        new StringSet ()
        {
            {
                addAll( A );
                addAll( B );
                ...
            }
        };

    private static final String[] V = S.toArray(new String[S.size()]);

    ...

}

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);
  }

}

Also, is there a way to
guarantee that arrays A, B, ... are constructed before S and V without
relying on the order in which they are declared?

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?- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -