Defining user defined var.

[Emnaki Chih]

in C there is a function #define i think which acts like precompile substitution
is there something like that in java?
I would like to initialize a lot of arrays in an interface. Most of the elements in the array are related and will most likely appear if the other one(s) appears as well. Is the a faster more maintainable way of doing this in java appart from enter in the intialization of each array in full?

[M Beck]

Originally posted by Emnaki Chih:
in C there is a function #define i think which acts like precompile substitution
is there something like that in java?

no, there isn't. (and, in fact: no, there isn't - C's #define is not a function, properly. functions can't be called before compilation.)

I would like to initialize a lot of arrays in an interface. Most of the elements in the array are related and will most likely appear if the other one(s) appears as well. Is the a faster more maintainable way of doing this in java appart from enter in the intialization of each array in full?

i wish i knew of a good answer to this, but i'm just not sufficiently familiar with interfaces. i don't think you can run code in an interface, so this might actually be a sign that your design is not quite optimal; are you sure that this initialization couldn't somehow be moved into a class?

[Lionel Badiou]

Hi Emnaki,

As for myself, what you are trying to do is to vague to offer an hint. Could you post a C sample code of what your are trying to do in Java ?

Best regards,

[Emnaki Chih]

String TEXT = "text";
 //String[] CONTENTS = {LI, "BR","P", TEXT, "B"};
 String[] HTM = {"HEAD", "BODY"};
 String[] HEAD = {"TITLE"};
 String[] TITLE = {TEXT};
 String[] BODY = {"OL", "UL", "DL", "BR","P", TEXT, "B", "I"};
 String[] UL = {"LI", "UL", "OL"};
 String[] OL = {"LI", "UL", "OL"};
 String[] LI = {"BR", TEXT, "B", "I"};
 String[] DL = {"DT", "DD"};
 String[] DT = {TEXT, "B", "I"};
 String[] DD = {TEXT, "B", "I"};
 String[] BR = {};
 String[] P = {"OL", "UL", "DL", "BR", TEXT, "B", "I"};
 String[] B = {TEXT, "I"};
 String[] I = {TEXT, "B"};  

Won't it be great if I could add content to each list that needs it, and be able to add to content and automatically add to all the lists with contents and not have to add to add to each initialization one by one? These are all declared in the interface by the way.

[Layne Lund]

Can you restate your question? The last message is not very clear to me. It would be helpful if you wrote the code first in C using the #define to illustrate what you would like to do in Java. C's #define sytnax does a lot of different things, and depending on how you are using it, there are different approaches to use in Java to get similar results.

HTH

Layne

[Emnaki Chih]

Lets say java has the define function then I could do.

#define CONTENTS " a, b, c, d "
String[] anArray = { CONTENTS , e, f, g };  

instead of

 
String[] anArray = { a, b, c, d , e, f, g };
 

is there a way to do this in java? it will help if I have to put CONTENTS into a lot of array initializations.
[ February 09, 2005: Message edited by: Emnaki Chih ]

[marc weber]

Could you use an ArrayList instead of an Array?

In the code below, I've defined an interface with a pre-valued List (since you indicated above that you might want to use an interface in this manner).

Then I defined a class implementing that interface, and used the List to initialize an ArrayList. After that, I can add to the ArrayList as desired.

import java.util.*;
 
interface Inter {
  List<String> contents = Arrays.asList("a", "b", "c", "d");
}
 
public class Basis implements Inter {
  static ArrayList<String> conPlus = new ArrayList<String>(contents);
 
  public static void main(String[] args) {
    List<String> supplement = Arrays.asList("e", "f", "g");
    conPlus.addAll(supplement);
    System.out.println(conPlus);
  }
}

This code uses 1.5. But I think the only new feature here is the generics, so if you remove the type parameters <String> it should work in 1.4.
[ February 10, 2005: Message edited by: marc weber ]

[Lionel Badiou]

Hi Emnaki,

Here's a sample code (1.4) that you could do.

import java.util.ArrayList;
 
interface MyInterface
{
  String u ="uuu";
  String[] f ={"fff","ggg"};
  String[][] privateContent = {{u}, f};
 
  ArrayList CONTENT = new ArrayList();
}
 
class foo
{
  public static void main(String[] args)
  {
    /*init interface in your main class */
    for (int i=0; i < MyInterface.privateContent.length; i++)
      for (int j =0; j < MyInterface.privateContent[i].length; j++)
        MyInterface.CONTENT.add(MyInterface.privateContent[i][j]);
 
    /*  You may now manage CONTENT as a String Collection or a String[] */
 
   /* Collection of String */
  for (int k=0; k < MyInterface.CONTENT.size(); k++)
    System.out.println(MyInterface.CONTENT.get(k));
 
    /* String[] */
  for (int k=0; k < MyInterface.CONTENT.toArray().length; k++)
    System.out.println(MyInterface.CONTENT.get(k));
  }
}
  

Hope that helps,

[marc weber]

Lionel: Very clever approach! I like it...

[Joel McNary]

Don't use an interface to define constants like this! Use a class, and then you can use the following:

public class Constants{
 
protected static final String[] combineArrays(String[] s1, String[] s2) {
    String[] s3 = new String[s1.length + s2.length];
    System.arraycopy(s1, 0, s3, 0, s1.length);
    System.arraycopy(s2, 0, s3, s1.length, s2.length);
    return s3;
}
 
public static final String TEXT = "text";
public static final String[] HTM = new String[]{"HEAD", "BODY"};
public static final String[] LI = {"BR", TEXT, "B", "I"};
public static final String[] UL = {"LI", "UL", "OL"};
public static final String[] P = combineArrays(LI, UL);
//etc...
}