The best way, by far, would be to create a class to store circle... see the From several arrays to classes article.

If that's too much of a stretch, then you can make each of the arc arrays into 2D arrays - or, more accurately, arrays of arrays. You can still treat each array as an array and each element of each array as its own array. As you can imagine, this will get incredibly confusing, which is why classes are the preferred method...

The answer partially depends on what you try to do.
Currently, you create 3 random arcs on each frame, so the object will look flickering a lot. If that's what you want, OK, but if you want something more stable, you have to create the arcs in the constructor of ArcCirc.
Here is a more stable version:

1. ArcCirc wilfred;
2.  
3. void setup() {
4.   size(500,500);
5.   smooth();
6.   // Parameters go inside the parentheses when the object is constructed.
7.   wilfred = new ArcCirc(width/2, height/2);
8. }
9.  
10. void draw() {
11.   background(255);
12.   wilfred.display();
13. }
14.  
15. //ArcCirc class - circle with a random number of RandArcs on it
16. class ArcCirc {
17.   float xpos;      //from global
18.   float ypos;      //from global
19.   float widhei;    //random - width and height are the same since I'm after a circle here
20.   int numarcs;   //random between 1 and 3
21. //  float circStroke;
22. //  float arcStroke;
23.   RandArc[] randy;
24. //Constructor
25.   //I want to draw a circle of random size, then add a random number of ArcCircs to it between 1 and 3
26.   //(maybe more smaller ones if it doesn't look right).
27.  
28.   ArcCirc(float _xpos, float _ypos) {
29.     xpos = _xpos;
30.     ypos = _ypos;
31.     widhei = int(random(20, 500));  //width and height are the same since I'm after a circle here
32.     numarcs = 3;   //int(random(1, 3));
33.     randy = new RandArc[numarcs];    //I should have an array of new RandArcs (between 1 and 3)
34.     for (int i = 0; i < numarcs; i++) {
35.       randy[i] = new RandArc(width/2, height/2, widhei, widhei, radians(random(1,60)), radians(random(1,60))); //should create a randarc
36.     }
37.   }
38.  
39.   void display() {
40.     stroke (150);
41.    // ellipse(width/2, height/2, widhei, widhei);
42.     for (int i = 0; i < numarcs; i++) {
43.       randy[i].display();  //should display the RandArc it just created
44.     }
45.   }
46. }
47.  
48.    
49. // RandArc class - single random arc.
50. // Class definition
51. class RandArc {
52.   float xpos;
53.   float ypos;
54.   float wid;
55.   float hei;
56.   float start;
57.   float stop;
58.  
59. // Constructor
60.   //I want the number of arcs drawn to be random and the length of the arc to be random,
61.   //but the position and size to be brought in from variables set by the circle it will nest in.
62.  
63.   RandArc(float tempXpos, float tempYpos, float tempWid, float tempHei, float tempStart, float tempStop) {
64.     xpos = tempXpos;
65.     ypos = tempYpos;
66.     wid = tempWid;
67.     hei = tempHei;
68.     start = tempStart;    //radians(3); //radians(random(0, 360));    //randomizes the start position
69.     stop = tempStop;     //radians(60); //radians(random(0, 360));     //eventually will add length to the segment when the method is calle
70.   }
71.  
72.   void display() {
73.     arc(xpos, ypos, wid, hei, start, start + stop);   //putting start + stop as the endpoint of the arc ensures no negative value
74.   }
75. }

But it still displays only one arc. I will look at your way to create an arc.

[EDIT] Actually, your range of angles isn't big enough to distinguish the arcs. If you offset them slightly, you can see them more distinctly:

1.   ArcCirc(float _xpos, float _ypos) {
2.     xpos = _xpos;
3.     ypos = _ypos;
4.     widhei = int(random(20, 500));  //width and height are the same since I'm after a circle here
5.     numarcs = 3;   //int(random(1, 3));
6.     randy = new RandArc[numarcs];    //I should have an array of new RandArcs (between 1 and 3)
7.     for (int i = 0; i < numarcs; i++) {
8.       randy[i] = new RandArc(width/2, height/2, widhei + i * 10, widhei + i * 10,
9.           radians(random(60)), radians(random(60))); //should create a randarc
10.     }
11.   }

BTW, your usage of classes is quite good for somebody starting to use them.

Thanks for taking the time to look through this, PhiLho, I'm going to work through that now and see what's changed, and hopefully come back with more specific questions (or better yet, figure it out myself ;)

OK, so still trying to get my head around random(); (and I guess the structure of Processing in general)

Actually, the roots are:
- Global variable initializations (done once before setup(); beware, path, for example, isn't set yet)
- setup()
- draw()
- and event functions, like mousePressed() or keyReleased().

Other inits are done from these roots.
For example, wilfred is initialized in setup(), so its init is done once: the constructor will be called once.
wilfred.display() is called from draw(), so it is called once per frame.
Your code made a new RandArc() in display, so you created the new object each time display() is called, thus on each frame (from draw()).
And so on.

That helps. Time to bang away at the code again - thanks! :)

woo hoo! I think I finally grok randomization. Here's the code that does exactly what I wanted, plus randomizes the color a bit. I also created another class for groups of ArcCircs in case I need to create ripples or something. Thanks so much for your help, PhiLho and calsign.

It looks good, and the code is well done.
I would just move the strokeCap(SQUARE); to setup() since you never change it, but that's a very minor remark / improvement.

I went back and refactored the code a bunch to remove nested objects and make everything occur in setup() rather than draw. I think it's finally at the stage where I'm happy with it :)