ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਕਿਵੇਂ ਬਣਾਈਏ

ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਖੇਤਰ ਵਿੱਚ, ਜਾਵਾ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਅਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਣ ਗਈ ਹੈ। ਇਸ ਦੀਆਂ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਇਸਦੀ ਵਰਤੋਂ ਦੀ ਸੌਖ, ਅਤੇ ਕਈ ਕਿਸਮਾਂ ਵਿੱਚ ਲਾਗੂ ਕਰਨ ਦੀ ਯੋਗਤਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇਸਨੂੰ ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਬਹੁਮੁਖੀ ਟੂਲ ਬਣਾਓ। ਇਸ ਭਾਸ਼ਾ ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤੀਆਂ ਕਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ, ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਹੇਰਾਫੇਰੀ ਕਰਨ ਦੀ ਯੋਗਤਾ ਜ਼ਰੂਰੀ ਹੈ। ਇਸ ਵ੍ਹਾਈਟ ਪੇਪਰ ਵਿੱਚ ਅਸੀਂ ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਉਪਲਬਧ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਅਤੇ ਤਰੀਕਿਆਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ। ਕੁਸ਼ਲਤਾ ਨਾਲ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ. ਜੇ ਤੁਸੀਂ ਇਹ ਸਿੱਖਣ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ ਕਿ ਟੈਕਸਟ ਫਾਈਲਾਂ ਬਣਾਉਣ ਲਈ ਜਾਵਾ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ, ਤਾਂ ਇਹ ਲੇਖ ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਸੰਕਲਪਾਂ ਅਤੇ ਵਧੀਆ ਅਭਿਆਸਾਂ ਲਈ ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਗਾਈਡ ਪ੍ਰਦਾਨ ਕਰੇਗਾ।

1. ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਸ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ?

ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਇੱਕ ਫਾਈਲ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਟੈਕਸਟ ਫਾਰਮੈਟ ਵਿੱਚ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ, ਅਰਥਾਤ, ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗ ਅੱਖਰ। ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦੇ ਉਲਟ, ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਟੈਕਸਟ ਐਡੀਟਰ ਨਾਲ ਆਸਾਨੀ ਨਾਲ ਖੋਲ੍ਹਿਆ ਅਤੇ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਜਾਵਾ ਵਿੱਚ, ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਸਾਦੇ ਟੈਕਸਟ ਦੇ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

Java ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਵੱਖ-ਵੱਖ ਕੰਮਾਂ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਟੈਕਸਟ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ, ਸੈਟਿੰਗਾਂ ਜਾਂ ਉਪਭੋਗਤਾ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨਾ, ਅਤੇ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਜਾਣਕਾਰੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ। ਉਹਨਾਂ ਵਿੱਚ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਟੈਕਸਟ ਸਤਰ, ਨੰਬਰ, ਮਿਤੀਆਂ, ਜਾਂ ਕੋਈ ਹੋਰ ਕਿਸਮ ਦਾ ਡੇਟਾ ਜਿਸ ਨੂੰ ਟੈਕਸਟ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

Java ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, Java API ਕਲਾਸਾਂ ਅਤੇ ਵਿਧੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਸਭ ਤੋਂ ਆਮ ਵਰਗਾਂ ਵਿੱਚੋਂ ਕੁਝ ਹਨ File, FileReader y BufferedReader. ਇਹ ਕਲਾਸਾਂ ਫਾਈਲਾਂ ਨੂੰ ਖੋਲ੍ਹਣ, ਉਹਨਾਂ ਦੀਆਂ ਸਮੱਗਰੀਆਂ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹਨ, ਅਤੇ ਵਰਤੋਂ ਤੋਂ ਬਾਅਦ ਫਾਈਲਾਂ ਨੂੰ ਬੰਦ ਕਰਨ ਦੇ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਲਿਖਣ ਲਈ ਢੰਗ ਵੀ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ FileWriter y BufferedWriter.

2. Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਣ ਲਈ ਕਦਮ

ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਣਾ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸ ਲਈ ਖਾਸ ਕਦਮਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਹੇਠਾਂ ਅਸੀਂ ਤੁਹਾਨੂੰ ਇੱਕ ਸਧਾਰਨ ਗਾਈਡ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਤੁਸੀਂ ਜਾਵਾ ਵਿੱਚ ਆਪਣੀਆਂ ਖੁਦ ਦੀਆਂ ਟੈਕਸਟ ਫਾਈਲਾਂ ਬਣਾ ਸਕੋ:

ਕਦਮ 1: ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰੋ

ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਕੋਡ ਦੀ ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:

import java.io.FileWriter;

import java.io.IOException;

ਕਦਮ 2: ਫਾਈਲਰਾਈਟਰ ਆਬਜੈਕਟ ਬਣਾਓ

ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ FileWriter ਵਸਤੂ ਬਣਾਉਣ ਦੀ ਲੋੜ ਪਵੇਗੀ। ਇਹ ਆਬਜੈਕਟ Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਬਣਾ ਸਕਦੇ ਹੋ:

FileWriter archivo = new FileWriter("ruta_del_archivo.txt");

ਕਦਮ 3: ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਲਿਖੋ

ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ FileWriter ਆਬਜੈਕਟ ਬਣਾ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਇਸ ਨੂੰ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਰ ਸਕਦੇ ਹੋ write ਫਾਈਲਰਾਈਟਰ ਆਬਜੈਕਟ ਦਾ। ਉਦਾਹਰਣ ਲਈ:

archivo.write("Hola, mundo!");

ਤੁਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ append ਜੇਕਰ ਤੁਸੀਂ ਫਾਈਲ ਵਿੱਚ ਮੌਜੂਦਾ ਸਮੱਗਰੀ ਨੂੰ ਹਟਾਏ ਬਿਨਾਂ ਟੈਕਸਟ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਉਦਾਹਰਣ ਲਈ:

archivo.append("Este es un ejemplo de texto agregado.");

3. Java ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਣ ਵੇਲੇ ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ

Java ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਣ ਵੇਲੇ ਅਪਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਕੋਸ਼ਿਸ਼-ਕੈਚ ਬਲਾਕਾਂ ਦੀ ਵਰਤੋਂ ਜ਼ਰੂਰੀ ਹੈ। ਇਹ ਬਲਾਕ ਸਾਨੂੰ ਕਿਸੇ ਵੀ ਅਪਵਾਦ ਨੂੰ ਫੜਨ ਅਤੇ ਸੰਭਾਲਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਫਾਈਲ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਹੋ ਸਕਦਾ ਹੈ।

ਪਹਿਲਾ ਕਦਮ ਇੱਕ ਕੋਸ਼ਿਸ਼ ਬਲਾਕ ਦੇ ਅੰਦਰ ਫਾਈਲ ਬਣਾਉਣ ਵਾਲੇ ਕੋਡ ਨੂੰ ਸਮੇਟਣਾ ਹੈ। ਇਸ ਬਲਾਕ ਦੇ ਅੰਦਰ, ਸਾਨੂੰ FileWriter ਕਲਾਸ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਬਣਾਉਣ ਲਈ ਫਾਈਲ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਜੋ ਅਸੀਂ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇਸ ਮੌਕੇ 'ਤੇ, ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਫਾਈਲ ਨੂੰ ਨਿਰਧਾਰਤ ਸਥਾਨ 'ਤੇ ਬਣਾਇਆ ਜਾਵੇਗਾ।

ਅੱਗੇ, ਸਾਨੂੰ ਫਾਈਲ ਵਿੱਚ ਸਮੱਗਰੀ ਲਿਖਣ ਲਈ ਫਾਈਲਰਾਈਟਰ ਕਲਾਸ ਦੀ ਲਿਖਣ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਵਿਧੀ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ 'ਤੇ ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਸਤਰ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ, ਜੋ ਕਿ ਫਾਈਲ ਵਿੱਚ ਲਿਖੀ ਜਾਣ ਵਾਲੀ ਸਮੱਗਰੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਇਹ ਵਿਧੀ ਇੱਕ IOException ਸੁੱਟ ਸਕਦੀ ਹੈ, ਇਸਲਈ ਸਾਨੂੰ ਇਸਨੂੰ ਇੱਕ ਕੋਸ਼ਿਸ਼-ਕੈਚ ਬਲਾਕ ਨਾਲ ਘੇਰਨ ਦੀ ਲੋੜ ਹੈ। ਕੈਚ ਬਲਾਕ ਦੇ ਅੰਦਰ, ਅਸੀਂ ਉਪਭੋਗਤਾ ਨੂੰ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਕੇ ਜਾਂ ਲੋੜੀਂਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਕੇ ਅਪਵਾਦ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲ ਸਕਦੇ ਹਾਂ।

4. ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਖੋਲ੍ਹਣਾ ਅਤੇ ਬੰਦ ਕਰਨਾ ਹੈ

ਜਾਵਾ ਵਿੱਚ, ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਖੋਲ੍ਹਣਾ ਅਤੇ ਬੰਦ ਕਰਨਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਸਰੋਤ ਸਹੀ ਢੰਗ ਨਾਲ ਜਾਰੀ ਕੀਤੇ ਗਏ ਹਨ ਅਤੇ ਮੈਮੋਰੀ ਜਾਂ ਫਾਈਲ ਐਕਸੈਸ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਲਈ. ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਕਦਮ ਹਨ:

1. ਫਾਈਲ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਘੋਸ਼ਿਤ ਕਰੋ। ਇਹ ਕਲਾਸ ਸਿਸਟਮ ਉੱਤੇ ਫਾਇਲ ਦੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਮੌਜੂਦਾ ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਫਾਈਲ ਦਾ ਪੂਰਨ ਮਾਰਗ ਜਾਂ ਸੰਬੰਧਿਤ ਮਾਰਗ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।

2. ਫਾਈਲ ਰੀਡਰ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ, ਜੋ ਟੈਕਸਟ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ 'ਤੇ ਪਹਿਲਾਂ ਬਣਾਈ ਗਈ ਫਾਈਲ ਉਦਾਹਰਣ ਨੂੰ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ।

3. ਫਾਈਲ ਲਾਈਨ ਦੀਆਂ ਸਮੱਗਰੀਆਂ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹਨ ਲਈ FileReader ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ readLine() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਲਾਈਨ ਰੀਡ ਦੇ ਨਾਲ ਇੱਕ ਸਤਰ ਵਾਪਸ ਕਰਦੀ ਹੈ। ਤੁਸੀਂ ਇਹਨਾਂ ਲਾਈਨਾਂ ਨੂੰ ਇੱਕ ArrayList ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹੋ।

ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ, ਇੱਕ ਵਾਰ ਫਾਈਲ ਰੀਡਿੰਗ ਪ੍ਰਕਿਰਿਆ ਪੂਰੀ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਸਰੋਤਾਂ ਨੂੰ ਉਚਿਤ ਢੰਗ ਨਾਲ ਬੰਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. FileReader ਆਬਜੈਕਟ ਦੀ ਕਲੋਜ਼() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਹ ਇਸ ਵਸਤੂ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਸਰੋਤਾਂ ਨੂੰ ਮੁਕਤ ਕਰਦਾ ਹੈ।

