ജാവയിൽ ഒരു ഇൻപുട്ട് സ്ട്രീം ഒരു സ്ട്രിംഗിലേക്ക് എങ്ങനെ പരിവർത്തനം ചെയ്യാം

ആമുഖം:

Java-ൽ ഇൻപുട്ട് സ്ട്രീമുകളിൽ പ്രവർത്തിക്കുന്നത് ഒരു സാധാരണ ജോലിയാണ്, പ്രത്യേകിച്ചും ഫയലുകൾ, നെറ്റ്‌വർക്ക് കണക്ഷനുകൾ അല്ലെങ്കിൽ മറ്റ് ഇൻപുട്ട് ചാനലുകൾ പോലുള്ള ബാഹ്യ ഉറവിടങ്ങളിൽ നിന്നുള്ള ഡാറ്റ കൈകാര്യം ചെയ്യുമ്പോൾ. വിവരങ്ങൾ ലോഗിൻ ചെയ്യുന്നതിനോ പ്രോസസ്സ് ചെയ്യുന്നതിനോ പ്രദർശിപ്പിക്കുന്നതിനോ ഈ ഡാറ്റ ഒരു സ്ട്രിംഗ് ഫോർമാറ്റിലേക്ക് മാറ്റുന്നത് അത്യന്താപേക്ഷിതമാണ്.

ഈ ലേഖനത്തിൽ, ഒരു InputStream ഒരു സ്ട്രിംഗ് ആക്കി മാറ്റുന്നതിനുള്ള ഏറ്റവും ലളിതവും കാര്യക്ഷമവുമായ മാർഗ്ഗം ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഈ ഘട്ടങ്ങൾ പാലിക്കുന്നതിലൂടെ, ജാവയിലെ നിങ്ങളുടെ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നത് ഫലപ്രദവും വിശ്വസനീയവുമാണെന്ന് നിങ്ങൾക്ക് ഉറപ്പാക്കാനാകും.

പരിവർത്തന പ്രക്രിയ മനസ്സിലാക്കുന്നു

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ എങ്ങനെ കാര്യക്ഷമമായി പരിവർത്തനം ചെയ്യാമെന്ന് കാണിക്കുന്നു InputStream എ വരെ String ജാവയിൽ. ആദ്യ സ്ക്രിപ്റ്റ് എ ഉപയോഗിക്കുന്നു BufferedReader ഒരു ചുറ്റും പൊതിഞ്ഞു InputStreamReader, ഇതിൽ നിന്നുള്ള ബൈറ്റുകൾ വായിക്കുന്നു InputStream അവയെ കഥാപാത്രങ്ങളാക്കി മാറ്റുകയും ചെയ്യുന്നു. ദി lines() എന്ന രീതി BufferedReader വരികളുടെ ഒരു സ്ട്രീം തിരികെ നൽകുന്നു, അത് പിന്നീട് ഒറ്റത്തവണയായി ശേഖരിക്കുന്നു String ഉപയോഗിക്കുന്നത് Collectors.joining. ഈ സമീപനം ഡാറ്റയുടെ വലിയ സ്ട്രീമുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് കാര്യക്ഷമമാണ്, കാരണം ഇത് ലൈനുകൾ അലസമായി പ്രോസസ്സ് ചെയ്യുന്നതിലൂടെ മെമ്മറി ഉപയോഗം കുറയ്ക്കുന്നു.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് സമാനമായ ഒരു സമീപനം പിന്തുടരുന്നു, എന്നാൽ എ ഉപയോഗിക്കുന്നു StringBuilder എന്നതിൽ നിന്ന് വായിച്ച വരികൾ ശേഖരിക്കാൻ BufferedReader. ഈ രീതി എല്ലാ വരികളും ചേർത്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്നു StringBuilder ശരിയായ ലൈൻ സെപ്പറേറ്ററുകൾക്കൊപ്പം. രണ്ട് സ്ക്രിപ്റ്റുകളും a ഉപയോഗിച്ച് ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുന്നു try-with-resources ഉറവിടങ്ങൾ സ്വയമേവ അടച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്ന പ്രസ്താവന. ഉപയോഗം StandardCharsets.UTF_8 പ്ലാറ്റ്‌ഫോമിൻ്റെ ഡിഫോൾട്ട് ചാർസെറ്റ് പരിഗണിക്കാതെ തന്നെ, ടെക്‌സ്‌റ്റ് ശരിയായി വ്യാഖ്യാനിക്കപ്പെടുന്നുവെന്ന് രണ്ടാമത്തെ സ്‌ക്രിപ്റ്റിൽ ഉറപ്പ് നൽകുന്നു.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

