एंड्रॉइड में / से एक फ़ाइल के लिए स्ट्रिंग पढ़ें / लिखें


213

मैं एडिट टेक्स्ट से इनपुट प्राप्त करके फ़ाइल को आंतरिक संग्रहण में सहेजना चाहता हूं। फिर मैं उसी फ़ाइल को स्ट्रिंग रूप में इनपुट किए गए पाठ को वापस करना चाहता हूं और इसे दूसरे स्ट्रिंग पर सहेजना चाहता हूं जिसे बाद में उपयोग किया जाना है।

यहाँ कोड है:

package com.omm.easybalancerecharge;


import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.telephony.TelephonyManager;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {

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

        final EditText num = (EditText) findViewById(R.id.sNum);
        Button ch = (Button) findViewById(R.id.rButton);
        TelephonyManager operator = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        String opname = operator.getNetworkOperatorName();
        TextView status = (TextView) findViewById(R.id.setStatus);
        final EditText ID = (EditText) findViewById(R.id.IQID);
        Button save = (Button) findViewById(R.id.sButton);

        final String myID = ""; //When Reading The File Back, I Need To Store It In This String For Later Use

        save.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

                //Get Text From EditText "ID" And Save It To Internal Memory
            }
        });
        if (opname.contentEquals("zain SA")) {
            status.setText("Your Network Is: " + opname);
        } else {
            status.setText("No Network");
        }
        ch.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

                //Read From The Saved File Here And Append It To String "myID"


                String hash = Uri.encode("#");
                Intent intent = new Intent(Intent.ACTION_CALL);
                intent.setData(Uri.parse("tel:*141*" + /*Use The String With Data Retrieved Here*/ num.getText()
                        + hash));
                startActivity(intent);
            }
        });
    }

मैंने अपने बिंदुओं का और अधिक विश्लेषण करने में आपकी मदद करने के लिए टिप्पणियों को शामिल किया है जहाँ मैं चाहता हूँ कि संचालन किया जाए / चर का उपयोग किया जाए।


2
सवाल यह है कि "फाइल से / के लिए कैसे पढ़ना / लिखना है?"
दिमित्री गुडकोव

क्या आपने अपने तार को स्टोर करने के लिए ऐप की वरीयताओं का उपयोग करने पर विचार किया?
sdabet

4
BTW, सुनिश्चित करें कि आपने मुख्य फ़ाइल की अनुमति दी है, भंडारण के साथ काम करने के लिए ...
दमित्री

लागू करने के लिए कई बदलावों के साथ यह मेरा आधा पूरा ऐप है। मेरा विचार यह है कि उपयोगकर्ता ऐप के पहले भाग में केवल एक बार आईडी दर्ज करें। फिर ऐप उस संदर्भ को संग्रहीत करेगा जो उपयोगकर्ता द्वारा ऐप चलाने पर कई बार आईडी संग्रहीत करता है। प्रकटीकरण में सभी अनुमतियाँ जोड़ी जाती हैं।
मेजर ऐली

जवाबों:


334

आशा है कि यह आपके लिए उपयोगी हो सकता है।

फाइल लिखें:

private void writeToFile(String data,Context context) {
    try {
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(context.openFileOutput("config.txt", Context.MODE_PRIVATE));
        outputStreamWriter.write(data);
        outputStreamWriter.close();
    }
    catch (IOException e) {
        Log.e("Exception", "File write failed: " + e.toString());
    } 
}

फाइल पढ़ें:

private String readFromFile(Context context) {

    String ret = "";

    try {
        InputStream inputStream = context.openFileInput("config.txt");

        if ( inputStream != null ) {
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String receiveString = "";
            StringBuilder stringBuilder = new StringBuilder();

            while ( (receiveString = bufferedReader.readLine()) != null ) {
                stringBuilder.append("\n").append(receiveString);
            }

            inputStream.close();
            ret = stringBuilder.toString();
        }
    }
    catch (FileNotFoundException e) {
        Log.e("login activity", "File not found: " + e.toString());
    } catch (IOException e) {
        Log.e("login activity", "Can not read file: " + e.toString());
    }

    return ret;
}

43
यदि कक्षा गतिविधि से विस्तारित नहीं है, तो "ओपनफाइलइन्पुट ()" विधि का उपयोग इस तरह से होना चाहिए: संदर्भ.ओपनफाइलइन्पुट ()
बेहज़ाद

11
नोट: ऊपर दिया गया कोड अच्छी तरह से काम करता है, लेकिन परिणामस्वरूप स्ट्रिंग में फ़ाइल से कोई भी लाइनब्रेक नहीं होगा। लाइनब्रीक्स को फिर से जोड़ने के लिए, लाइन "stringBuilder.append (getString)" बदलें; "stringBuilder.append (getString) .append (" \ n ")?"। यदि आप अन्य लाइनब्रेक वर्णों की अपेक्षा करते हैं (जैसे Windows पाठ फ़ाइलों में \ r आदि ..) होंगे, तो अपने अंतिम स्ट्रिंग में, आपको इसे थोड़ा और अनुकूल करना होगा।
पेड़अविकास 23