2. ਜੇਕਰ ਤੁਸੀਂ ਪੜ੍ਹੀਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਐਰੇਲਿਸਟ ਜਾਂ ਕਿਸੇ ਹੋਰ ਕਿਸਮ ਦੇ ਸੰਗ੍ਰਹਿ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਤਾਂ ਉਕਤ ਸੰਗ੍ਰਹਿ ਨਾਲ ਜੁੜੇ ਸਰੋਤਾਂ ਨੂੰ ਵੀ ਜਾਰੀ ਕਰਨਾ ਯਾਦ ਰੱਖੋ। ਤੁਸੀਂ ਸਪਸ਼ਟ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹੋ।

ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰ ਰਹੇ ਹੋਵੋਗੇ, ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚੋਗੇ ਅਤੇ ਸਰੋਤਾਂ ਦੀ ਸਹੀ ਰੀਲੀਜ਼ ਦੀ ਗਰੰਟੀ ਦਿਓਗੇ। ਯਾਦ ਰੱਖੋ ਕਿ ਭਵਿੱਖ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਲਈ ਹਮੇਸ਼ਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਰੋਤਾਂ ਦਾ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।

5. Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣਾ: ਢੰਗ ਅਤੇ ਵਧੀਆ ਅਭਿਆਸ

ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣਾ ਐਪਲੀਕੇਸ਼ਨ ਵਿਕਾਸ ਵਿੱਚ ਇੱਕ ਆਮ ਕੰਮ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਜਾਵਾ ਤਰੀਕੇ ਅਤੇ ਚੰਗੇ ਅਭਿਆਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਸਾਨੂੰ ਇਸ ਕੰਮ ਨੂੰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਕੁਸ਼ਲ ਤਰੀਕਾ ਅਤੇ ਸੁਰੱਖਿਅਤ. ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਸਿਖਾਂਗੇ ਕਿ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਅਤੇ ਸਾਡੇ ਕੋਡ ਦੀ ਗੁਣਵੱਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਚੰਗੇ ਅਭਿਆਸਾਂ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ।

ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਲਿਖ ਸਕੀਏ, ਸਾਨੂੰ ਇਸਨੂੰ ਲਿਖਣ ਮੋਡ ਵਿੱਚ ਖੋਲ੍ਹਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਸੀਂ FileWriter ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ, ਜੋ ਸਾਨੂੰ ਇੱਕ ਖਾਸ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣ ਦੀ ਯੋਗਤਾ ਦੇ ਨਾਲ ਇੱਕ ਵਸਤੂ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਵਾਰ ਫਾਈਲ ਖੋਲ੍ਹਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਇਸ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣ ਲਈ write() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਅਸੀਂ ਇੱਕ ਟੈਕਸਟ ਸਤਰ ਨੂੰ ਸਿੱਧੇ ਫਾਈਲ ਵਿੱਚ ਲਿਖਣ ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕਰ ਸਕਦੇ ਹਾਂ, ਜਾਂ ਟੈਕਸਟ ਦੀ ਇੱਕ ਪੂਰੀ ਲਾਈਨ ਲਿਖਣ ਲਈ println() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ।

ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਟੈਕਸਟ ਫਾਈਲਾਂ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਸੰਭਾਵਿਤ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਸਾਵਧਾਨੀ ਵਰਤਣੀ ਚਾਹੀਦੀ ਹੈ। ਇੱਕ ਵਧੀਆ ਅਭਿਆਸ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਇੱਕ ਵਾਰ ਫਾਈਲ ਨੂੰ ਲਿਖਣ ਤੋਂ ਬਾਅਦ ਇਸਨੂੰ ਬੰਦ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ FileWriter ਕਲਾਸ ਦੀ close() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਲਿਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਸੰਭਵ ਅਪਵਾਦਾਂ ਨੂੰ ਫੜਨ ਲਈ ਕੋਸ਼ਿਸ਼-ਕੈਚ ਬਲਾਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਕਿਸੇ ਵੀ ਤਰੁੱਟੀ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅਚਾਨਕ ਰੁਕਣ ਤੋਂ ਰੋਕ ਸਕਦੇ ਹਾਂ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਰਾ ਡੇਟਾ ਸਹੀ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਫਲੱਸ਼() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵੀ ਯਾਦ ਰੱਖੋ।

6. Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਤੋਂ ਜਾਣਕਾਰੀ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨੀ ਹੈ

Java ਵਿੱਚ, ਜਾਣਕਾਰੀ ਪੜ੍ਹੋ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰੋ ਇੱਕ ਫਾਈਲ ਤੋਂ ਟੈਕਸਟ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਕੀਤਾ ਜਾਣ ਵਾਲਾ ਇੱਕ ਆਮ ਕੰਮ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਜਾਵਾ ਇਸ ਕੰਮ ਨੂੰ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਕਈ ਟੂਲ ਅਤੇ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਸਿੱਖਾਂਗੇ ਕਿ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਤੋਂ ਜਾਣਕਾਰੀ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨੀ ਹੈ ਕਦਮ ਦਰ ਕਦਮ.

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨਾ ਸ਼ੁਰੂ ਕਰੋ, ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਖੋਲ੍ਹਣ ਦੀ ਲੋੜ ਹੈ FileReader y la clase BufferedReader. ਪਹਿਲਾ ਕਦਮ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਣਾ ਹੈ File ਜੋ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਅਸੀਂ ਪੜ੍ਹਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਅੱਗੇ, ਅਸੀਂ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਂਦੇ ਹਾਂ FileReader ਵਸਤੂ ਨੂੰ ਪਾਸ ਕਰਨਾ File ਇੱਕ ਦਲੀਲ ਦੇ ਤੌਰ ਤੇ. ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਂਦੇ ਹਾਂ BufferedReader ਵਸਤੂ ਨੂੰ ਪਾਸ ਕਰਨਾ FileReader ਇੱਕ ਦਲੀਲ ਦੇ ਤੌਰ ਤੇ.

ਇੱਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਖੋਲ੍ਹ ਲੈਂਦੇ ਹਾਂ, ਅਸੀਂ ਇਸਦੀ ਸਮੱਗਰੀ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ readLine() de la clase BufferedReader. ਇਹ ਵਿਧੀ ਇੱਕ ਅੱਖਰ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਈਲ ਤੋਂ ਇੱਕ ਲਾਈਨ ਵਾਪਸ ਕਰਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਸਟ੍ਰਿੰਗ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਜਾਂ ਆਉਟਪੁੱਟ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਵਿਧੀ readLine() devuelve null ਜਦੋਂ ਇਹ ਫਾਈਲ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ while ਅੰਤ ਤੱਕ ਪਹੁੰਚਣ ਤੱਕ ਫਾਈਲ ਦੀਆਂ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ।

7. ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਣ ਵੇਲੇ ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਅਤੇ ਏਨਕੋਡਿੰਗਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ

Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਅਕਸਰ ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਅਤੇ ਏਨਕੋਡਿੰਗਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹਨਾਂ ਅੱਖਰਾਂ ਵਿੱਚ ਗੈਰ-ਵਰਣਮਾਲਾ ਦੇ ਚਿੰਨ੍ਹ, ਲਹਿਜ਼ੇ, ਸਫੈਦ ਸਪੇਸ, ਹੋਰਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਵਰਤੀ ਗਈ ਏਨਕੋਡਿੰਗ ਅਨੁਕੂਲ ਹੈ ਸਿਸਟਮ ਨਾਲ ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਚਲਾਇਆ ਜਾਵੇਗਾ।

ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ ਬਚਣ ਦੇ ਕ੍ਰਮ ਦੀ ਵਰਤੋਂ ਕਰਨਾ। ਇਹਨਾਂ ਕ੍ਰਮਾਂ ਵਿੱਚ ਇੱਕ ਬੈਕਸਲੈਸ਼ ਤੋਂ ਬਾਅਦ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਅੱਖਰ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਲਾਈਨ ਬ੍ਰੇਕ ਨੂੰ ਦਰਸਾਉਣ ਲਈ n। ਇੱਕ ਹੋਰ ਵਿਕਲਪ UTF-8 ਇੰਕੋਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ, ਜੋ ਵੱਖ-ਵੱਖ ਭਾਸ਼ਾਵਾਂ ਦੇ ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਨੂੰ ਪ੍ਰਸਤੁਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਜਾਵਾ ਵਿੱਚ, ਉਚਿਤ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਫਾਈਲਰਾਈਟਰ ਜਾਂ ਬਫਰਡ ਰਾਈਟਰ ਕਿਸਮ ਦਾ ਇੱਕ ਆਬਜੈਕਟ ਬਣਾਉਣ ਵੇਲੇ ਏਨਕੋਡਿੰਗ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਅਤੇ ਏਨਕੋਡਿੰਗਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਜਾਂ ਲਿਖਣ ਦੇ ਤਰੀਕੇ 'ਤੇ ਵੀ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਦੇ ਸਮੇਂ, ਫਾਈਲ ਰੀਡਰ ਜਾਂ ਬਫਰਡ ਰੀਡਰ ਕਿਸਮ ਦਾ ਇੱਕ ਆਬਜੈਕਟ ਬਣਾਉਣ ਵੇਲੇ ਵਰਤੀ ਗਈ ਏਨਕੋਡਿੰਗ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੈ। ਨਾਲ ਹੀ, ਜਦੋਂ ਇੱਕ ਫਾਈਲ ਨੂੰ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਟੈਕਸਟ ਨੂੰ ਢੁਕਵੀਂ ਏਨਕੋਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਹੀ ਢੰਗ ਨਾਲ ਏਨਕੋਡ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸਦੇ ਲਈ, ਅਸੀਂ ਰਾਈਟ() ਜਾਂ ਐਪੈਂਡ() ਵਰਗੇ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ 'ਤੇ ਸੰਬੰਧਿਤ ਏਨਕੋਡਿੰਗ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹਾਂ।

8. ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਜਾਂ ਸੋਧਣਾ ਹੈ

Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਜੋੜਨ ਜਾਂ ਸੋਧਣ ਲਈ, ਤੁਹਾਨੂੰ ਕਈ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਪਹਿਲਾਂ, ਸਾਨੂੰ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਾਈਲ ਨੂੰ ਲਿਖਣ ਮੋਡ ਵਿੱਚ ਖੋਲ੍ਹਣ ਦੀ ਲੋੜ ਹੈ ਫਾਈਲਰਾਇਟਰ ਅਤੇ ਫਾਇਲ ਮਾਰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਫਿਰ ਅਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ write() ਫਾਈਲ ਵਿੱਚ ਲੋੜੀਂਦਾ ਟੈਕਸਟ ਜੋੜਨ ਜਾਂ ਸੋਧਣ ਲਈ। ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਇਹ ਵਿਧੀ ਮੌਜੂਦਾ ਸਮੱਗਰੀ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰ ਦੇਵੇਗੀ ਜੇਕਰ ਫਾਈਲ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ।

ਬਲਾਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਕਿਸੇ ਵੀ ਅਪਵਾਦ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫਾਈਲ ਓਪਰੇਸ਼ਨਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਜੋ ਹੋ ਸਕਦਾ ਹੈ। ਕੋਸ਼ਿਸ਼ ਬਲਾਕ ਦੇ ਅੰਦਰ, ਇੱਕ ਫਾਈਲਰਾਈਟਰ ਉਦਾਹਰਣ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਮੱਗਰੀ ਨੂੰ ਜੋੜਨ ਜਾਂ ਸੋਧਣ ਲਈ ਲਿਖਣ ਦਾ ਤਰੀਕਾ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਅੱਗੇ, ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ close() ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਸਾਰੇ ਓਪਰੇਸ਼ਨ ਸਹੀ ਢੰਗ ਨਾਲ ਸੁਰੱਖਿਅਤ ਕੀਤੇ ਗਏ ਹਨ ਅਤੇ ਵਰਤੇ ਗਏ ਸਰੋਤਾਂ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਸਮੱਗਰੀ ਨੂੰ ਜੋੜਨਾ ਜਾਂ ਸੋਧਣਾ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਕੁਝ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਸ਼ਾਮਲ ਕਰੋ () ਸਗੋਂ write() ਮੌਜੂਦਾ ਸਮੱਗਰੀ ਨੂੰ ਓਵਰਰਾਈਟ ਕੀਤੇ ਬਿਨਾਂ ਫਾਈਲ ਦੇ ਅੰਤ ਵਿੱਚ ਟੈਕਸਟ ਜੋੜਨ ਲਈ। ਤੁਸੀਂ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ ਬਫਰਡ ਰਾਈਟਰ ਫਾਈਲ ਵਿੱਚ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਡੇਟਾ ਲਿਖਣ ਵੇਲੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ਲਈ। ਇਹਨਾਂ ਸਾਧਨਾਂ ਅਤੇ ਤਕਨੀਕਾਂ ਨੂੰ ਹੱਲ ਕੀਤੀ ਜਾ ਰਹੀ ਸਮੱਸਿਆ ਦੀਆਂ ਖਾਸ ਲੋੜਾਂ ਅਨੁਸਾਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

9. Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਕਸਟ ਖੋਜੋ ਅਤੇ ਬਦਲੋ

ਜਾਵਾ ਵਿੱਚ, ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਕਸਟ ਨੂੰ ਖੋਜਣਾ ਅਤੇ ਬਦਲਣਾ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿੱਚ ਇੱਕ ਆਮ ਕੰਮ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਵੱਖ-ਵੱਖ ਲੋੜਾਂ ਅਤੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਇਸ ਸਥਿਤੀ ਤੱਕ ਪਹੁੰਚਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ। ਇਸ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਹੇਠਾਂ ਕੁਝ ਵਿਕਲਪ ਅਤੇ ਉਦਾਹਰਨਾਂ ਹਨ।

ਬਫਰਡ ਰੀਡਰ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ: ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਕਸਟ ਲੱਭਣ ਅਤੇ ਬਦਲਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ ਬਫਰਡ ਰੀਡਰ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ। ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਾਈਲ ਨੂੰ ਖੋਲ੍ਹਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਲਾਈਨ ਦਰ ਲਾਈਨ ਪੜ੍ਹਨਾ ਚਾਹੀਦਾ ਹੈ। ਪੜ੍ਹਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਲੋੜੀਂਦੇ ਟੈਕਸਟ ਨੂੰ ਲੱਭਣ ਅਤੇ ਬਦਲਣ ਲਈ ਬਦਲੋ ਸਾਰੇ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਅੰਤ ਵਿੱਚ, ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ BufferedReader ਜਾਂ FileWriter ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੋਧੀ ਹੋਈ ਫਾਈਲ ਨੂੰ ਲਿਖ ਸਕਦੇ ਹੋ।

ਅਪਾਚੇ ਕਾਮਨਜ਼ IO ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ: ਇੱਕ ਹੋਰ ਵਿਕਲਪ ਅਪਾਚੇ ਕਾਮਨਜ਼ IO ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ, ਜੋ Java ਵਿੱਚ ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਉਪਯੋਗਤਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਤੁਸੀਂ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ FileUtils ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਟੈਕਸਟ ਨੂੰ ਲੱਭਣ ਅਤੇ ਬਦਲਣ ਲਈ, ਤੁਸੀਂ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ readFileToString ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ ਰੀਪਲੇਸ ਓਪਰੇਸ਼ਨ ਕਰਨ ਲਈ ਰੀਪਲੇਸ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਅੰਤ ਵਿੱਚ, ਸੋਧੀ ਹੋਈ ਫਾਈਲ ਨੂੰ writeStringToFile ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਨਿਯਮਿਤ ਸਮੀਕਰਨ: ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਖੋਜ ਅਤੇ ਬਦਲਣ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਟੂਲ ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਹੈ। ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਤੁਹਾਨੂੰ ਟੈਕਸਟ ਪੈਟਰਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ ਜੋ ਖੋਜ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਰੈਗੂਲਰ ਸਮੀਕਰਨਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਮੇਲ ਜਾਂ ਸਟ੍ਰਿੰਗ ਕਲਾਸ ਦੇ ਸਾਰੇ ਬਦਲਣ ਵਰਗੀਆਂ ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, java.util.regex ਪੈਕੇਜ ਰੈਗੂਲਰ ਸਮੀਕਰਨਾਂ ਨਾਲ ਵਧੇਰੇ ਸਹੀ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵਧੇਰੇ ਉੱਨਤ ਕਲਾਸਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਇਹਨਾਂ ਵਿਕਲਪਾਂ ਅਤੇ ਉਦਾਹਰਨਾਂ ਦੇ ਨਾਲ, ਤੁਹਾਡੇ ਕੋਲ ਹੁਣ Java ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਕਸਟ ਲੱਭਣ ਅਤੇ ਬਦਲਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ। ਭਾਵੇਂ ਬਫਰਡ ਰੀਡਰ ਕਲਾਸ, ਅਪਾਚੇ ਕਾਮਨਜ਼ IO ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਜਾਂ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀਆਂ ਖਾਸ ਲੋੜਾਂ ਅਤੇ ਲੋੜਾਂ ਅਨੁਸਾਰ ਆਪਣੇ ਹੱਲ ਨੂੰ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ। ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਕੀ ਹੈ ਉਸ ਅਨੁਸਾਰ ਹਰ ਇੱਕ ਪਹੁੰਚ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਹਮੇਸ਼ਾ ਯਾਦ ਰੱਖੋ।

