Hey, Edson, it's getting difficult to follow your questions, because pieces of your question are spread all over this conversation. Also, please use the codeblock formatting for your code instead of text. When you're posting your question look for the little icon that looks kinda like <>. Or just use 4 spaces after a blank line to initiate a codeblock. And make sure you paste in your actual code. If you do this, then we can copy-paste your code and be confident that we're replicating your actual situation. Also, it would really help if you'd provide all of the relevant code. I don't know how you defined F in this latest post. Maybe it's somewhere else in this conversation, but that just means it's effectively lost. And really, at this point, it's probably better to just start a whole new conversation. The initial question has been answered (I think), so you're now asking a completely different question, but nobody looking at this site knows that unless they've been following all the details. So, you're not likely to get any more "eyes" on this problem.

Hi, everyone! I found that Tuples[{{a,b},{c,d,e}}] does what I want. Is there another form of pairing up elements in Wolfram? Thank you.

I did this and it worked!!!!! Wowwww!

TestQf[Qf_]:= Which[0.06<=Qf<=0.6,Return[0.003],
             0.6<Qf<=8,Return[0.04],
              8<Qf<=40,Return[0.2]]
Map[TestQf, Qf]

I am proud of myself!!!
Do you guys have another idea to solve the same problem, please share with me. Thank you.

In general, the use of Table is more concise than using For. Example:

(* Function and loop parameters *)
F[x_,y_]:=x+10*y
x0=2;
xf=12;
deltax=3;

(* For *)
w={};
For[x=x0,x<=xf,x+=deltax,s=SolveValues[F[x,y]==0,y];AppendTo[w,s]]
w
(* {{-(1/5)}, {-(1/2)}, {-(4/5)}, {-(11/10)}} *)

(* Table *)
Table[SolveValues[F[x,y]==0,y],{x,x0,xf,deltax}]
(* {{-(1/5)}, {-(1/2)}, {-(4/5)}, {-(11/10)}} *)

Then, to get a list of x,y pairs:

Table[{x,First@SolveValues[F[x,y]==0,y]},{x,x0,xf,deltax}]
(* {{2, -(1/5)}, {5, -(1/2)}, {8, -(4/5)}, {11, -(11/10)}} *)

Using Outer:

L1 = {x1, x2};
L2 = {y1, y2, y3};
Outer[F, L1, L2] // Flatten

(* {F[x1,y1],F[x1,y2],F[x1,y3],F[x2,y1],F[x2,y2],F[x2,y3]} *)

How does this relate to your original question?

Let's examine your Table expression:

tb1 = Table[{h1[[i]], h2[[i]]}, {i, n1}]

So, you have two lists, h1 and h2, and you want to pair them up. There are other ways to do this that are more idiomatic to Mathematica. I'll manufacture some lists to illustrate:

h1 = {1, 3, 5, 7};
h2 = {"a", "b", "c", "d"};
Transpose[{h1, h2}]
(* {{1, "a"}, {3, "b"}, {5, "c"}, {7, "d"}} *)

In general, you can probably find a Mathematica function that deals with the lists as lists rather by indexing into each list. There are various ways to thread through them or re-structure them or map over them or operate on them element-wise and so on and so forth.

You used For when it would be more natural to use Table (or some other table-like function, and see my other comment about replacing Table with Transpose). Let's say can specify your sample points with an iteration expression and you want to apply a function to those points:

Table[myFunction[i], {i, 0.1, 0.3, 0.05}]
(* {myFunction[0.1], myFunction[0.15], myFunction[0.2], myFunction[0.25], myFunction[0.3]} *)

Array[myFunction, 5, {0.1, 0.3}]
(* {myFunction[0.1], myFunction[0.15], myFunction[0.2], myFunction[0.25], myFunction[0.3]} *)

Or let's say you have the sample points in a list, then you can just map over the list:

samplePointsFromSomewhere = Range[.1, .3, .05];
myFunction /@ samplePointsFromSomewhere
(* {myFunction[0.1], myFunction[0.15], myFunction[0.2], myFunction[0.25], myFunction[0.3]} *)

Now, for the specific case of h2 where you just need to generate those sample points, you did this:

h2 = {};
For[jf = 0.001, jf <= 0.30, jf += 0.00005, s = jf; AppendTo[h2, s]];

But it would be much clearer and cleaner (and probably faster) to do this:

h2 = Range[.001, .3, .00005];

DataRange is used to re-scale the horizontal axis. If you want to extend it, use PlotRange.

tb3 = Table[{i, i^2}, {i, 10}];  (* You don't need all of the indirection you had before. *)
L1 = {{15, 40}};    (* Using List explicitly is fine, but not necessary, just use curly braces. *)
ListPlot[{tb3, L1}, PlotRange -> {{0, 20}, Automatic}]

Eric, Mathematica fascinates me as much as your good explanation! Thank you very much.