Should be simple, comparing the x coordinates of the hearts against the x coordinates of the arrows to find out which are likely to hit, then for these, compare the y coordinates.
If you give some code, we can give more precise advices.

As phi.lho pointed out, it's about comparing the coordinates of the hears with the arrows.

To answer the 'array' part of your question. Yes this means that in some way you have to compare the whole arrays or arraylists against each object. There are always multiple ways to do things. You could for example check each heart against all arrows (have I been shot?) or each arrow against all hearts (have I shot something?). For me the former would seem more intuitive, since the next step is removal and being shot is just another reason (condition) for an object to be removed, as is for example moving off the screen. Below is one example of how you could do it.

Code Example

main code

1. ArrayList <Arrow> arrows = new ArrayList <Arrow> ();
2. ArrayList <Target> targets = new ArrayList <Target> ();
3. int lastShot; // to prevent a continuous laser beam of arrows
4. PVector origin, m;
5. int score;
6.  
7. void setup() {
8.   size(1280, 720);
9.   textSize(50);
10.   textAlign(RIGHT, TOP);
11.   strokeWeight(3);
12.   origin = new PVector(width/2, height/2);
13.   m = new PVector();
14.   smooth();
15. }
16.  
17. void draw() {
18.   background(255);
19.  
20.   for (int i=arrows.size()-1; i>=0; i--) {
21.     Arrow a = arrows.get(i);
22.     a.update();
23.     a.display();
24.   }
25.  
26.   for (int i=targets.size()-1; i>=0; i--) {
27.     Target t = targets.get(i);
28.     t.update();
29.     t.display();
30.   }
31.  
32.   addTarget(30); // add new target every 30th frame
33.   displayShooter();
34.   text(score, width-10, 0);
35.  
36.   if (mousePressed && millis() - lastShot > 250) {
37.     addArrow();
38.     lastShot = millis();
39.   }
40. }
41.  
42. void addTarget(int nth) {
43.   if (frameCount % nth == 0) {
44.     targets.add(new Target(random(width), -50, new PVector(0, 1), 50));
45.   }
46. }
47.  
48. void addArrow() {
49.   m.normalize();
50.   arrows.add(new Arrow(origin, m));
51. }
52.  
53. void displayShooter() {
54.   m.set(mouseX, mouseY, 0);
55.   m.sub(origin);
56.   m.normalize();
57.   m.mult(25);
58.   pushMatrix();
59.   translate(origin.x, origin.y);
60.   stroke(0);
61.   line(0, 0, m.x, m.y);
62.   fill(0);
63.   ellipse(0, 0, 25, 25);
64.   popMatrix();
65. }

arrow

1. class Arrow {
2.   PVector pos, vel;
3.   boolean remove;
4.  
5.   Arrow(PVector pos, PVector vel) {
6.     this.pos = pos.get();
7.     vel.mult(5); // you could also randomize the speed for each arrow
8.     this.vel = vel.get();
9.   }
10.  
11.   void update() {
12.     pos.add(vel);
13.     if (pos.x < 0 || pos.x > width || pos.y < 0 || pos.y > height) {
14.       arrows.remove(this);
15.     }
16.   }
17.  
18.   void display() {
19.     pushMatrix();
20.     translate(pos.x, pos.y);
21.     stroke(0);
22.     line(0, 0, vel.x, vel.y);
23.     popMatrix();
24.   }
25. }

target

1. class Target {
2.   PVector pos, vel;
3.   boolean remove;
4.   int diam;
5.   color c;
6.  
7.   Target(float x, float y, PVector vel, int diam) {
8.     pos = new PVector(x, y);
9.     this.vel = vel.get();
10.     this.diam = diam;
11.     c = color(random(200), random(200), random(200));
12.   }
13.  
14.   void update() {
15.     pos.add(vel);
16.     if (pos.x < -diam || pos.x > width+diam || pos.y < -diam || pos.y > height+diam || beenShot()) {
17.       targets.remove(this);
18.     }
19.   }
20.  
21.   void display() {
22.     noStroke();
23.     fill(c);
24.     ellipse(pos.x, pos.y, diam, diam);
25.   }
26.  
27.   boolean beenShot() {
28.     for (Arrow a : arrows) {
29.      if (pos.dist(a.pos) < diam/2) {
30.         score++; // add one for the global highscore
31.         return true;
32.       }
33.     }
34.     return false;
35.   }
36. }

totalDrops remains at zero, so the loop in draw() is empty.
You initialize the drops array, but you don't fill it. Add hearts to it to see them.

1. void setup() {
2.   size(500, 500);
3.   smooth();
4.  
5.   spikes = new Arrows[50];
6.   drops = new Heart[100]; // Create 100 spots in the array
7.   totalDrops = 5;
8.   for (int i = 0; i < totalDrops; i++) {
9.     drops[i] = new Heart();
10.   }
11. }

You still have to handle collisions. And why these big arrays? Perhaps ArrayList would be more appropriate, allowing easy add/remove of elements.

Why the 200 and 50? It is out of bounds, and it will check only one element of the array.
You pass a parameter and don't use it.
You must do a test like that, but comparing each heart against each arrow. So you need two nested loops.