Datei aus Assets lesen

public class Utils {
    public static List<Message> getMessages() {
        //File file = new File("file:///android_asset/helloworld.txt");
        AssetManager assetManager = getAssets();
        InputStream ims = assetManager.open("helloworld.txt");    
     }
}

Ich verwende diesen Code, um eine Datei aus Assets zu lesen. Ich habe zwei Möglichkeiten ausprobiert, dies zu tun. Erstens, wenn die Verwendung, die Fileich erhalten habe FileNotFoundException, wenn die Verwendung der AssetManager getAssets()Methode nicht erkannt wird. Gibt es hier eine Lösung?

Hier ist, was ich in einer Aktivität zum gepufferten Lesen mache, erweitern / modifizieren, um es Ihren Bedürfnissen anzupassen

BufferedReader reader = null;
try {
    reader = new BufferedReader(
        new InputStreamReader(getAssets().open("filename.txt")));

    // do reading, usually loop until end of file reading  
    String mLine;
    while ((mLine = reader.readLine()) != null) {
       //process line
       ...
    }
} catch (IOException e) {
    //log the exception
} finally {
    if (reader != null) {
         try {
             reader.close();
         } catch (IOException e) {
             //log the exception
         }
    }
}

EDIT: Meine Antwort ist vielleicht nutzlos, wenn Ihre Frage lautet, wie es außerhalb einer Aktivität gemacht werden soll. Wenn Ihre Frage einfach ist, wie man eine Datei aus einem Asset liest, ist die Antwort oben.

AKTUALISIEREN :

Um eine Datei mit dem Typ zu öffnen, fügen Sie den Typ einfach wie folgt in den InputStreamReader-Aufruf ein.

BufferedReader reader = null;
try {
    reader = new BufferedReader(
        new InputStreamReader(getAssets().open("filename.txt"), "UTF-8")); 

    // do reading, usually loop until end of file reading 
    String mLine;
    while ((mLine = reader.readLine()) != null) {
       //process line
       ...
    }
} catch (IOException e) {
    //log the exception
} finally {
    if (reader != null) {
         try {
             reader.close();
         } catch (IOException e) {
             //log the exception
         }
    }
}

BEARBEITEN

Wie @Stan im Kommentar sagt, summiert der Code, den ich gebe, keine Zeilen. mLinewird bei jedem Durchgang ersetzt. Deshalb habe ich geschrieben//process line . Ich gehe davon aus, dass die Datei irgendeine Art von Daten enthält (dh eine Kontaktliste) und jede Zeile separat verarbeitet werden sollte.

Wenn Sie die Datei einfach ohne jegliche Verarbeitung laden möchten, müssen Sie sie mLinebei jedem Durchgang mit jedem Durchgang zusammenfassen StringBuilder()und anhängen.

Noch eine Bearbeitung

Nach dem Kommentar von @Vincent habe ich das hinzugefügt finally Block .

Beachten Sie auch, dass Sie in Java 7 und höher try-with-resourcesdie Funktionen AutoCloseableund CloseableFunktionen des aktuellen Java verwenden können.

KONTEXT

In einem Kommentar weist @LunarWatcher darauf hin, dass getAssets()es sich um ein classIn handelt context. Wenn Sie es also außerhalb von a aufrufen, activitymüssen Sie darauf verweisen und die Kontextinstanz an die Aktivität übergeben.

ContextInstance.getAssets();

Dies wird in der Antwort von @Maneesh erklärt. Wenn dies für Sie nützlich ist, stimmen Sie seiner Antwort zu, denn das ist er, der darauf hingewiesen hat.

getAssets()

funktioniert nur in Aktivität in einer anderen Klasse, die Sie dafür verwenden müssen Context.

Mach ein Konstruktor für die Utils- Klasse als Referenz für die Aktivität (hässlicher Weg) oder den Kontext der Anwendung als Parameter. Verwenden Sie dazu getAsset () in Ihrer Utils-Klasse.

Besser spät als nie.

Unter bestimmten Umständen hatte ich Schwierigkeiten, Dateien Zeile für Zeile zu lesen. Die folgende Methode ist die beste, die ich bisher gefunden habe, und ich empfehle sie.

Verwendung: String yourData = LoadData("YourDataFile.txt");

Wo angenommen wird, dass sich YourDataFile.txt in Assets befindet /

 public String LoadData(String inFile) {
        String tContents = "";

    try {
        InputStream stream = getAssets().open(inFile);

        int size = stream.available();
        byte[] buffer = new byte[size];
        stream.read(buffer);
        stream.close();
        tContents = new String(buffer);
    } catch (IOException e) {
        // Handle exceptions here
    }

    return tContents;

 }