26
यह कॉन्‍फ़‍िगर फ़ाइल वास्तविक डिवाइस में कहां सहेजती है? मुझे यह जांचने के लिए नहीं मिला :(
महदी

4
मुझे लगता है, final@SharkAlley उत्तर के रूप में ब्लॉक में धाराएं बंद होनी चाहिए
K

4
@Kenji फ़ाइल को ऐप की फ़ाइल निर्देशिका (यानी /data/data/<package_name>/files/config.txt) में सहेजा गया है। ऐप की प्रक्रिया इस तक पहुंच सकती है लेकिन ओएस में सभी प्रक्रियाएं नहीं। कार्यान्वयन भिन्न हो सकता है जिसके आधार पर आपका डिवाइस चलाने के लिए Android संस्करण। आप AOSP के कार्यान्वयन को ऑनलाइन देख सकते हैं। उदाहरण के लिए, एंड्रॉइड के लिए 8.1_r5: android.googlesource.com/platform/frameworks/base/+/…
vhamon

187

पढ़ने और लिखने के लिए एक स्ट्रिंग फाइल करने के लिए एक सामान्य रणनीति की तलाश करने वालों के लिए:

सबसे पहले, फ़ाइल ऑब्जेक्ट प्राप्त करें

आपको भंडारण पथ की आवश्यकता होगी। आंतरिक संग्रहण के लिए, उपयोग करें:

File path = context.getFilesDir();

बाहरी संग्रहण (SD कार्ड) के लिए, उपयोग करें:

File path = context.getExternalFilesDir(null);

फिर अपनी फ़ाइल ऑब्जेक्ट बनाएँ:

File file = new File(path, "my-file-name.txt");

फ़ाइल के लिए एक स्ट्रिंग लिखें

FileOutputStream stream = new FileOutputStream(file);
try {
    stream.write("text-to-write".getBytes());
} finally {
    stream.close();
}

या गूगल अमरूद के साथ

स्ट्रिंग सामग्री = Files.toString (फ़ाइल, StandardCharsets.UTF_8);

फ़ाइल को स्ट्रिंग पर पढ़ें

int length = (int) file.length();

byte[] bytes = new byte[length];

FileInputStream in = new FileInputStream(file);
try {
    in.read(bytes);
} finally {
    in.close();
}

String contents = new String(bytes);   

या यदि आप Google Guava का उपयोग कर रहे हैं

String contents = Files.toString(file,"UTF-8");

पूर्णता के लिए मैं उल्लेख करूंगा

String contents = new Scanner(file).useDelimiter("\\A").next();

जिसके लिए किसी लाइब्रेरी की आवश्यकता नहीं है, लेकिन अन्य विकल्पों की तुलना में बेंचमार्क 50% - 400% धीमा है (मेरे Nexus 5 पर विभिन्न परीक्षणों में)।

टिप्पणियाँ

इनमें से प्रत्येक रणनीति के लिए, आपको IOException को पकड़ने के लिए कहा जाएगा।

Android पर डिफ़ॉल्ट चरित्र एन्कोडिंग UTF-8 है।

यदि आप बाहरी संग्रहण का उपयोग कर रहे हैं, तो आपको अपने मैनिफ़ेस्ट में भी जोड़ना होगा:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

या

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

लिखने की अनुमति का अर्थ है पढ़ने की अनुमति, इसलिए आपको दोनों की आवश्यकता नहीं है।


उदाहरण के लिए, मैं चाहता हूं कि एक उपयोगकर्ता अपने सभी पोस्ट देखें, और जब वह किसी अन्य स्क्रीन पर जाए और वापस आए, तो क्या मुझे इसे फिर से खींचने की आवश्यकता है या क्योंकि यह कैश किया गया है, इसे कैश से बाहर खींचता है और बस दिखाता है, अगर यह बस इसे बाहर खींच रहा है, अगर सशर्त मेरी सर्वर क्वेरी करने के लिए नहीं कहने के लिए मैं कैसे एक जोड़ सकता हूँ
Lion789

4
इसे पसंद न करें new File(path + "/my-file-name.txt");। यह बहुत समझदारी को दर्शाता है Filenew File(path, "my-file-name.txt");इसके बजाय उपयोग करें ।
जिम्मीबीज

@HannoBinder एंड्रॉइड हमेशा लिनक्स के शीर्ष पर चलता है, इसलिए विभाजक को "/" होने की गारंटी है। इस संदर्भ में नई फ़ाइल (पथ, "my-file-name.txt") का उपयोग करने से क्या लाभ होगा? (यदि कोई कारण है तो मैं जवाब को अपडेट करने में प्रसन्न हूं।)
शार्कले

1
Fileवहाँ एक कारण के लिए है। आपके मामले में, आप बस के रूप में अच्छी तरह से छोड़ सकते हैं Fileऔर बस कर सकते हैं new FileInputStream(path + "/my-file-name.txt");, जो मैं अनुशंसा नहीं करता। (क्या होगा यदि उदाहरण के लिए pathएक अनुगामी शामिल है /?)
जिमीबी

आपके सुझाव के अनुसार संपादित किया गया। धन्यवाद :)
शार्कले

