static initialization of arrays

J

Johan

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? 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?

Thanks,

Johan

-----------------------------------------

import java.util.*;

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

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()]);

...
}
 
S

Stefan Ram

Johan said:
produce a static array V from several static arrays A, B, ...,
but I don't want V to have any duplicate elements.
Click to expand...

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]
 
S

Stefan Ram

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

When answering, I actually had not yet read
the question to the end, so that my answer
might not address all questions of the OP.

I only answered to how to merge arrays
removing duplicates - not being aware that
the OP already used java.util.Set.
 
P

Patricia Shanahan

Johan said:
Hi guys,
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? 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?
Click to expand...

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
 
D

Daniel Pitts

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

};
Click to expand...
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()]);

...

}
Click to expand...

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?
Click to expand...
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?
 
J

Johan

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

Hi guys,
Click to expand...
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.*;
Click to expand...
class StringSet extends TreeSet<String>
{
public void addAll( String[] strings )
{
for (String s: strings )
{
add( s );
}
}
Click to expand...
};
Click to expand...

No need for a special StringSet class...






class Main
{
private static final String[] A = { "A1", "A2", "B1" };
private static final String[] B = { "B1", "B2" };
...
Click to expand...
private static final StringSet S =
new StringSet ()
{
{
addAll( A );
addAll( B );
...
}
};
Click to expand...
private static final String[] V = S.toArray(new String[S.size()]);
...
Click to expand...

}
Click to expand...

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?
Click to expand...

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 -
Click to expand...
 
L

Lew

Johan said:
Thanks for all the replies, people.
Click to expand...

Please, please, please, please, please do not top-post.
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 :)
Click to expand...

Be aware that not all Lists are LinkedLists. And what does "efficient" mean
to you - a week of figuring out how to code something to save a millisecond
that will be optimized away by the HotSpotter anyway?

Since you're looking into using Collections to implement your features anyway,
i.e., using a Set to prevent duplicate entries, you might consider going
Collection all the way and not using explicit arrays.

This also lets you use generics for type safety.
 
D

Daniel Pitts

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

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,
Click to expand...


*Why* are you doing this? How will it improve your end-users
experience?
 
J

Johan

On Oct 16 said:
illustrated by the following 'code':
[snip]

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.
Click to expand...
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 :)
Click to expand...
Thanks,
Click to expand...

*Why* are you doing this? How will it improve your end-users
experience?
Click to expand...

My sub-classes send queries to a database. Some of these queries are
specific to a sub-type, other queries are common to several sub-types.
I grouped the queries into sets by function and by storing the these
sets in the base class, sub types can use and combine them as
necessary. This makes it easier to add new subtypes in the future. I
hope this is clear so far.

With regards to using arrays as opposed to containers for this
purpose, I agree that it is better to use containers as performance is
not an issue. I only just started writing Java - I am used to
developing C++ applications where performance *is* an issue and where
converting between STL containers is often not appropriate.

Thanks,

Johan
 
D

Daniel Pitts

On Oct 16 said:
illustrated by the following 'code':
Click to expand...
[snip]
Click to expand...
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,
Click to expand...
Click to expand...
*Why* are you doing this? How will it improve your end-users
experience?
Click to expand...

My sub-classes send queries to a database. Some of these queries are
specific to a sub-type, other queries are common to several sub-types.
I grouped the queries into sets by function and by storing the these
sets in the base class, sub types can use and combine them as
necessary. This makes it easier to add new subtypes in the future. I
hope this is clear so far.

With regards to using arrays as opposed to containers for this
purpose, I agree that it is better to use containers as performance is
not an issue. I only just started writing Java - I am used to
developing C++ applications where performance *is* an issue and where
converting between STL containers is often not appropriate.

Thanks,

Johan
Click to expand...

I'm still thinking that it might be useful for you to externalize all
of this data. At least consider it.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

Dark corners of the JLS: static methods, hiding, and bytecode 0
Primitive type arrays boxing utilities 6
inner class and static 9
Python point location of intersect between two lines 0
retriving escape unicode sequences from files ... 1
retriving escape unicode sequences from files ... 1
Generics/Comparator 4
Mapping of JTable rows and columns onto frame object 2

Members online

Total: 51 (members: 2, guests: 49)
Robots: 442

Forum statistics

Threads
473,769
Messages
2,569,580
Members
45,054
Latest member
TrimKetoBoost

Latest Threads

Top