10. Java ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਮਿਟਾਉਣਾ ਹੈ

11. ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ Java ਵਿੱਚ ਡਾਇਰੈਕਟਰੀ ਅਤੇ ਫਾਈਲ ਪ੍ਰਬੰਧਨ

Java ਵਿੱਚ ਡਾਇਰੈਕਟਰੀਆਂ ਅਤੇ ਫਾਈਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਕੰਮ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਜਾਵਾ ਕਈ ਕਲਾਸਾਂ ਅਤੇ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਇਸ ਕੰਮ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ। ਹੇਠਾਂ ਏ ਕਦਮ-ਦਰ-ਕਦਮ ਟਿਊਟੋਰਿਅਲ Java ਵਿੱਚ ਡਾਇਰੈਕਟਰੀਆਂ ਅਤੇ ਫਾਈਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਿਵੇਂ ਕਰਨਾ ਹੈ।

ਪਹਿਲਾ ਕਦਮ: Java ਵਿੱਚ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਬਣਾਓ। Java ਵਿੱਚ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਬਣਾਉਣ ਲਈ, ਤੁਸੀਂ File ਕਲਾਸ ਅਤੇ ਇਸਦੀ mkdir() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਸਿਰਫ਼ ਡਾਇਰੈਕਟਰੀ ਦਾ ਮਾਰਗ ਦਿਓ ਜੋ ਤੁਸੀਂ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ mkdir() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰੋ।

ਦੂਜਾ ਕਦਮ: Java ਵਿੱਚ ਫਾਈਲਾਂ ਪੜ੍ਹੋ ਅਤੇ ਲਿਖੋ। Java ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ, ਤੁਸੀਂ BufferedReader ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਕਲਾਸ ਰੀਡਲਾਈਨ () ਵਿਧੀ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਜੋ ਫਾਈਲ ਤੋਂ ਟੈਕਸਟ ਦੀ ਇੱਕ ਲਾਈਨ ਪੜ੍ਹਦੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਲਿਖਣ ਲਈ, ਤੁਸੀਂ ਬਫਰਡ ਰਾਈਟਰ ਕਲਾਸ ਅਤੇ ਇਸਦੀ ਰਾਈਟ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਸੰਭਾਵਿਤ ਮੈਮੋਰੀ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਲਈ close() ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੰਬੰਧਿਤ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਨੂੰ ਬੰਦ ਕਰਨਾ ਯਾਦ ਰੱਖੋ।

12. ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੀ ਰਚਨਾ ਅਤੇ ਹੇਰਾਫੇਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੀ ਰਚਨਾ ਅਤੇ ਹੇਰਾਫੇਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਬਹੁਤ ਉਪਯੋਗੀ ਸਾਧਨ ਹਨ। ਇਹ ਲਾਇਬ੍ਰੇਰੀਆਂ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਫੰਕਸ਼ਨ ਅਤੇ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ ਜੋ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਕਸਟਮ ਕੋਡ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਵਿੱਚ ਸਮਾਂ ਅਤੇ ਮਿਹਨਤ ਦੀ ਬਚਤ ਕਰਦੀਆਂ ਹਨ। ਹੇਠਾਂ ਕੁਝ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ Java ਵਿੱਚ ਕਿਵੇਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

1. Apache Commons IO: ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਫਾਈਲ ਪ੍ਰਬੰਧਨ ਉਪਯੋਗਤਾਵਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਬਣਾਉਣਾ, ਲਿਖਣਾ ਅਤੇ ਪੜ੍ਹਨਾ ਸ਼ਾਮਲ ਹੈ। ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਮੂਲ ਕਾਰਵਾਈਆਂ ਜਿਵੇਂ ਕਿ ਕਾਪੀ ਕਰਨਾ, ਨਾਮ ਬਦਲਣਾ ਅਤੇ ਫਾਈਲਾਂ ਨੂੰ ਮਿਟਾਉਣਾ, ਨਾਲ ਹੀ ਡਾਇਰੈਕਟਰੀਆਂ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਇੰਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ।

2. OpenCSV: ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ CSV (ਕੌਮਾ ਵੱਖ ਕੀਤੇ ਮੁੱਲ) ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਉਪਯੋਗੀ ਹੈ, ਜੋ ਕਿ ਡੇਟਾ ਐਕਸਚੇਂਜ ਵਿੱਚ ਬਹੁਤ ਆਮ ਹਨ। ਵੱਖ-ਵੱਖ ਸਿਸਟਮ. OpenCSV ਇੱਕ CSV ਫਾਈਲ ਤੋਂ ਡੇਟਾ ਐਕਸਟਰੈਕਟ ਕਰਨ ਅਤੇ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇਸਦੀ ਅੱਗੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। CSV ਫਾਰਮੈਟ ਵਿੱਚ ਡਾਟਾ ਰਿਕਾਰਡਾਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੇ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਡਾਟਾ ਖੇਤਰਾਂ ਤੱਕ ਆਸਾਨ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