public String ReadFromfile(String fileName, Context context) {
    StringBuilder returnString = new StringBuilder();
    InputStream fIn = null;
    InputStreamReader isr = null;
    BufferedReader input = null;
    try {
        fIn = context.getResources().getAssets()
                .open(fileName, Context.MODE_WORLD_READABLE);
        isr = new InputStreamReader(fIn);
        input = new BufferedReader(isr);
        String line = "";
        while ((line = input.readLine()) != null) {
            returnString.append(line);
        }
    } catch (Exception e) {
        e.getMessage();
    } finally {
        try {
            if (isr != null)
                isr.close();
            if (fIn != null)
                fIn.close();
            if (input != null)
                input.close();
        } catch (Exception e2) {
            e2.getMessage();
        }
    }
    return returnString.toString();
}

AssetManager assetManager = getAssets();
InputStream inputStream = null;
try {
    inputStream = assetManager.open("helloworld.txt");
}
catch (IOException e){
    Log.e("message: ",e.getMessage());
}

Einzeilige Lösung für Kotlin:

fun readFileText(fileName: String): String {
    return assets.open(fileName).bufferedReader().use { it.readText() }
}

getAssets() Die Methode funktioniert, wenn Sie innerhalb der Activity-Klasse aufrufen.

Wenn Sie diese Methode in einer Nicht-Aktivitätsklasse aufrufen, müssen Sie diese Methode aus dem Kontext aufrufen, der von der Aktivitätsklasse übergeben wird. Unten sehen Sie die Zeile, in der Sie auf die Methode zugreifen können.

ContextInstance.getAssets();

ContextInstance kann als dies der Aktivitätsklasse übergeben werden.

Das Lesen und Schreiben von Dateien war schon immer ausführlich und fehleranfällig. Vermeiden Sie diese Antworten und verwenden Sie stattdessen einfach Okio :

public void readLines(File file) throws IOException {
  try (BufferedSource source = Okio.buffer(Okio.source(file))) {
    for (String line; (line = source.readUtf8Line()) != null; ) {
      if (line.contains("square")) {
        System.out.println(line);
      }
    }
  }
}

Hier ist eine Methode zum Lesen einer Datei in Assets:

/**
 * Reads the text of an asset. Should not be run on the UI thread.
 * 
 * @param mgr
 *            The {@link AssetManager} obtained via {@link Context#getAssets()}
 * @param path
 *            The path to the asset.
 * @return The plain text of the asset
 */
public static String readAsset(AssetManager mgr, String path) {
    String contents = "";
    InputStream is = null;
    BufferedReader reader = null;
    try {
        is = mgr.open(path);
        reader = new BufferedReader(new InputStreamReader(is));
        contents = reader.readLine();
        String line = null;
        while ((line = reader.readLine()) != null) {
            contents += '\n' + line;
        }
    } catch (final Exception e) {
        e.printStackTrace();
    } finally {
        if (is != null) {
            try {
                is.close();
            } catch (IOException ignored) {
            }
        }
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException ignored) {
            }
        }
    }
    return contents;
}

Sie können den Inhalt aus der Datei laden. Angenommen, die Datei befindet sich im Asset-Ordner.

public static InputStream loadInputStreamFromAssetFile(Context context, String fileName){
    AssetManager am = context.getAssets();
    try {
        InputStream is = am.open(fileName);
        return is;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

public static String loadContentFromFile(Context context, String path){
    String content = null;
    try {
        InputStream is = loadInputStreamFromAssetFile(context, path);
        int size = is.available();
        byte[] buffer = new byte[size];
        is.read(buffer);
        is.close();
        content = new String(buffer, "UTF-8");
    } catch (IOException ex) {
        ex.printStackTrace();
        return null;
    }
    return content;
}

Jetzt können Sie den Inhalt abrufen, indem Sie die Funktion wie folgt aufrufen

String json= FileUtil.loadContentFromFile(context, "data.json");

Berücksichtigen Sie, dass die Datei data.json unter Application \ app \ src \ main \ assets \ data.json gespeichert ist

In MainActivity.java

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView tvView = (TextView) findViewById(R.id.tvView);

        AssetsReader assetsReader = new AssetsReader(this);
        if(assetsReader.getTxtFile(your_file_title)) != null)
        {
            tvView.setText(assetsReader.getTxtFile(your_file_title)));
        }
    }

Sie können auch eine separate Klasse erstellen, die die gesamte Arbeit erledigt

public class AssetsReader implements Readable{

    private static final String TAG = "AssetsReader";


    private AssetManager mAssetManager;
    private Activity mActivity;

    public AssetsReader(Activity activity) {
        this.mActivity = activity;
        mAssetManager = mActivity.getAssets();
    }

