How do I find relavence documents against the query

I going through a project where I have to find the relevant document one by one against the query. First I calculated the TF, IDF for all the words of all documents. And then I multiplied the TF and IDF and store each term and its corresponding TF-IDF score for a particular document inside a List.here the class named Tfidf calculating TF and IDF

public double TF(String[] document, String term) {
double value = 0;                 //calculate Term Frequency for all term
for (String s : document) {
if (s.equalsIgnoreCase(term)) {
tfmap.put(s, tfmap.getOrDefault(term, 0) + 1);
for (Map.Entry entry : tfmap.entrySet()) {
value = (int) entry.getValue();
}
}
}
return value / document.length;
}
public double idf(List alldocument, String term) {
double b = alldocument.size();
double count = 0;
for (int i = 0; i < alldocument.size(); i++) {
String[] f = alldocument.get(i).toString().replaceAll("[^a-zA-Z0-9 ]", " ").trim().replaceAll(" +", " ").toLowerCase().split(" ");
for (String ss : f) {
if (ss.equalsIgnoreCase(term)) {
count++;
break;
}
}
}
return 1 + Math.log(b / count);
}}

here the code where I multiplied the TF and IDF

  List<String> alldocument= new ArrayList<>();
List tfidfVector = new ArrayList<>();
public void TfIdf() {
double tf;
double idf;
double tfidf = 0;
for (int i = 0; i < alldocument.size(); i++) {
double[] tfidfvector = new double[allterm.size()];  //allterm is all unique word in all documents
for (String terms : allterm) {
String[] file = alldocument.get(i).replaceAll("[^a-zA-Z0-9 ]", " ").trim().replaceAll(" +", " ").toLowerCase().split(" ");
int count = 0;
tf = new Tfidf().TF(file, terms);
idf = new Tfidf().idf(alldocument, terms);
tfidf = tf * idf;
tfidfvector[count] = tfidf;
count++;
}
tfidfVector.add(tfidfvector);            
}   
}

can anyone tell me how I Compute the TF-IDF vector for the query If my query is "life and learning"?and how can I calculate the cosine similarity of the query between all the Documents to find the similarity between the query and all the document?

The tf-idf score is used in conjunction with the cosine similarity between the query and a document. So you need to compute a dot product between two vectors. One vector represents the query "life and learning". The other vector represents one of the documents. To find the most relevant document, you need to calculate the cosine similarity with all of the documents (or ideally, only the ones that contain some of the words).
In the vector space model, each dimension of the vector represents one distinct word. So in this particular example, the only two relevant dimensions would be those representing "life", "and", "learning". Theoretically there are other dimensions corresponding to every other known word, but the score of those will be 0 in this case so they can be skipped over when calculating the cosine similarity.

There are several possible variations of exactly how to apply the weighting. But if we stick to the simplest...
You can consider the query vector to have <life:1, and:1 learning: 1>. And the document vector to have <word1: tf_word1/idf_word1, word2: tf_word2/idf_word2, ..., wordN: tf_wordN/idf_wordN>.
Then you just compute the dot product between these two vectors. For words not appearing in the query, you're just going to end up multiplying by 0 and adding it to the score, which means you can ignore all those words. So you only need to consider the terms in the query. For each term in the query, multiply the tf in the query (or even just 1 if desired) by the tf-idf score of that term in the document.

There are many possible weighting variations you can use. You've already talked about TF and IDF. I also see you've written some code to normalize the term frequency by the length of the document, which is also. To learn more, you can refer to this section of the Introduction to Information Retrieval Textbook: https://nlp.stanford.edu/IR-book/html/htmledition/document-and-query-weighting-schemes-1.html#sec:querydocweighting. (Although, it might be too dense without reading some of the earlier sections)

FYI, sepcifically regarding the code you've posted, you're currently storing them in an ArrayList, just indexed in order. Well, you have an issue where count is being reset to 0 every time through the loop, which doesn't seem right. But ignoring that, you will want an easy way to look up the tf-idf information for a specific term. A HashTable is more natural for that than an ArrayList.