Recherche d'un fichier pour une Chaîne et de retour de cette Chaîne si trouvé

Comment pouvez-vous rechercher dans un fichier txt pour une Chaîne qui les entrées de l'utilisateur et ensuite de retour à la Chaîne de la console. J'ai écrit un code qui ne fonctionne pas en dessous, mais j'espère que cela peut illustrer mon point de vue...

public static void main(String[] args) {
  searchforName();
}

   private static void searchForName() throws FileNotFoundException {
    File file = new File("leaders.txt");
    Scanner kb = new Scanner(System.in);
    Scanner input = new Scanner(file);

    System.out.println("Please enter the name you would like to search for: ");
    String name = kb.nextLine();


    while(input.hasNextLine()) {
        System.out.println(input.next(name));
    }
}

"Leaders.txt" fichier contient une liste de noms.

Vous avez besoin pour itérer sur chaque ligne du fichier (alors qu'il a tout) et de contrôler votre Chaîne dans chacune de ces lignes.
Vous êtes à la recherche pour certains de données dans cette ligne? Vous pouvez lire le fichier à la chaîne (si ce n'est pas trop gros) - par exemple, avec apache commune fileutils.

OriginalL'auteur lancer | 2013-03-22

io java java.util.scanner

11

Vous pouvez créer une salle de Scanner pour lire le fichier ligne par ligne et de faire un match de la sorte...
```
final Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
   final String lineFromFile = scanner.nextLine();
   if(lineFromFile.contains(name)) { 
       //a match!
       System.out.println("I found " +name+ " in file " +file.getName());
       break;
   }
}
```
En ce qui concerne si vous devez utiliser un Scanner ou un BufferedReader pour lire le fichier, lire ce réponse.

Pourquoi avez-vous fait de ces "final"? Je sais que la finale se rendre immuable par la suite, mais je me demandais si c'était nécessaire ou juste quelque chose que je devrais être dans l'habitude de le faire.
C'est une habitude et un bon. Lire Efficace Java

OriginalL'auteur Amir Afghani

Scanner est beaucoup trop lent. Exécutez le code suivant à, et de voir les différences. Cherché dans les 750 MO de fichiers, et BufferedReader est 10 fois plus rapide qu'un Scanner en moyenne.

package uk.co.planetbeyond.service.test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Date;
import java.util.HashSet;
import java.util.Scanner;
public class SearchTextInFile
{
public static void main(String[] args) throws IOException
{
//First write a file, with large number of entries
writeFile("/home/aqeel/temp/subscribers_files.csv");
long scannerSearchMillis = 0;
long brSearchMillis = 0;
int iterations = 5;
//Now search random strings five times, and see the time taken
for (int i = 0; i < iterations; i++)
{
String msisdn = String.valueOf(923000000000l + ((long) (Math.random() * 40000000)));
System.out.println("ITERATION " + i);
System.out.print("Search " + msisdn + " using scanner");
Date d1 = new Date();
searchUsingScanner("/home/aqeel/temp/subscribers_files.csv", msisdn);
Date d2 = new Date();
long millis = (d2.getTime() - d1.getTime());
scannerSearchMillis += millis;
System.out.println(" | " + (millis / 1000) + " Seconds");
System.out.println("==================================================================");
System.out.print("Search " + msisdn + " using buffered reader");
d1 = new Date();
searchUsingBufferedReader("/home/aqeel/temp/subscribers_files.csv", msisdn);
d2 = new Date();
millis = d2.getTime() - d1.getTime();
brSearchMillis += millis;
System.out.println(" | " + (millis / 1000) + " Seconds");
System.out.println("==================================================================");
System.out.println("==================================================================");
System.out.println("==================================================================");
System.out.println("==================================================================");
}
System.out.println("Average Search time using Scanner " + (scannerSearchMillis / (iterations * 1000.0)) + " Seconds");
System.out.println("Average Search time using BufferedReader " + (brSearchMillis / (iterations * 1000.0)) + " Seconds");
}
public static void writeFile(String path)
{
BufferedWriter csvWriter = null;
HashSet<Integer> additions = new HashSet<Integer>();
try
{
csvWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(path)));
for (int i = 0; i < 40000000; i++)
{
int addition = (int) (Math.random() * 40000000);
additions.add(addition);
if (i % 20000 == 0)
{
System.out.println("Entries written : " + i + " ------ Unique Entries: " + additions.size());
csvWriter.flush();
}
long msisdn = 923000000000l + addition;
csvWriter.write(String.valueOf(msisdn) + "|" + String.valueOf((int) (Math.random() * 131)) + "\r\n");
}
csvWriter.flush();
System.out.println("Unique Entries written : " + additions.size());
}
catch (Exception e)
{
//TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if (csvWriter != null)
{
try
{
csvWriter.close();
}
catch (IOException e)
{
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public static String searchUsingScanner(String filePath, String searchQuery) throws FileNotFoundException
{
searchQuery = searchQuery.trim();
Scanner scanner = null;
try
{
scanner = new Scanner(new File(filePath));
while (scanner.hasNextLine())
{
String line = scanner.nextLine();
if (line.contains(searchQuery))
{
return line;
}
else
{
}
}
}
finally
{
try
{
if (scanner != null)
scanner.close();
}
catch (Exception e)
{
System.err.println("Exception while closing scanner " + e.toString());
}
}
return null;
}
public static String searchUsingBufferedReader(String filePath, String searchQuery) throws IOException
{
searchQuery = searchQuery.trim();
BufferedReader br = null;
try
{
br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
String line;
while ((line = br.readLine()) != null)
{
if (line.contains(searchQuery))
{
return line;
}
else
{
}
}
}
finally
{
try
{
if (br != null)
br.close();
}
catch (Exception e)
{
System.err.println("Exception while closing bufferedreader " + e.toString());
}
}
return null;
}
}

OriginalL'auteur Syed Aqeel Ashiq

La suite de Java 7+ solution a un avantage principal.

private static void searchForName() throws IOException {
System.out.println("Please enter the name you would like to search for: ");
Scanner kb = new Scanner(System.in);
String name = kb.nextLine();
List<String> lines = Files.readAllLines(Paths.get("leaders.txt"));
for (String line : lines) {
if (line.contains(name)) {
System.out.println(line);
}
}
}

Il n'est pas plus courte que le code de cette réponse. Le point principal est que, quand nous ouvrons un File nous avons une ressource ouverte et nous devons nous préoccuper de clôture. Sinon, il peut poser un problème de fuite de ressources.

De Java 7 la try-with-resources déclaration poignées de fermeture de ressources. Donc l'ouverture d'un Scanner soutenu par un fichier devrait ressembler à ça:

try (Scanner scanner = new Scanner("leaders.txt")) {
//using scanner
}

À l'aide de Files.readAllLines nous n'avons pas besoin de se soucier de la fermeture du fichier, puisque cette méthode (JavaDoc)

assure que le fichier est fermé lorsque tous les octets ont été lus ou un
I/O erreur, ou d'autres runtime exception est levée.

Si le premier occourance d'un String est nécessaire que, à la suite de Java 8+ code fait le travail en quelques lignes:

protected static Optional<String> searchForName(String name) throws IOException {
try (Stream<String> lines = Files.lines(Paths.get("leaders.txt"))) {
return lines.filter(line -> line.contains(name)).findFirst();
}
}

Elle renvoie un Optional indiquant qu'il pourrait y avoir un résultat vide. Nous l'utilisons par exemple comme suit:

private static void searchForName() throws IOException {
System.out.println("Please enter the name you would like to search for: ");
Scanner kb = new Scanner(System.in);
String name = kb.nextLine();
Optional<String> result = searchForName(name);
result.ifPresent(System.out::println);
}

OriginalL'auteur LuCio

Vous devez vous connecter pour publier un commentaire.