37
public static void writeStringAsFile(final String fileContents, String fileName) {
    Context context = App.instance.getApplicationContext();
    try {
        FileWriter out = new FileWriter(new File(context.getFilesDir(), fileName));
        out.write(fileContents);
        out.close();
    } catch (IOException e) {
        Logger.logError(TAG, e);
    }
}

public static String readFileAsString(String fileName) {
    Context context = App.instance.getApplicationContext();
    StringBuilder stringBuilder = new StringBuilder();
    String line;
    BufferedReader in = null;

    try {
        in = new BufferedReader(new FileReader(new File(context.getFilesDir(), fileName)));
        while ((line = in.readLine()) != null) stringBuilder.append(line);

    } catch (FileNotFoundException e) {
        Logger.logError(TAG, e);
    } catch (IOException e) {
        Logger.logError(TAG, e);
    } 

    return stringBuilder.toString();
}

7
ऐप? यह क्या होना चाहिए!
अलाप al ’at१४

@alap कुछ है @ यूजीन का उपयोग ऐप के संदर्भ को सांख्यिकीय रूप से प्राप्त करने के लिए किया जाता है। उसे इसके लिए चाहिए context.getFilesDir()। आप केवल new File(context.getFilesDir(), fileName)एक Fileवस्तु के साथ घटनाओं को बदल सकते हैं या Stringइसके बजाय कार्य करने के लिए पारित कर सकते हैं fileName
लोरेंजो-एस

7

अधिक प्रदर्शन के लिए फ़ाइल विधि से स्ट्रिंग पढ़ने पर बस थोड़ा सा संशोधन

private String readFromFile(Context context, String fileName) {
    if (context == null) {
        return null;
    }

    String ret = "";

    try {
        InputStream inputStream = context.openFileInput(fileName);

        if ( inputStream != null ) {
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);               

            int size = inputStream.available();
            char[] buffer = new char[size];

            inputStreamReader.read(buffer);

            inputStream.close();
            ret = new String(buffer);
        }
    }catch (Exception e) {
        e.printStackTrace();
    }

    return ret;
}

6

नीचे दिए गए कोड की जाँच करें।

फाइलसिस्टम में एक फाइल से पढ़ना।

