varlıklardan dosyayı oku

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");    
     }
}

Bu kodu varlıklardan bir dosya okumaya çalışıyorum. Bunu yapmanın iki yolunu denedim. Birincisi, Filealdığım kullanım FileNotFoundException, AssetManager getAssets()yöntem kullanılırken tanınmıyor. Burada bir çözüm var mı?

Tampon okuma için bir aktivitede yaptığım şey, ihtiyaçlarınıza göre genişlet / değiştir

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
         }
    }
}

DÜZENLEME: Sorunuz bir etkinliğin dışında nasıl yapılacağı ile ilgiliyse cevabım belki işe yaramaz. Sorunuz basitçe öğeden bir dosyayı nasıl okuyacağınız ise cevap yukarıdadır.

GÜNCELLEME :

Türü belirten bir dosyayı açmak için türü aşağıdaki gibi InputStreamReader çağrısına ekleyin.

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
         }
    }
}

DÜZENLE

@Stan'ın yorumda söylediği gibi, verdiğim kod satırları özetlemiyor. mLineher geçişte değiştirilir. Bu yüzden yazdım //process line. Dosya bir tür veri (yani bir kişi listesi) içeriyor ve her satır ayrı ayrı işlenmesi gerektiğini varsayalım.

Dosyayı herhangi bir işlem yapmadan yüklemek istiyorsanız mLine, her geçişi kullanarak StringBuilder()ve her geçişte özetlemeniz gerekir .

BAŞKA BİR DÜZENLEME

@ Vincent yorumuna göre finallybloğu ekledim .

Ayrıca Java 7 ve üst sürümlerinde, en son Java'nın ve özelliklerini kullanmak try-with-resourcesiçin kullanabileceğinizi unutmayın .AutoCloseableCloseable

BAĞLAM

Bir yorumda @LunarWatcher getAssets()bunun classiçinde olduğuna dikkat çekiyor context. Yani, bunu bir dışında çağırırsanız, ona activitybaşvurmanız ve bağlam örneğini etkinliğe geçirmeniz gerekir.

ContextInstance.getAssets();

Bu @Maneesh cevabında açıklanmaktadır. Eğer bu sizin için faydalıysa cevabını onaylayın, çünkü bunu işaret eden oydu.

getAssets()

yalnızca bunun için kullanmanız gereken herhangi bir sınıftaki Etkinlik'te çalışır Context.

Bir yapmak Utils kurucu buna bir parametre olarak sınıf geçme aktivitesinin referans (çirkin bir şekilde) ya da uygulama bağlamında. Bunu kullanarak Utils sınıfınızda getAsset () kullanın.

Geç olsun güç olmasın.

Bazı durumlarda dosyaları satır satır okumakta zorlandım. Aşağıdaki yöntem şimdiye kadar bulduğum en iyisidir ve tavsiye ederim.

Kullanımı: String yourData = LoadData("YourDataFile.txt");

Nerede YourDataFile.txt ikamet varsayılır varlıklar /

 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());
}

kotlin için bir satır çözüm:

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

getAssets() yöntemi, Activity sınıfının içinde çağırdığınızda çalışır.

Bu yöntemi Activity olmayan sınıfta çağırıyorsanız, bu yöntemi Activity sınıfından geçirilen Context'ten çağırmanız gerekir. Bu nedenle, aşağıdaki yönteme erişebilirsiniz.

ContextInstance.getAssets();

ContextInstance Activity sınıfının bu haliyle iletilebilir.

Dosyaları okumak ve yazmak her zaman ayrıntılı ve hataya açık hale gelmiştir. Bu cevaplardan kaçının ve bunun yerine Okio'yu kullanın:

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);
      }
    }
  }
}

Varlıklardaki bir dosyayı okumak için bir yöntem:

/**
 * 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;
}

İçeriği dosyadan yükleyebilirsiniz. Dosyanın varlık klasöründe olduğunu düşünün.

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;
}

Şimdi fonksiyonu aşağıdaki gibi çağırarak içeriği alabilirsiniz

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

Data.json dikkate alındığında Application \ app \ src \ main \ asset \ data.json dizininde saklanır

MainActivity.java içinde

@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)));
        }
    }

Ayrıca, tüm işi yapan ayrı bir sınıf oluşturabilirsiniz

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();
    }
}

Bence bir arayüz oluşturmak daha iyi, ama gerekli değil

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

Etkinlik dışında başka bir sınıf kullanıyorsanız, bunu yapmak isteyebilirsiniz,

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

Kotlin'i kullanarak Android'deki varlıklardan bir dosya okumak için aşağıdakileri yapabilirsiniz:

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())
}

Belki çok geç ama şeftali gibi cevaplar arayan başkalarının uğruna:

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 + "";

    }

Scanner sınıfı bunu basitleştirebilir.

        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 cevap Kotlin sürümü:

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
}

İşte bir almanın bir yoludur InputStreambir dosya için assetsbir olmadan klasörde Context, Activity, Fragmentveya Application. Verileri bundan nasıl elde InputStreamedeceğiniz size kalmış. Buradaki diğer cevaplarda bunun için birçok öneri var.

Kotlin

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

Java

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

Bir özel oyundaysa tüm bahisler kapalıdır ClassLoader.