ਜਾਣ-ਪਛਾਣ:
Java ਵਿੱਚ InputStreams ਨਾਲ ਕੰਮ ਕਰਨਾ ਇੱਕ ਆਮ ਕੰਮ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਬਾਹਰੀ ਸਰੋਤਾਂ ਜਿਵੇਂ ਕਿ ਫਾਈਲਾਂ, ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨਾਂ, ਜਾਂ ਹੋਰ ਇਨਪੁਟ ਚੈਨਲਾਂ ਤੋਂ ਡਾਟਾ ਨਾਲ ਨਜਿੱਠਣਾ ਹੋਵੇ। ਜਾਣਕਾਰੀ ਨੂੰ ਲੌਗ ਕਰਨ, ਪ੍ਰੋਸੈਸ ਕਰਨ ਜਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇਸ ਡੇਟਾ ਨੂੰ ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣਾ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ।
ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਇਨਪੁਟਸਟ੍ਰੀਮ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਣ ਦੇ ਸਭ ਤੋਂ ਸਿੱਧੇ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕੇ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ। ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ Java ਵਿੱਚ ਤੁਹਾਡਾ ਡੇਟਾ ਹੈਂਡਲਿੰਗ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਭਰੋਸੇਮੰਦ ਹੈ।
| ਹੁਕਮ | ਵਰਣਨ |
|---|---|
| BufferedReader | ਇੱਕ ਪਾਠਕ ਜੋ ਇਨਪੁਟ ਨੂੰ ਬਫਰ ਕਰਦਾ ਹੈ, ਡੇਟਾ ਦੀਆਂ ਵੱਡੀਆਂ ਧਾਰਾਵਾਂ ਨੂੰ ਪੜ੍ਹਦੇ ਸਮੇਂ ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ। |
| InputStreamReader | ਇੱਕ ਬਾਈਟ ਸਟ੍ਰੀਮ (ਇਨਪੁਟ ਸਟ੍ਰੀਮ) ਨੂੰ ਇੱਕ ਅੱਖਰ ਸਟ੍ਰੀਮ (ਰੀਡਰ) ਵਿੱਚ ਬਦਲਦਾ ਹੈ। |
| Collectors.joining | ਇੱਕ ਵਿਕਲਪਿਕ ਡੀਲੀਮੀਟਰ ਦੇ ਨਾਲ, ਇੱਕ ਸਿੰਗਲ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਸਤਰ ਦੀ ਇੱਕ ਧਾਰਾ ਨੂੰ ਜੋੜਦਾ ਹੈ। |
| lines() | ਬਫਰਡ ਰੀਡਰ ਤੋਂ ਪੜ੍ਹੀਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਦੀ ਇੱਕ ਸਟ੍ਰੀਮ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅੱਗੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। |
| StandardCharsets.UTF_8 | ਏਨਕੋਡਿੰਗ ਲਈ UTF-8 ਅੱਖਰ-ਸੈੱਟ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ, ਅੱਖਰ ਡੇਟਾ ਦੇ ਸਹੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। |
| StringBuilder | ਸਟਰਿੰਗਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਬਣਾਉਣ ਅਤੇ ਸੋਧਣ ਲਈ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਅੱਖਰਾਂ ਦਾ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਕ੍ਰਮ। |
ਪਰਿਵਰਤਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਝਣਾ
ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਇੱਕ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ ਨੂੰ ਏ ਜਾਵਾ ਵਿੱਚ. ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਏ ਇੱਕ ਦੁਆਲੇ ਲਪੇਟਿਆ InputStreamReader, ਜੋ ਕਿ ਤੋਂ ਬਾਈਟਸ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਦ ਦੀ ਵਿਧੀ ਲਾਈਨਾਂ ਦੀ ਇੱਕ ਧਾਰਾ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜੋ ਫਿਰ ਇੱਕ ਸਿੰਗਲ ਵਿੱਚ ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ String ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ . ਇਹ ਪਹੁੰਚ ਡੇਟਾ ਦੀਆਂ ਵੱਡੀਆਂ ਧਾਰਾਵਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਕੁਸ਼ਲ ਹੈ ਕਿਉਂਕਿ ਇਹ ਲਾਈਨਾਂ ਨੂੰ ਆਲਸ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰਕੇ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ।
ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਸਮਾਨ ਪਹੁੰਚ ਦੀ ਪਾਲਣਾ ਕਰਦੀ ਹੈ ਪਰ a ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਤੋਂ ਪੜ੍ਹੀਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ . ਇਹ ਵਿਧੀ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਨਾਲ ਜੋੜਿਆ ਗਿਆ ਹੈ ਸਹੀ ਲਾਈਨ ਵਿਭਾਜਕਾਂ ਦੇ ਨਾਲ. ਦੋਵੇਂ ਸਕ੍ਰਿਪਟਾਂ a ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਪਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲਦੀਆਂ ਹਨ try-with-resources ਸਟੇਟਮੈਂਟ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਰੋਤ ਆਪਣੇ ਆਪ ਬੰਦ ਹੋ ਗਏ ਹਨ। ਦੀ ਵਰਤੋਂ ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇਹ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਪਲੇਟਫਾਰਮ ਦੇ ਡਿਫੌਲਟ ਅੱਖਰ-ਸੈੱਟ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਟੈਕਸਟ ਦੀ ਸਹੀ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ ਹੈ।
ਜਾਵਾ ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਨਾਲ ਇਨਪੁਟਸਟ੍ਰੀਮ ਨੂੰ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਣਾ
ਇਨਪੁਟਸਟ੍ਰੀਮ ਪਰਿਵਰਤਨ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮਿੰਗ
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();}}
ਵੱਡੀਆਂ ਇਨਪੁਟ ਸਟ੍ਰੀਮਾਂ ਦੀ ਕੁਸ਼ਲ ਹੈਂਡਲਿੰਗ
ਵੱਡੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ , ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇੱਕ ਪਹੁੰਚ ਨੂੰ ਪੜ੍ਹਨਾ ਹੈ ਲਾਈਨ ਦਰ ਲਾਈਨ ਦੀ ਬਜਾਏ ਟੁਕੜਿਆਂ ਵਿੱਚ, ਜੋ ਇੱਕ ਬਾਈਟ ਬਫਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਲਾਭਦਾਇਕ ਹੈ ਜਦੋਂ ਬਾਈਨਰੀ ਡੇਟਾ ਜਾਂ ਵੱਡੀਆਂ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਜਿੱਥੇ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇੱਕ ਬਫਰ ਨਿਰਧਾਰਤ ਕਰਕੇ ਅਤੇ ਇਸ ਵਿੱਚ ਡੇਟਾ ਪੜ੍ਹ ਕੇ, ਤੁਸੀਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹੋ।
ਇਕ ਹੋਰ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ ਲਾਇਬ੍ਰੇਰੀ, ਜੋ ਕਿ I/O ਕਾਰਵਾਈਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਉਪਯੋਗਤਾ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਦ ਵਿਧੀ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਦੇ ਸਿੱਧੇ ਰੂਪਾਂਤਰਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਨੂੰ ਏ String. ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਸਰਲ ਬਣਾ ਸਕਦੀ ਹੈ ਅਤੇ ਪੜ੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੀ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਇੱਕ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਨੂੰ ਪੇਸ਼ ਕਰਦੀ ਹੈ। ਮਜਬੂਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ, ਕੁਸ਼ਲ ਅਤੇ ਸਾਂਭਣਯੋਗ ਕੋਡ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਹਨਾਂ ਪਹੁੰਚਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰੋ।
- ਵਰਤਣ ਦਾ ਮਕਸਦ ਕੀ ਹੈ ?
- ਦ ਇੰਪੁੱਟ ਨੂੰ ਬਫਰ ਕਰਕੇ ਅਤੇ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਘਟਾ ਕੇ ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ।
- ਕਿਉਂ ਵਰਤੋ ਨਾਲ ?
- ਦ ਇੱਕ ਬਾਈਟ ਸਟ੍ਰੀਮ ਨੂੰ ਇੱਕ ਅੱਖਰ ਸਟ੍ਰੀਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਟੈਕਸਟ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
- ਕੀ ਇਹ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਰੋ?
- ਦ ਵਿਧੀ ਸਟਰੀਮ ਦੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਵਿੱਚ ਜੋੜਦੀ ਹੈ ਇੱਕ ਨਿਰਧਾਰਤ ਡੀਲੀਮੀਟਰ ਦੇ ਨਾਲ।
- ਕਿਵੇਂ ਕਰਦਾ ਹੈ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਵਧਾਉਣਾ?
- ਦ ਅਟੱਲ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਮੁਕਾਬਲੇ ਮੈਮੋਰੀ ਓਵਰਹੈੱਡ ਨੂੰ ਘਟਾਉਣ ਲਈ, ਕੁਸ਼ਲਤਾ ਨਾਲ ਸਤਰ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
- ਦੇ ਕੀ ਫਾਇਦੇ ਹਨ ?
- ਦ ਸਟੇਟਮੈਂਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਰੋਤ ਆਟੋਮੈਟਿਕ ਬੰਦ ਹੋ ਗਏ ਹਨ, ਸਰੋਤ ਲੀਕ ਨੂੰ ਰੋਕਦੇ ਹੋਏ।
- ਕਿਉਂ ਨਿਰਧਾਰਿਤ ਕਰੋ ?
- ਨਿਰਧਾਰਿਤ ਕਰ ਰਿਹਾ ਹੈ ਵੱਖ-ਵੱਖ ਪਲੇਟਫਾਰਮਾਂ ਵਿੱਚ ਇਕਸਾਰ ਅੱਖਰ ਇੰਕੋਡਿੰਗ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।
- ਸਕਦਾ ਹੈ ਪਰਿਵਰਤਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਣਾ?
- ਹਾਂ, ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਤੱਕ ਵਿਧੀ ਇੱਕ ਨੂੰ ਬਦਲਣ ਲਈ ਕੋਡ ਨੂੰ ਸਰਲ ਬਣਾ ਸਕਦਾ ਹੈ ਨੂੰ ਏ String.
ਇਨਪੁਟਸਟ੍ਰੀਮ ਪਰਿਵਰਤਨ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ
ਇੱਕ ਨੂੰ ਬਦਲਣਾ ਨੂੰ ਏ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਇੱਕ ਆਮ ਕੰਮ ਹੈ ਜਿਸਨੂੰ ਸਹੀ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਵਰਗੀਆਂ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਅਤੇ InputStreamReader ਟੈਕਸਟ ਡੇਟਾ ਦੀ ਨਿਰਵਿਘਨ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਵਿਧੀਆਂ ਜਿਵੇਂ ਕਿ ਅਤੇ Apache Commons IO ਵਰਗੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਕੋਡ ਦੀ ਸਰਲਤਾ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਹੋਰ ਵਧਾ ਸਕਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹਨ ਕਿ ਉਹਨਾਂ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਇਨਪੁਟ ਸਟ੍ਰੀਮਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਭਰੋਸੇਮੰਦ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦੀਆਂ ਹਨ।