FileInputStream fis = null;
    try {

        fis = context.openFileInput(fileName);
        InputStreamReader isr = new InputStreamReader(fis);
        // READ STRING OF UNKNOWN LENGTH
        StringBuilder sb = new StringBuilder();
        char[] inputBuffer = new char[2048];
        int l;
        // FILL BUFFER WITH DATA
        while ((l = isr.read(inputBuffer)) != -1) {
            sb.append(inputBuffer, 0, l);
        }
        // CONVERT BYTES TO STRING
        String readString = sb.toString();
        fis.close();

    catch (Exception e) {

    } finally {
        if (fis != null) {
            fis = null;
        }
    }

कोड को आंतरिक फाइलसिस्टम में फाइल लिखना है।

FileOutputStream fos = null;
    try {

        fos = context.openFileOutput(fileName, Context.MODE_PRIVATE);
        fos.write(stringdatatobestoredinfile.getBytes());
        fos.flush();
        fos.close();

    } catch (Exception e) {

    } finally {
        if (fos != null) {
            fos = null;
        }
    }

मुझे लगता है कि यह आपकी मदद करेगा।


3

मैं एक शुरुआत का एक सा रहा हूं और आज काम करने के लिए संघर्ष कर रहा हूं।

नीचे वह वर्ग है जिसके साथ मैं समाप्त हुआ। यह काम करता है लेकिन मैं सोच रहा था कि मेरा समाधान कितना अपूर्ण है। वैसे भी, मैं उम्मीद कर रहा था कि आप में से कुछ अधिक अनुभवी लोग मेरे IO वर्ग पर एक नज़र डालने और मुझे कुछ सुझाव देने के लिए तैयार हो सकते हैं। चीयर्स!

public class HighScore {
    File data = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator);
    File file = new File(data, "highscore.txt");
    private int highScore = 0;

    public int readHighScore() {
        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            try {
                highScore = Integer.parseInt(br.readLine());
                br.close();
            } catch (NumberFormatException | IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            try {
                file.createNewFile();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            e.printStackTrace();
        }
        return highScore;
    }

    public void writeHighScore(int highestScore) {
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            bw.write(String.valueOf(highestScore));
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

यदि कोई फ़ाइल नहीं है, तो आपको एक नई फ़ाइल बनाने की आवश्यकता नहीं है।
rml

1

पहली चीज़ जो हमें चाहिए वह है AndroidManifest.xml में अनुमतियाँ

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_INTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_INTERNAL_STORAGE" />

तो एक asyncTask Kotlin वर्ग में, हम फ़ाइल के निर्माण का इलाज करते हैं

    import android.os.AsyncTask
    import android.os.Environment
    import android.util.Log
    import java.io.*
    class WriteFile: AsyncTask<String, Int, String>() {
        private val mFolder = "/MainFolder"
        lateinit var folder: File
        internal var writeThis = "string to cacheApp.txt"
        internal var cacheApptxt = "cacheApp.txt"
        override fun doInBackground(vararg writethis: String): String? {
            val received = writethis[0]
            if(received.isNotEmpty()){
                writeThis = received
            }
            folder = File(Environment.getExternalStorageDirectory(),"$mFolder/")
            if(!folder.exists()){
                folder.mkdir()
                val readME = File(folder, cacheApptxt)
                val file = File(readME.path)
                val out: BufferedWriter
                try {
                    out = BufferedWriter(FileWriter(file, true), 1024)
                    out.write(writeThis)
                    out.newLine()
                    out.close()
                    Log.d("Output_Success", folder.path)
                } catch (e: Exception) {
                    Log.d("Output_Exception", "$e")
                }
            }
            return folder.path

    }

        override fun onPostExecute(result: String) {
            super.onPostExecute(result)

            if(result.isNotEmpty()){
                //implement an interface or do something
                Log.d("onPostExecuteSuccess", result)
            }else{
                Log.d("onPostExecuteFailure", result)
            }
        }

    }

यदि आप Api 23 से ऊपर एंड्रॉइड का उपयोग कर रहे हैं, तो निश्चित रूप से आपको डिवाइस मेमोरी को लिखने की अनुमति देने के अनुरोध को संभालना चाहिए। कुछ इस तरह

    import android.Manifest
    import android.content.Context
    import android.content.pm.PackageManager
    import android.os.Build
    import androidx.appcompat.app.AppCompatActivity
    import androidx.core.app.ActivityCompat
    import androidx.core.content.ContextCompat

    class ReadandWrite {
        private val mREAD = 9
        private val mWRITE = 10
        private var readAndWrite: Boolean = false
        fun readAndwriteStorage(ctx: Context, atividade: AppCompatActivity): Boolean {
            if (Build.VERSION.SDK_INT < 23) {
                readAndWrite = true
            } else {
                val mRead = ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_EXTERNAL_STORAGE)
                val mWrite = ContextCompat.checkSelfPermission(ctx, Manifest.permission.WRITE_EXTERNAL_STORAGE)

                if (mRead != PackageManager.PERMISSION_GRANTED) {
                    ActivityCompat.requestPermissions(atividade, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), mREAD)
                } else {
                    readAndWrite = true
                }

                if (mWrite != PackageManager.PERMISSION_GRANTED) {
                    ActivityCompat.requestPermissions(atividade, arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE), mWRITE)
                } else {
                    readAndWrite = true
                }
            }
            return readAndWrite
        }
    }

फिर एक गतिविधि में, कॉल निष्पादित करें।

  var pathToFileCreated = ""
    val anRW = ReadandWrite().readAndwriteStorage(this,this)
    if(anRW){
        pathToFileCreated =  WriteFile().execute("onTaskComplete").get()
        Log.d("pathToFileCreated",pathToFileCreated)
    }

उन आंतरिक संग्रहण अनुमतियाँ अमान्य हैं।
लेर्क

0

Kotlin

class FileReadWriteService {

    private var context:Context? = ContextHolder.instance.appContext

    fun writeFileOnInternalStorage(fileKey: String, sBody: String) {
        val file = File(context?.filesDir, "files")
        try {
            if (!file.exists()) {
                file.mkdir()
            }
            val fileToWrite = File(file, fileKey)
            val writer = FileWriter(fileToWrite)
            writer.append(sBody)
            writer.flush()
            writer.close()
        } catch (e: Exception) {
            Logger.e(classTag, e)
        }
    }

    fun readFileOnInternalStorage(fileKey: String): String {
        val file = File(context?.filesDir, "files")
        var ret = ""
        try {
            if (!file.exists()) {
                return ret
            }
            val fileToRead = File(file, fileKey)
            val reader = FileReader(fileToRead)
            ret = reader.readText()
            reader.close()
        } catch (e: Exception) {
            Logger.e(classTag, e)
        }
        return ret
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.