3. Gson: ਇਹ ਲਾਇਬ੍ਰੇਰੀ JSON (JavaScript ਆਬਜੈਕਟ ਨੋਟੇਸ਼ਨ) ਫਾਰਮੈਟ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। Gson ਜਾਵਾ ਆਬਜੈਕਟਸ ਨੂੰ JSON ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਉਲਟ। ਇਹ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇੱਕ Java ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਇੱਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਜੋ ਸੰਚਾਰ ਲਈ JSON ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਵਿਚਕਾਰ ਡੇਟਾ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। Gson JSON ਫਾਈਲਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨ ਅਤੇ ਬਣਾਉਣ ਦੀ ਵੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਗੁੰਝਲਦਾਰ ਡਾਟਾ ਢਾਂਚੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ।

ਸੰਖੇਪ ਵਿੱਚ, ਜਾਵਾ ਵਿੱਚ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਤੁਹਾਨੂੰ ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੀ ਰਚਨਾ ਅਤੇ ਹੇਰਾਫੇਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ. ਇਹ ਲਾਇਬ੍ਰੇਰੀਆਂ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਫੰਕਸ਼ਨ ਅਤੇ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ ਜੋ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਸਬੰਧਤ ਕਾਰਜਾਂ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਵਿੱਚ ਸਮਾਂ ਅਤੇ ਮਿਹਨਤ ਦੀ ਬਚਤ ਕਰਦੀਆਂ ਹਨ। ਕੁਝ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ Apache Commons IO, OpenCSV, ਅਤੇ Gson ਸ਼ਾਮਲ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਵੱਖ-ਵੱਖ ਕਿਸਮ ਦੀਆਂ ਟੈਕਸਟ ਫਾਈਲਾਂ ਲਈ ਖਾਸ ਕਾਰਜਸ਼ੀਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

13. ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਅਤੇ ਵੰਡਣਾ ਹੈ

ਜਦੋਂ ਤੁਸੀਂ ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਆਮ ਗੱਲ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਦੀ ਸਮਗਰੀ ਨੂੰ ਆਪਣੀਆਂ ਲੋੜਾਂ ਅਨੁਸਾਰ ਜੋੜਨ ਜਾਂ ਵੰਡਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, Java ਟੂਲ ਅਤੇ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਇਸ ਕੰਮ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦੇ ਹਨ। ਹੇਠਾਂ ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਜੋੜਨ ਅਤੇ ਵੰਡਣ ਲਈ ਤਿੰਨ ਵੱਖ-ਵੱਖ ਤਰੀਕੇ ਹਨ:

1. FileWriter ਕਲਾਸ ਦੀ append() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

• FileWriter ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਰੋਤ ਫਾਈਲ ਅਤੇ ਮੰਜ਼ਿਲ ਫਾਈਲ ਖੋਲ੍ਹੋ.
• ਸਰੋਤ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਪੜ੍ਹਨ ਲਈ BufferedReader ਦੀ ਵਰਤੋਂ ਕਰੋ।
• ਸਰੋਤ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਮੰਜ਼ਿਲ ਫਾਈਲ ਵਿੱਚ ਲਿਖਣ ਲਈ FileWriter ਦੀ append() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।
• ਲਿਖਣ ਤੋਂ ਬਾਅਦ ਫਾਈਲਾਂ ਨੂੰ ਬੰਦ ਕਰੋ।

2. Java.nio ਫਾਈਲਾਂ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

• ਸਰੋਤ ਫਾਈਲ ਤੋਂ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਫਾਈਲ ਕਲਾਸ ਦੀ readAllLines() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।
• StringJoiner ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਿੰਗਲ ਟੈਕਸਟ ਸਤਰ ਵਿੱਚ ਲਾਈਨਾਂ ਨੂੰ ਜੋੜੋ।
• ਸੰਯੁਕਤ ਸਮੱਗਰੀ ਨੂੰ ਮੰਜ਼ਿਲ ਫਾਈਲ ਵਿੱਚ ਲਿਖਣ ਲਈ ਫਾਈਲਾਂ ਕਲਾਸ ਦੀ ਰਾਈਟ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

3. ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਜਿਵੇਂ ਕਿ Apache Commons IO

• ਅਪਾਚੇ ਕਾਮਨਜ਼ IO ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ।
• Static writeLines() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਾਈਲਾਂ ਨੂੰ ਜੋੜਨ ਲਈ FileUtils ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ।
• ਲਈ ਇੱਕ ਫਾਈਲ ਵੰਡੋ, ਸਪਲਿਟਰ ਕਲਾਸ ਦੀ ਸਟੈਟਿਕ ਸਪਲਿਟ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

14. ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ ਅਤੇ ਸਿਫ਼ਾਰਿਸ਼ਾਂ

ਜਾਵਾ ਵਿੱਚ, ਐਪਲੀਕੇਸ਼ਨ ਡਿਵੈਲਪਮੈਂਟ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਇੱਕ ਆਮ ਕੰਮ ਹੈ। ਇਸ ਕੰਮ ਨੂੰ ਆਸਾਨ ਬਣਾਉਣ ਅਤੇ ਸੰਭਾਵੀ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਹੇਠਾਂ ਕੁਝ ਵਧੀਆ ਅਭਿਆਸ ਅਤੇ ਸਿਫ਼ਾਰਸ਼ਾਂ ਹਨ।

