Cómo leer realmente un archivo de texto de classpath en Java


366

Estoy tratando de leer un archivo de texto que se establece en la variable de sistema CLASSPATH. No es una variable de usuario.

Estoy tratando de obtener la secuencia de entrada al archivo de la siguiente manera:

Coloque el directorio de archivo ( D:\myDir) en CLASSPATH e intente a continuación:

InputStream in = this.getClass().getClassLoader().getResourceAsStream("SomeTextFile.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("/SomeTextFile.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("//SomeTextFile.txt");

Coloque la ruta completa del archivo ( D:\myDir\SomeTextFile.txt) en CLASSPATH e intente lo mismo arriba de las 3 líneas de código.

Pero desafortunadamente NINGUNO de ellos está funcionando y siempre estoy nullingresando a mi InputStream in.

Respuestas:


605

Con el directorio en el classpath, desde una clase cargada por el mismo cargador de clases, debería poder usar cualquiera de:

// From ClassLoader, all paths are "absolute" already - there's no context
// from which they could be relative. Therefore you don't need a leading slash.
InputStream in = this.getClass().getClassLoader()
                                .getResourceAsStream("SomeTextFile.txt");
// From Class, the path is relative to the package of the class unless
// you include a leading slash, so if you don't want to use the current
// package, include a slash like this:
InputStream in = this.getClass().getResourceAsStream("/SomeTextFile.txt");

Si esos no funcionan, eso sugiere que algo más está mal.

Entonces, por ejemplo, tome este código:

package dummy;

import java.io.*;

public class Test
{
    public static void main(String[] args)
    {
        InputStream stream = Test.class.getResourceAsStream("/SomeTextFile.txt");
        System.out.println(stream != null);
        stream = Test.class.getClassLoader().getResourceAsStream("SomeTextFile.txt");
        System.out.println(stream != null);
    }
}

Y esta estructura de directorios:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

Y luego (usando el separador de ruta Unix ya que estoy en una caja de Linux):

java -classpath code:txt dummy.Test

Resultados:

true
true

2
Mezclaste caminos relativos y absolutos. Una ruta que comienza con "/" es absoluta (es decir, comienza desde lo que aparece en CLASSPATH). Todas las demás rutas son relativas al paquete de la clase a la que llamagetResourceAsStream()
Aaron Digulla el

13
No, rompiste mi ejemplo. Editaré los comentarios para que sean más claros, pero el punto es que al usar ClassLoader, se supone que todas las rutas ya son absolutas. No hay nada con lo que puedan ser relativos.
Jon Skeet

66
Tampoco use Java.IO.File.Separator. No funcionará en Windows. Si está ejecutando este código en Windows, aún debe ser '/' y no '\'
Pradhan

28
@Pradhan: No, no deberías estar usando File.Separator, porque no estás pidiendo un archivo , estás pidiendo un recurso . Es importante comprender que la abstracción involucrada no es el sistema de archivos.
Jon Skeet

1
@jagdpanzer: Bueno, es solo para clases que están cargadas por el mismo cargador de clases, básicamente, y es porque Class.getResourceAsStreames realmente un método conveniente para llamar ClassLoader.getResourceAsStream, pero con la característica adicional de recursos "relativos". Si está especificando un recurso absoluto, cualquier llamada que use el mismo cargador de clases hará lo mismo.
Jon Skeet

115

Cuando use Spring Framework (ya sea como una colección de utilidades o contenedor, no necesita usar esta última funcionalidad) puede usar fácilmente la abstracción de recursos .

Resource resource = new ClassPathResource("com/example/Foo.class");

A través de la interfaz de Recursos puede acceder al recurso como InputStream , URL , URI o Archivo . Cambiar el tipo de recurso a, por ejemplo, un recurso del sistema de archivos es una simple cuestión de cambiar la instancia.


66
¿Podría proporcionar un código de muestra sobre cómo se puede usar esto en el archivo de E / S? No puedo encontrar una manera decente , explícita y directa sobre cómo usarlo en Internet: ((((

Funciona de maravilla. El único forro provisto es todo lo que necesita. Utilice el análisis de la secuencia de otros ejemplos si no sabe cómo obtener una cadena de la secuencia.
Joseph Lust

Tuve algunos problemas para averiguar exactamente qué hacer con la variable de recursos también. He editado la respuesta con un poco más de detalle
DavidZemon

Ya estaba usando Spring y probando el modo "Java puro". Me estaba matando, las diferencias entre getResource, getResourceAsStream, etc., sin buenos ejemplos de trabajo. Este es un ejemplo perfecto de encapsulación, por lo que no me tiene que importar.
TinkerTenorSoftwareGuy

1
Tenga cuidado, si empaqueta su proyecto en un jar, debe usar un InputStream. Si usa un archivo, funciona en su IDE, pero fallará si lo prueba desde el jar. Si realmente necesita un archivo, intente con stackoverflow.com/questions/4317035/…
Rafael Membrives

58

Así es como leo todas las líneas de un archivo de texto en mi classpath, usando Java 7 NIO:

...
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;

...

Files.readAllLines(
    Paths.get(this.getClass().getResource("res.txt").toURI()), Charset.defaultCharset());

Nota: este es un ejemplo de cómo se puede hacer. Tendrás que hacer mejoras según sea necesario. Este ejemplo solo funcionará si el archivo está realmente presente en su classpath; de lo contrario, se generará una NullPointerException cuando getResource () devuelve nulo y se invoca .toURI () en él.

Además, desde Java 7, una forma conveniente de especificar conjuntos de caracteres es usar las constantes definidas en java.nio.charset.StandardCharsets (estas son, de acuerdo con sus javadocs , "están garantizados para estar disponibles en cada implementación de la plataforma Java").

Por lo tanto, si sabe que la codificación del archivo es UTF-8, especifique explícitamente el juego de caracteres StandardCharsets.UTF_8


1
Gracias por la solución NIO, por lo que pocas personas usan esta gran API, es una pena.
mvreijn

77
Para leer en un solo intento de cadena. nueva Cadena (Files.readAllBytes (Paths.get (MyClass.class.getResource (resource) .toURI ())));
Theo Briscoe

2
La mejor solución para mí, ya que no necesita dependencias, como Spring o Commons IO.
Bernie

1
Esto fallará si su archivo de recursos está dentro de un jar, por ejemplo, un módulo maven. En ese caso deberás usar algo como Spring's StreamUtils.copyToString.
Somu

26

Por favor, inténtalo

InputStream in = this.getClass().getResourceAsStream("/SomeTextFile.txt");

Sus intentos no funcionaron porque solo el cargador de clases para sus clases puede cargarse desde el classpath. Usó el cargador de clases para el sistema java mismo.


Aunque no estoy seguro acerca de la "/". Una ruta relativa podría funcionar mejor en este caso.
VonC

3
Si lo usa sin "/", está buscando su archivo dentro del paquete de "this".
tangens

1
Archivo InputStream = this.getClass (). GetResourceAsStream ("SomeTextFile.txt"); Archivo InputStream = this.getClass (). GetResourceAsStream ("/ SomeTextFile.txt"); InputStream file = this.getClass (). GetResourceAsStream ("// SomeTextFile.txt"); Ninguno de los anteriores funcionó :(
Chaitanya MSV

@Chaitanya: ¿Puedes ejecutar el ejemplo de la respuesta de John Skeet?
Aaron Digulla


20

Para leer realmente el contenido del archivo, me gusta usar Commons IO + Spring Core. Suponiendo Java 8:

try (InputStream stream = new ClassPathResource("package/resource").getInputStream()) {
    IOUtils.toString(stream);
}

Alternativamente:

InputStream stream = null;
try {
    stream = new ClassPathResource("/log4j.xml").getInputStream();
    IOUtils.toString(stream);
} finally {
    IOUtils.closeQuietly(stream);
}

¿Qué hay de cerrar el flujo de entrada?
Stephan

La transmisión se cerrará automáticamente. Es una característica de Java 7 "Probar con recursos" docs.oracle.com/javase/tutorial/essential/exceptions/…
Michał Maciej Gałuszka

Solo si está dentro de la instrucción try, que no es el caso aquí. Debería haber sido intentado (flujo de InputStream final = nueva ClassPathResource ("/ log4j.xml"). GetInputStream ()) {...
andresp

15

Para obtener la ruta absoluta de clase intente esto:

String url = this.getClass().getResource("").getPath();

¿Y entonces que? Esa información no sirve de nada en sí misma.
Marqués de Lorne

Esta información fue perfecta. ¡Solo me faltaba getPath ()!
Patrick

@Patrick Esta respuesta no proporciona la 'ruta absoluta de clase'. Proporciona una URL. Para nada lo mismo.
Marqués de Lorne

12

De alguna manera, la mejor respuesta no funciona para mí. Necesito usar un código ligeramente diferente en su lugar.

ClassLoader loader = Thread.currentThread().getContextClassLoader();
InputStream is = loader.getResourceAsStream("SomeTextFile.txt");

Espero que esto ayude a aquellos que enfrentan el mismo problema.


Esto también me ayudó en Android, donde el cargador de aplicaciones cargó una clase, pero una clave que necesitaba era una carga lenta en el hilo de la interfaz de usuario.
asokan

Debe proporcionar información sobre por qué la mejor respuesta no funciona para usted (por ejemplo, la estructura de su aplicación, el marco que está utilizando, el error, etc.). La mejor respuesta dice claramente que 1) el directorio debe estar en classpath, 2) debe solicitar a una clase cargada por el mismo cargador de clases. Lo más probable es que uno de estos supuestos no sea válido para su aplicación. Además, el cargador de clases de contexto está muy desaconsejado, ya que se introdujo como un hack. Algunos marcos lo utilizan, pero es importante conocer las implicaciones (que requieren que describa los antecedentes de su proyecto)
Xinchao

6

Si usas guayaba:

import com.google.common.io.Resources;

podemos obtener URL de CLASSPATH:

URL resource = Resources.getResource("test.txt");
String file = resource.getFile();   // get file path 

o InputStream:

InputStream is = Resources.getResource("test.txt").openStream();

La ruta del archivo no sirve de nada si el recurso está en un archivo JAR o WAR.
Marqués de Lorne

El método getFile de URL no devuelve un nombre de archivo. Simplemente devuelve la porción de ruta de la URL, que no se garantiza que sea un nombre de archivo válido. (La clase de URL era parte de Java 1.0; en aquel entonces, la mayoría de las URL de hecho se referían a archivos físicos en la misma computadora o en una computadora diferente.)
VGR

3

Para leer el contenido de un archivo en una Cadena desde classpath, puede usar esto:

private String resourceToString(String filePath) throws IOException, URISyntaxException
{
    try (InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(filePath))
    {
        return IOUtils.toString(inputStream);
    }
}

Nota:
IOUtilses parte de Commons IO.

Llámalo así:

String fileContents = resourceToString("ImOnTheClasspath.txt");

1

Usted dice "Estoy tratando de leer un archivo de texto que está configurado en la variable de sistema CLASSPATH". Supongo que esto está en Windows y está utilizando este diálogo feo para editar las "Variables del sistema".

Ahora ejecuta su programa Java en la consola. Y eso no funciona: la consola obtiene una copia de los valores de las variables del sistema una vez que se inicia . Esto significa cualquier cambio en el diálogo posterior no tiene ningún efecto.

Existen estas soluciones:

  1. Inicie una nueva consola después de cada cambio.

  2. Use set CLASSPATH=...en la consola para configurar la copia de la variable en la consola y cuando su código funcione, pegue el último valor en el cuadro de diálogo de la variable.

  3. Ponga la llamada a Java en el .BATarchivo y haga doble clic en él. Esto creará una nueva consola cada vez (copiando así el valor actual de la variable del sistema).

CUIDADO: si también tiene una variable de usuario, CLASSPATHentonces sombreará la variable de su sistema. Es por eso que generalmente es mejor poner la llamada a su programa Java en un .BATarchivo y establecer la ruta de clase allí (usando set CLASSPATH=) en lugar de confiar en un sistema global o variable de usuario.

Esto también asegura que pueda tener más de un programa Java trabajando en su computadora porque seguramente tendrán diferentes classpaths.


0

Mi respuesta no es exactamente lo que se pregunta en la pregunta. Más bien, estoy dando una solución exactamente con qué facilidad podemos leer un archivo en nuestra aplicación Java desde nuestra ruta de clase de proyecto.

Por ejemplo, suponga que un nombre de archivo de configuración example.xml se encuentra en una ruta como la siguiente:

com.myproject.config.dev

y nuestro archivo de clase ejecutable de Java está en la ruta a continuación:

com.myproject.server.main

ahora solo marque en la ruta anterior, que es el directorio / carpeta común más cercano desde donde puede acceder tanto a dev como al directorio / carpeta principal (com.myproject.server.main, donde existe la clase ejecutable java de nuestra aplicación) - Podemos ver que es myproject folder / directory que es el directorio / carpeta común más cercano desde donde podemos acceder a nuestro archivo example.xml. Por lo tanto, desde una clase ejecutable de Java que reside en la carpeta / directorio principal , tenemos que retroceder dos pasos como ../../ para acceder a myproject . Ahora, siguiendo esto, vea cómo podemos leer el archivo:

package com.myproject.server.main;

class Example {

  File xmlFile;

  public Example(){
       String filePath = this.getClass().getResource("../../config/dev/example.xml").getPath();
       this.xmlFile = new File(filePath);
    }

  public File getXMLFile() {
      return this.xmlFile;
  }
   public static void main(String args[]){
      Example ex = new Example();
      File xmlFile = ex.getXMLFile();
   }
}

0

Si compila su proyecto en un archivo jar: puede colocar su archivo en resources / files / your_file.text o pdf;

y usa este código:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;

public class readFileService(){
    private static final Logger LOGGER = LoggerFactory.getLogger(readFileService.class);


    public byte[] getFile(){
        String filePath="/files/your_file";
        InputStream inputStreamFile;
        byte[] bytes;
        try{
            inputStreamFile = this.getClass().getResourceAsStream(filePath);
            bytes = new byte[inputStreamFile.available()];
            inputStreamFile.read(bytes);    
        } catch(NullPointerException | IOException e) {
            LOGGER.error("Erreur read file "+filePath+" error message :" +e.getMessage());
            return null;
        }
        return bytes;
    } 
}

-1

Estoy usando el servidor de aplicaciones webshpere y mi módulo web está construido en Spring MVC. Se Test.propertiesubicaron en la carpeta de recursos, intenté cargar estos archivos usando lo siguiente:

  1. this.getClass().getClassLoader().getResourceAsStream("Test.properties");
  2. this.getClass().getResourceAsStream("/Test.properties");

Ninguno de los códigos anteriores cargó el archivo.

Pero con la ayuda del siguiente código, el archivo de propiedades se cargó correctamente:

Thread.currentThread().getContextClassLoader().getResourceAsStream("Test.properties");

Gracias al usuario "user1695166" .


1
¡Bienvenido a Stack Overflow! No agregue "gracias" como respuestas, incluso si también proporciona parcialmente cómo fue su solución, si sus soluciones son las mismas que en otra publicación, no es necesario agregarlas. Después de haber invertido algo de tiempo en el sitio, obtendrá los privilegios suficientes para votar las respuestas que desee, que es la forma en que Stack Overflow dice gracias.
SuperBiasedMan

-1

Utilizar org.apache.commons.io.FileUtils.readFileToString(new File("src/test/resources/sample-data/fileName.txt"));


la referencia a src no debe usarse ... No funciona en el artefacto final.
L. Holanda

-1

Guión:

1) client-service-1.0-SNAPSHOT.jartiene dependenciaread-classpath-resource-1.0-SNAPSHOT.jar

2) queremos leer el contenido de los recursos de ruta de clase ( sample.txt) de read-classpath-resource-1.0-SNAPSHOT.jarthrough client-service-1.0-SNAPSHOT.jar.

3) read-classpath-resource-1.0-SNAPSHOT.jartienesrc/main/resources/sample.txt

Aquí está el código de muestra que preparé, después de 2-3 días perdiendo mi tiempo de desarrollo, encontré la solución completa de principio a fin, espero que esto ayude a ahorrar tiempo

1. pom.xmlderead-classpath-resource-1.0-SNAPSHOT.jar

<?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>
            <groupId>jar-classpath-resource</groupId>
            <artifactId>read-classpath-resource</artifactId>
            <version>1.0-SNAPSHOT</version>
            <name>classpath-test</name>
            <properties>
                <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                <org.springframework.version>4.3.3.RELEASE</org.springframework.version>
                <mvn.release.plugin>2.5.1</mvn.release.plugin>
                <output.path>${project.artifactId}</output.path>
                <io.dropwizard.version>1.0.3</io.dropwizard.version>
                <commons-io.verion>2.4</commons-io.verion>
            </properties>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                    <version>${org.springframework.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>${org.springframework.version}</version>
                </dependency>
                <dependency>
                    <groupId>commons-io</groupId>
                    <artifactId>commons-io</artifactId>
                    <version>${commons-io.verion}</version>
                </dependency>
            </dependencies>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources</directory>
                    </resource>
                </resources>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-release-plugin</artifactId>
                        <version>${mvn.release.plugin}</version>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.1</version>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                            <encoding>UTF-8</encoding>
                        </configuration>
                    </plugin>
                    <plugin>
                        <artifactId>maven-jar-plugin</artifactId>
                        <version>2.5</version>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <archive>
                                <manifest>
                                    <addClasspath>true</addClasspath>
                                    <useUniqueVersions>false</useUniqueVersions>
                                    <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                                    <mainClass>demo.read.classpath.resources.ClassPathResourceReadTest</mainClass>
                                </manifest>
                                <manifestEntries>
                                    <Implementation-Artifact-Id>${project.artifactId}</Implementation-Artifact-Id>
                                    <Class-Path>sample.txt</Class-Path>
                                </manifestEntries>
                            </archive>
                        </configuration>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-shade-plugin</artifactId>
                        <version>2.2</version>
                        <configuration>
                            <createDependencyReducedPom>false</createDependencyReducedPom>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                        <executions>
                            <execution>
                                <phase>package</phase>
                                <goals>
                                    <goal>shade</goal>
                                </goals>
                                <configuration>
                                    <transformers>
                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                            <mainClass>demo.read.classpath.resources.ClassPathResourceReadTest</mainClass>
                                        </transformer>
                                    </transformers>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </project>

2)ClassPathResourceReadTest.java clase en read-classpath-resource-1.0-SNAPSHOT.jarque carga el contenido del archivo de recursos de ruta de clase.

package demo.read.classpath.resources;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public final class ClassPathResourceReadTest {
    public ClassPathResourceReadTest() throws IOException {
        InputStream inputStream = getClass().getResourceAsStream("/sample.txt");
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        List<Object> list = new ArrayList<>();
        String line;
        while ((line = reader.readLine()) != null) {
            list.add(line);
        }
        for (Object s1: list) {
            System.out.println("@@@ " +s1);
        }
        System.out.println("getClass().getResourceAsStream('/sample.txt') lines: "+list.size());
    }
}

3. pom.xmldeclient-service-1.0-SNAPSHOT.jar

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>client-service</groupId>
    <artifactId>client-service</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>jar-classpath-resource</groupId>
            <artifactId>read-classpath-resource</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <useUniqueVersions>false</useUniqueVersions>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                            <mainClass>com.crazy.issue.client.AccessClassPathResource</mainClass>
                        </manifest>
                        <manifestEntries>
                            <Implementation-Artifact-Id>${project.artifactId}</Implementation-Artifact-Id>
                            <Implementation-Source-SHA>${buildNumber}</Implementation-Source-SHA>
                            <Class-Path>sample.txt</Class-Path>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.crazy.issue.client.AccessClassPathResource</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

4. AccessClassPathResource.javainstanciarClassPathResourceReadTest.java clase donde, se va a cargar sample.txte imprime su contenido también.

package com.crazy.issue.client;

import demo.read.classpath.resources.ClassPathResourceReadTest;
import java.io.IOException;

public class AccessClassPathResource {
    public static void main(String[] args) throws IOException {
        ClassPathResourceReadTest test = new ClassPathResourceReadTest();
    }
}

5. Ejecute jar ejecutable de la siguiente manera:

[ravibeli@localhost lib]$ java -jar client-service-1.0-SNAPSHOT.jar
****************************************
I am in resources directory of read-classpath-resource-1.0-SNAPSHOT.jar
****************************************
3) getClass().getResourceAsStream('/sample.txt'): 3

-2

No use el método getClassLoader () y use "/" antes del nombre del archivo. "/" es muy importante

this.getClass().getResourceAsStream("/SomeTextFile.txt");

Usar el líder /tiene exactamente el mismo efecto que usar el getClassLoader()método.
Marqués de Lorne

-4
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile

{
    /**
     * * feel free to make any modification I have have been here so I feel you
     * * * @param args * @throws InterruptedException
     */

    public static void main(String[] args) throws InterruptedException {
        // thread pool of 10
        File dir = new File(".");
        // read file from same directory as source //
        if (dir.isDirectory()) {
            File[] files = dir.listFiles();
            for (File file : files) {
                // if you wanna read file name with txt files
                if (file.getName().contains("txt")) {
                    System.out.println(file.getName());
                }

                // if you want to open text file and read each line then
                if (file.getName().contains("txt")) {
                    try {
                        // FileReader reads text files in the default encoding.
                        FileReader fileReader = new FileReader(
                                file.getAbsolutePath());
                        // Always wrap FileReader in BufferedReader.
                        BufferedReader bufferedReader = new BufferedReader(
                                fileReader);
                        String line;
                        // get file details and get info you need.
                        while ((line = bufferedReader.readLine()) != null) {
                            System.out.println(line);
                            // here you can say...
                            // System.out.println(line.substring(0, 10)); this
                            // prints from 0 to 10 indext
                        }
                    } catch (FileNotFoundException ex) {
                        System.out.println("Unable to open file '"
                                + file.getName() + "'");
                    } catch (IOException ex) {
                        System.out.println("Error reading file '"
                                + file.getName() + "'");
                        // Or we could just do this:
                        ex.printStackTrace();
                    }
                }
            }
        }

    }

}

No responde la pregunta de ninguna manera.
Marqués de Lorne

-5

tienes que poner tu 'variable de sistema' en el classpath de Java.


Puse la variable del sistema en sí.
Chaitanya MSV

La 'variable del sistema' es la CLASSPATH de Java. La respuesta no tiene sentido.
Marqués de Lorne

Totalmente cierto ... ni siquiera recordaba haber escrito esta respuesta :)
Salandur
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.