    @Override
    public String getTxtFile(String fileName)
    {
        BufferedReader reader = null;
        InputStream inputStream = null;
        StringBuilder builder = new StringBuilder();

        try{
            inputStream = mAssetManager.open(fileName);
            reader = new BufferedReader(new InputStreamReader(inputStream));

            String line;

            while((line = reader.readLine()) != null)
            {
                Log.i(TAG, line);
                builder.append(line);
                builder.append("\n");
            }
        } catch (IOException ioe){
            ioe.printStackTrace();
        } finally {

            if(inputStream != null)
            {
                try {
                    inputStream.close();
                } catch (IOException ioe){
                    ioe.printStackTrace();
                }
            }

            if(reader != null)
            {
                try {
                    reader.close();
                } catch (IOException ioe)
                {
                    ioe.printStackTrace();
                }
            }
        }
        Log.i(TAG, "builder.toString(): " + builder.toString());
        return builder.toString();
    }
}

Meiner Meinung nach ist es besser, eine Schnittstelle zu erstellen, aber es ist nicht notwendig

public interface Readable {
    /**
     * Reads txt file from assets
     * @param fileName
     * @return string
     */
    String getTxtFile(String fileName);
}

Wenn Sie eine andere Klasse als Aktivität verwenden, möchten Sie möglicherweise Folgendes tun:

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader( YourApplication.getInstance().getAssets().open("text.txt"), "UTF-8"));

Mit Kotlin können Sie Folgendes tun, um eine Datei aus Assets in Android zu lesen:

try {
    val inputStream:InputStream = assets.open("helloworld.txt")
    val inputString = inputStream.bufferedReader().use{it.readText()}
    Log.d(TAG,inputString)
} catch (e:Exception){
    Log.d(TAG, e.toString())
}

Es ist vielleicht zu spät, aber für andere, die nach pfirsichfarbenen Antworten suchen:

public static String loadAssetFile(Context context, String fileName) {
    try {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(context.getAssets().open(fileName)));
        StringBuilder out= new StringBuilder();
        String eachline = bufferedReader.readLine();
        while (eachline != null) {
            out.append(eachline);
            eachline = bufferedReader.readLine();
        }
        return out.toString();
    } catch (IOException e) {
        Log.e("Load Asset File",e.toString());
    }
    return null;
}

cityfile.txt

   public void getCityStateFromLocal() {
        AssetManager am = getAssets();
        InputStream inputStream = null;
        try {
            inputStream = am.open("city_state.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
        ObjectMapper mapper = new ObjectMapper();
        Map<String, String[]> map = new HashMap<String, String[]>();
        try {
            map = mapper.readValue(getStringFromInputStream(inputStream), new TypeReference<Map<String, String[]>>() {
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
        ConstantValues.arrayListStateName.clear();
        ConstantValues.arrayListCityByState.clear();
        if (map.size() > 0)
        {
            for (Map.Entry<String, String[]> e : map.entrySet()) {
                CityByState cityByState = new CityByState();
                String key = e.getKey();
                String[] value = e.getValue();
                ArrayList<String> s = new ArrayList<String>(Arrays.asList(value));
                ConstantValues.arrayListStateName.add(key);
                s.add(0,"Select City");
                cityByState.addValue(s);
                ConstantValues.arrayListCityByState.add(cityByState);
            }
        }
        ConstantValues.arrayListStateName.add(0,"Select States");
    }
 // Convert InputStream to String
    public String getStringFromInputStream(InputStream is) {
        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();
        String line;
        try {
            br = new BufferedReader(new InputStreamReader(is));
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return sb + "";

    }

Die Scannerklasse kann dies vereinfachen.

        StringBuilder sb=new StringBuilder();
        Scanner scanner=null;
        try {
            scanner=new Scanner(getAssets().open("text.txt"));
            while(scanner.hasNextLine()){
                sb.append(scanner.nextLine());
                sb.append('\n');
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(scanner!=null){try{scanner.close();}catch (Exception e){}}
        }
        mTextView.setText(sb.toString());

@ HPTerm Antwort Kotlin Version:

private fun getDataFromAssets(): String? {

    var bufferedReader: BufferedReader? = null
    var data: String? = null

    try {
        bufferedReader = BufferedReader(
            InputStreamReader(
                activity?.assets?.open("Your_FILE.html"),     
                "UTF-8"
            )
        )                  //use assets? directly if in activity

       var mLine:String = bufferedReader?.readLine()
        while (mLine != null) {
            data+= mLine
            mLine=bufferedReader.readLine()
        }

    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        try {
            bufferedReader?.close()
        } catch (e: Exception) {
           e.printStackTrace()
        }
    }
    return data
}

Hier ist ein Weg , eine bekommen InputStreamfür eine Datei im assetsOrdner ohne Context, Activity, Fragmentoder Application. Wie Sie die Daten daraus erhaltenInputStream liegt bei Ihnen. Es gibt viele Vorschläge dafür in anderen Antworten hier.

Kotlin

val inputStream = ClassLoader::class.java.classLoader?.getResourceAsStream("assets/your_file.ext")

Java

InputStream inputStream = ClassLoader.class.getClassLoader().getResourceAsStream("assets/your_file.ext");

Alle Wetten sind ungültig, wenn ein Brauch ClassLoaderim Spiel ist.