1. FileReader ਅਤੇ FileWriter ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ: Java ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਇਹ ਕਲਾਸਾਂ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ ਆਸਾਨ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਤੁਸੀਂ ਮੈਮੋਰੀ ਲੀਕ ਤੋਂ ਬਚਣ ਲਈ ਸਟ੍ਰੀਮਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਬੰਦ ਕਰਦੇ ਹੋ। ਸਟ੍ਰੀਮਾਂ ਦੇ ਆਟੋਮੈਟਿਕ ਬੰਦ ਹੋਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਸਰੋਤਾਂ ਦੇ ਨਾਲ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਵਾਲੇ ਬਲਾਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

2. ਪਾਥ ਹੇਰਾਫੇਰੀ: ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਮਾਰਗਾਂ ਦੀ ਸਹੀ ਹੇਰਾਫੇਰੀ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇਹਨਾਂ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ ਅਤੇ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਜਾਵਾ ਦੇ ਪਾਥ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਸਾਪੇਖਿਕ ਜਾਂ ਸੰਪੂਰਨ ਮਾਰਗਾਂ ਨਾਲ ਕੰਮ ਕਰਨ, ਅਤੇ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇੱਕ ਫਾਈਲ ਨੂੰ ਖੋਲ੍ਹਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸ ਦੀ ਮੌਜੂਦਗੀ ਨੂੰ ਜੋੜਨਾ ਜਾਂ ਇਸ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨਾ।

3. ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਦਾ ਇਲਾਜ: ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਦੇ ਜਾਂ ਲਿਖਣ ਵੇਲੇ, ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਸੰਭਵ ਹੁੰਦਾ ਹੈ ਜੋ ਜਾਣਕਾਰੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹਨ। ਪੜ੍ਹਨ ਜਾਂ ਲਿਖਣ ਦੀਆਂ ਸਟ੍ਰੀਮਾਂ ਨੂੰ ਖੋਲ੍ਹਣ ਵੇਲੇ ਅੱਖਰ ਇੰਕੋਡਿੰਗ ਦੀ ਸਹੀ ਵਰਤੋਂ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। InputStreamReader ਕਲਾਸ ਲੋੜੀਦੀ ਏਨਕੋਡਿੰਗ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਅੱਖਰ ਵਿਆਖਿਆ ਵਿੱਚ ਗਲਤੀਆਂ ਤੋਂ ਬਚਿਆ ਜਾਂਦਾ ਹੈ।

ਇਹਨਾਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਅਤੇ ਸਿਫ਼ਾਰਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ Java ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੇ ਨਾਲ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ ਅਤੇ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੋਗੇ। ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਅਤੇ ਵਿਸਤ੍ਰਿਤ ਉਦਾਹਰਣਾਂ ਲਈ ਅਧਿਕਾਰਤ Java ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਹਮੇਸ਼ਾਂ ਯਾਦ ਰੱਖੋ। ਤੁਹਾਡੇ ਵਿਕਾਸ ਵਿੱਚ ਚੰਗੀ ਕਿਸਮਤ!

ਸਿੱਟੇ ਵਜੋਂ, ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਬਣਾਉਣਾ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸ ਲਈ ਸਪਸ਼ਟ ਅਤੇ ਸਟੀਕ ਕਦਮਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। FileWriter ਅਤੇ BufferedWriter ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਦੁਆਰਾ, ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਅਤੇ ਜਟਿਲਤਾਵਾਂ ਤੋਂ ਬਿਨਾਂ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹਾਂ।

ਸਹੀ ਫਾਈਲ ਟਿਕਾਣਾ ਅਤੇ ਨਾਮ ਸੈਟ ਕਰਨਾ ਯਾਦ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਨਾਲ ਹੀ ਲਿਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਅਪਵਾਦ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣਾ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਲਿਖਣਾ ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ ਫਾਈਲ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਬੰਦ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਢੁਕਵੇਂ ਢੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਿ ਸਮੱਗਰੀ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਕੋਈ ਡਾਟਾ ਨੁਕਸਾਨ ਨਹੀਂ ਹੁੰਦਾ।

ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਬਣਾਉਣਾ ਸਾਨੂੰ ਇੱਕ ਢਾਂਚਾਗਤ ਅਤੇ ਪੜ੍ਹਨਯੋਗ ਤਰੀਕੇ ਨਾਲ ਜਾਣਕਾਰੀ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਵੱਖ-ਵੱਖ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਤੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਬਹੁਤ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ।

ਸੰਖੇਪ ਵਿੱਚ, ਜਾਵਾ ਵਿੱਚ ਟੈਕਸਟ ਫਾਈਲਾਂ ਦੀ ਰਚਨਾ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮਰ ਲਈ ਇੱਕ ਬੁਨਿਆਦੀ ਹੁਨਰ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਸਾਨੂੰ ਡੇਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣ ਅਤੇ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਫਾਈਲਰਾਈਟਰ ਅਤੇ ਬਫਰਡ ਰਾਈਟਰ ਕਲਾਸਾਂ ਦੇ ਨਾਲ, ਅਸੀਂ ਬਿਨਾਂ ਕਿਸੇ ਮੁਸ਼ਕਲ ਦੇ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਬਣਾ ਅਤੇ ਲਿਖ ਸਕਦੇ ਹਾਂ, ਇਸ ਤਰ੍ਹਾਂ ਸਾਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਤਕਨੀਕੀ ਅਤੇ ਕੁਸ਼ਲ ਹੱਲ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹਾਂ।