To directly access a char from within a String, you need method -> charAt().

thanks but I know that , I'm trying to make a new String who as the name of a result of a function split()

use a hashmap? 8)

this is hard to do in a compiled language like processing (java) because all the names have to be defined ahead of time.

with a hashmap you can associated the name 'vox' with a string (vox is the key, string is the value). but it won't be a String variable called 'vox' the same way String vox; is.

(tbh, i can't think why you'd ever need this)

kooogy is right, this kind of PHP coding isn't usual / needed in Java...
At "best", you can access an existing variable by its name, using reflection, but that's slow, prone to error (what if the input isn't the one expected?) and hackish...

Instead of asking how to do some hack to reach your goal, perhaps you could explain your goal, so we can provide an appropriate solution... (probably involving a HashMap... )

thanks for answering, of course I can explain :)

I've got some incomming message receive by OSC with the library " OSCP5", they come during the time : we don't know when and we d'ont know exactly there form.
I read and put their adress in a String :
here the different adress that can took my String :

      inOSC = synth/synthesisFM/Fp
      inOSC = in/guitar/amp
      intOSC = in/guitar/pitch
      inOSC = treat/chorus/

in fact there is three type possible for the first element : "in" or "synth" or "treat".
After I'de like to draw some object which depend of their adress :

1. String[] cutOSC = split(inOSC,"/");

my first idea was to use classes of object that I've had already defined :

1. if (cutOSC[0].equals"synth"){
2.  synthObject cutOSC[1]= new synthObject ("cutOSC[1]", 250, 50, "cutOSC[2]");
3. }
   

but as you known it don't work. The second idea - while I'm writing this explanation :) - is to do "manually" : 

1. if (cutOSC[0].equals"synth"){
2. text(cutOSC[1], width/2, height/4);
   text(cutOSC[2], width/2, height/4 + 20);
   
3. etc...
4. }
5. if (cutOSC[0].equals"in"){
6. // or maybe with function, I don't try yet
   
7. drawCircle(cutOSC[1])
   
8. }
9. if (cutOSC[0].equals"treat"){
10. drawRect(cutOSC[1])
11. }
    

 one problem that appears while I try the simply solution, is that only one condition is active : wether cutOSC[0] = "synth" or "treat" or "in", whereas I need to have more than one object drawn, if the three type of OSC message is active I need to draw them together.
So, I've got certainly to put this OSC message in a String[], and to compare the fow stored and then to deduce a vizualisation.
well,
sorry for the aspect "work in progress".
thank you.

Not too sure if I followed you fully...
Let's try something.

1. HashMap<String, Drawer> map = new HashMap<String, Drawer>();
2.  
3. interface Drawer
4. {
5.   void draw(String s1, String s2); // Classes must implement this method
6. }
7.  
8. void setup()
9. {
10.   map.put("synth", new Drawer()
11.   {
12.     @Override
13.     public void draw(String s1, String s2)
14.     {
15.       text(s1, width/2, height/4);
16.       text(s2, width/2, height/4 + 20);
17.     }
18.   }
19.   );
20.  
21.   map.put("in", new Drawer()
22.   {
23.     @Override
24.     public void draw(String s1, String s2)
25.     {
26.       drawCircle(s1);
27.     }
28.   }
29.   );
30.  
31.   map.put("treat", new Drawer()
32.   {
33.     @Override
34.     public void draw(String s1, String s2)
35.     {
36.       drawRect(s1);
37.     }
38.   }
39.   );
40.  
41.   String[] inOSCs = { "synth/synthesisFM/Fp", "in/guitar/amp", "in/guitar/pitch", "treat/chorus" };
42.   for (String inOSC : inOSCs)
43.   {
44.     String[] cutOSC = split(inOSC, "/");
45.     Drawer d = map.get(cutOSC[0]);
46.     if (d == null)
47.     {
48.       println("Unknown: " + cutOSC[0]);
49.     }
50.     else
51.     {
52.       d.draw(cutOSC[1], cutOSC.length > 2 ? cutOSC[2] : "");
53.     }
54.   }
55. }
56.  
57. void drawCircle(String s) {
58.   println("drawCircle: " + s);
59. }
60. void drawRect(String s) {
61.   println("drawRect: " + s);
62. }

I defined an interface, which is a "contract": classes implementing this interface must have the defined method. So you are sure that you can call the method on objects of these classes, and you can put all these objects in a collection (here a HashMap, hehe) as instances of this interface. A powerful concept.
Another facility: no need to define a class for each kind of object, since you will create only one object of them. So I made so called anonymous classes: defined on the fly, without name.