public class InputStreamConverter {
    public static String convertStreamToString(InputStream is) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
            return reader.lines().collect(Collectors.joining(System.lineSeparator()));
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class StreamToString {
    public static String convertStreamToString(InputStream is) {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append(System.lineSeparator());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
}

വലിയ ഇൻപുട്ട് സ്ട്രീമുകളുടെ കാര്യക്ഷമമായ കൈകാര്യം ചെയ്യൽ

വലുതുമായി പ്രവർത്തിക്കുമ്പോൾ InputStreams, മെമ്മറി ഫലപ്രദമായി കൈകാര്യം ചെയ്യേണ്ടത് നിർണായകമാണ്. വായിക്കുക എന്നതാണ് ഒരു സമീപനം InputStream ഒരു ബൈറ്റ് ബഫർ ഉപയോഗിച്ച് നേടാനാകുന്ന വരി വരി എന്നതിലുപരി കഷണങ്ങളായി. ബൈനറി ഡാറ്റ അല്ലെങ്കിൽ മെമ്മറി ഉപയോഗം കുറയ്ക്കേണ്ട വലിയ ടെക്സ്റ്റ് ഫയലുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ ഈ രീതി പ്രയോജനകരമാണ്. ഒരു ബഫർ അനുവദിക്കുകയും അതിലേക്ക് ഡാറ്റ വായിക്കുകയും ചെയ്യുന്നതിലൂടെ, അമിതമായ മെമ്മറി ഉപയോഗിക്കാതെ നിങ്ങൾക്ക് വലിയ ഫയലുകൾ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും.

മറ്റൊരു സാങ്കേതികത ഉപയോഗിക്കുന്നു Apache Commons IO I/O പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള യൂട്ടിലിറ്റി രീതികൾ നൽകുന്ന ലൈബ്രറി. ദി IOUtils.toString രീതി, ഉദാഹരണത്തിന്, ഒരു നേരിട്ട് പരിവർത്തനം അനുവദിക്കുന്നു InputStream എ വരെ String. ഈ ലൈബ്രറിക്ക് നിങ്ങളുടെ കോഡ് ലളിതമാക്കാനും വായനാക്ഷമത മെച്ചപ്പെടുത്താനും കഴിയും, എന്നിരുന്നാലും ഇത് ഒരു ബാഹ്യ ആശ്രിതത്വം അവതരിപ്പിക്കുന്നു. ശക്തമായ ആപ്ലിക്കേഷനുകൾക്കായി, കാര്യക്ഷമവും പരിപാലിക്കാവുന്നതുമായ കോഡ് ഉറപ്പാക്കാൻ ഈ സമീപനങ്ങൾ പരിഗണിക്കുക.

ഇൻപുട്ട് സ്ട്രീം പരിവർത്തനത്തെക്കുറിച്ചുള്ള അന്തിമ ചിന്തകൾ

ഒരു പരിവർത്തനം ചെയ്യുന്നു InputStream എ വരെ String ശരിയായ സാങ്കേതിക വിദ്യകൾ ഉപയോഗിച്ച് കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ജാവ പ്രോഗ്രാമിംഗിലെ ഒരു സാധാരണ ജോലിയാണ്. തുടങ്ങിയ ക്ലാസുകൾ ഉപയോഗപ്പെടുത്തുന്നു BufferedReader ഒപ്പം InputStreamReader ടെക്സ്റ്റ് ഡാറ്റയുടെ സുഗമമായ പ്രോസസ്സിംഗ് അനുവദിക്കുന്നു, അതേസമയം പോലുള്ള രീതികൾ Collectors.joining കൂടാതെ Apache Commons IO പോലുള്ള ലൈബ്രറികൾക്ക് കോഡ് ലാളിത്യവും പ്രകടനവും കൂടുതൽ മെച്ചപ്പെടുത്താൻ കഴിയും. ഈ രീതികൾ പിന്തുടരുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് അവരുടെ ആപ്ലിക്കേഷനുകൾ ഇൻപുട്ട് സ്ട്രീമുകൾ ഫലപ്രദമായും വിശ്വസനീയമായും കൈകാര്യം ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കാൻ കഴിയും.