Java asoslari 10-qism. I/O

I/O - bu Input / Output degani.

Java’da I/O va files mavzusi quyidagilar uchun kerak:

• fayl o‘qish;

• faylga yozish;

• papka yaratish;

• fayl mavjudligini tekshirish;

• faylni o‘chirish;

• text fayllar bilan ishlash;

• binary fayllar bilan ishlash;

• stream orqali data uzatish;

• katta fayllarni samarali o‘qish.

Bu bo‘limga quyidagilar kiradi: File, Path, Files (NIO.2), InputStream / OutputStream, Reader / Writer, BufferedReader / BufferedWriter, Serialization basics.

1. I/O nima?

Input - tashqaridan ma’lumot olish.

Masalan:

file -> Java application
keyboard -> Java application
network -> Java application

Output - Java application’dan tashqariga ma’lumot chiqarish.

Masalan:

Java application -> file
Java application -> console
Java application -> network

Oddiy misol:

System.out.println("Hello");

Bu ham output. Chunki Java console’ga ma’lumot chiqaryapti.

2. Java’da fayl bilan ishlashning ikki asosiy yo‘li

Java’da fayl bilan ishlash uchun ikki avlod API bor:

Hozirgi real loyihalarda ko‘proq shuni ishlatish kerak:

Path
Files

3. File class

File - eski class. Fayl yoki papka yo‘lini ifodalaydi.

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File file = new File("data.txt");

        System.out.println(file.exists());
        System.out.println(file.getName());
        System.out.println(file.getAbsolutePath());
    }
}

Bu yerda:

new File("data.txt")

data.txt degan faylga yo‘l yaratadi.

Muhim: File obyekt yaratish faylni yaratmaydi. U faqat faylga yo‘lni ifodalaydi.

3.1 Fayl mavjudligini tekshirish

File file = new File("data.txt");

if (file.exists()) {
    System.out.println("Fayl mavjud");
} else {
    System.out.println("Fayl mavjud emas");
}

3.2 Fayl yaratish

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        File file = new File("data.txt");

        boolean created = file.createNewFile();

        if (created) {
            System.out.println("Fayl yaratildi");
        } else {
            System.out.println("Fayl oldindan mavjud");
        }
    }
}

createNewFile() checked exception tashlashi mumkin. Shuning uchun throws IOException yozildi.

3.3 Papka yaratish

File folder = new File("uploads");

boolean created = folder.mkdir();

System.out.println(created);

Agar ichma-ich papkalar yaratish kerak bo‘lsa:

File folder = new File("uploads/images/avatars");

boolean created = folder.mkdirs();

Farqi:

4. Path

Path - fayl yoki papkaga yo‘lni ifodalovchi zamonaviy class.

import java.nio.file.Path;

public class Main {
    public static void main(String[] args) {
        Path path = Path.of("data.txt");

        System.out.println(path.getFileName());
        System.out.println(path.toAbsolutePath());
    }
}

Path.of() Java 11+ da qulay ishlatiladi.

Eskiroq variant:

Path path = Paths.get("data.txt");

5. Files

Files - fayllar bilan ishlash uchun utility class.

U orqali:

• fayl yaratish;

• fayl o‘qish;

• faylga yozish;

• fayl o‘chirish;

• fayl mavjudligini tekshirish;

• papka yaratish;

mumkin.

5.1 Fayl mavjudligini tekshirish

import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) {
        Path path = Path.of("data.txt");

        if (Files.exists(path)) {
            System.out.println("Fayl mavjud");
        } else {
            System.out.println("Fayl mavjud emas");
        }
    }
}

5.2 Fayl yaratish

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("data.txt");

        if (!Files.exists(path)) {
            Files.createFile(path);
        }
    }
}

5.3 Papka yaratish

Path folder = Path.of("uploads");

if (!Files.exists(folder)) {
    Files.createDirectory(folder);
}

Ichma-ich papkalar uchun:

Path folder = Path.of("uploads/images/avatars");

Files.createDirectories(folder);

Real loyihalarda ko‘pincha createDirectories() ishlatiladi. Chunki parent papkalar bo‘lmasa ham yaratib beradi.

6. Faylga text yozish

Eng oddiy usul:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("data.txt");

        Files.writeString(path, "Hello Java");
    }
}

Natijada data.txt ichiga quyidagi text yoziladi:

Hello Java

Agar fayl mavjud bo‘lmasa, Java uni yaratadi.

6.1 Faylga bir nechta qator yozish

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("users.txt");

        List<String> users = List.of("Ali", "Vali", "Hasan");

        Files.write(path, users);
    }
}

users.txt ichida:

Ali
Vali
Hasan

6.2 Faylga oxiridan qo‘shib yozish

Oddiy writeString() eski textni o‘chirib, yangisini yozadi.

Agar oxiridan qo‘shib yozmoqchi bo‘lsak:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("logs.txt");

        Files.writeString(
                path,
                "Application started\n",
                StandardOpenOption.CREATE,
                StandardOpenOption.APPEND
        );
    }
}

Bu yerda:

7. Fayldan text o‘qish

7.1 Butun faylni String qilib o‘qish

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("data.txt");

        String content = Files.readString(path);

        System.out.println(content);
    }
}

Bu kichik fayllar uchun qulay.

7.2 Faylni qatorlar bo‘yicha o‘qish

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("users.txt");

        List<String> lines = Files.readAllLines(path);

        for (String line : lines) {
            System.out.println(line);
        }
    }
}

Bu ham kichik va o‘rtacha fayllar uchun qulay.

8. Katta faylni qanday o‘qish kerak?

Files.readAllLines() butun faylni xotiraga yuklaydi.

Agar fayl juda katta bo‘lsa, bu yomon:

List<String> lines = Files.readAllLines(path);

Chunki RAM ko‘p ishlatiladi.

Katta fayllar uchun BufferedReader yaxshi.

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("large-file.txt");

        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

Bu faylni qator-qator o‘qiydi. Butun faylni birdan RAMga yuklamaydi.

9. try-with-resources

I/O’da resurslar bor:

• file stream;

• reader;

• writer;

• database connection;

• socket.

Bularni ishlatib bo‘lgach yopish kerak.

Eski usul:

BufferedReader reader = null;

try {
    reader = Files.newBufferedReader(Path.of("data.txt"));
    System.out.println(reader.readLine());
} finally {
    if (reader != null) {
        reader.close();
    }
}

Yangi va toza usul:

try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
    System.out.println(reader.readLine());
}

Bu try-with-resources deyiladi.

Java avtomatik reader.close() qiladi.

10. Reader / Writer

Reader va Writer - text data bilan ishlash uchun ishlatiladi.

Ya’ni:

String, char, text file

uchun.

10.1 BufferedReader

BufferedReader - textni samarali o‘qish uchun.

Path path = Path.of("users.txt");

try (BufferedReader reader = Files.newBufferedReader(path)) {
    String line;

    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

10.2 BufferedWriter

BufferedWriter - textni samarali yozish uchun.

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("users.txt");

        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
            writer.write("Ali");
            writer.newLine();
            writer.write("Vali");
            writer.newLine();
            writer.write("Hasan");
        }
    }
}

Natija:

Ali
Vali
Hasan

11. InputStream / OutputStream

InputStream va OutputStream - binary data bilan ishlash uchun.

Ya’ni:

• rasm;

• video;

• audio;

• PDF;

• zip;

• byte data;

uchun.

Text uchun odatda Reader/Writer, binary uchun InputStream/OutputStream.

11.1 InputStream

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("image.png");

        try (InputStream inputStream = Files.newInputStream(path)) {
            byte[] bytes = inputStream.readAllBytes();

            System.out.println("File size: " + bytes.length);
        }
    }
}

Bu kichik binary fayllar uchun ishlaydi.

11.2 OutputStream

import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("output.bin");

        byte[] data = {65, 66, 67};

        try (OutputStream outputStream = Files.newOutputStream(path)) {
            outputStream.write(data);
        }
    }
}

Bu output.bin ichiga byte yozadi.

12. Fayl copy qilish

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class Main {
    public static void main(String[] args) throws IOException {
        Path source = Path.of("data.txt");
        Path target = Path.of("backup/data-copy.txt");

        Files.createDirectories(target.getParent());

        Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
    }
}

Bu yerda:

StandardCopyOption.REPLACE_EXISTING

agar target fayl oldin mavjud bo‘lsa, almashtiradi.

13. Fayl move qilish

Path source = Path.of("data.txt");
Path target = Path.of("archive/data.txt");

Files.createDirectories(target.getParent());

Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);

Bu faylni boshqa joyga ko‘chiradi.

14. Fayl o‘chirish

Path path = Path.of("data.txt");

Files.delete(path);

Agar fayl bo‘lmasa, exception beradi.

Xavfsizroq variant:

Files.deleteIfExists(path);

15. Fayl haqida ma’lumot olish

Path path = Path.of("data.txt");

System.out.println(Files.size(path));
System.out.println(Files.isRegularFile(path));
System.out.println(Files.isDirectory(path));
System.out.println(Files.getLastModifiedTime(path));

16. Papkadagi fayllarni ko‘rish

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) throws IOException {
        Path folder = Path.of("uploads");

        try (Stream<Path> paths = Files.list(folder)) {
            paths.forEach(System.out::println);
        }
    }
}

Files.list() stream qaytaradi. Shu sababli try-with-resources bilan yopish yaxshi.

17. Papka ichidan fayl qidirish

Path folder = Path.of("uploads");

try (Stream<Path> paths = Files.walk(folder)) {
    paths
            .filter(Files::isRegularFile)
            .filter(path -> path.toString().endsWith(".jpg"))
            .forEach(System.out::println);
}

Bu uploads ichidagi barcha .jpg fayllarni topadi.

18. Encoding

Text fayllar bilan ishlaganda encoding muhim.

Masalan, o‘zbekcha harflar:

o', g', sh, ch

Yoki kirill, ruscha, emoji ishlatilsa encoding kerak.

Tavsiya: UTF-8 ishlating.

import java.nio.charset.StandardCharsets;

Path path = Path.of("data.txt");

Files.writeString(path, "Salom o‘zbek tili", StandardCharsets.UTF_8);

String content = Files.readString(path, StandardCharsets.UTF_8);

19. Serialization basics

Serialization - obyektni byte ko‘rinishga o‘tkazish.

Deserialization - byte’dan obyektni qayta tiklash.

Masalan:

User object -> bytes -> file
file -> bytes -> User object

19.1 Serializable class

import java.io.Serializable;

public class User implements Serializable {
    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}

Serializable marker interface. Ichida method yo‘q.

19.2 ObjectOutputStream bilan yozish

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) throws IOException {
        User user = new User(1L, "Ali");

        try (ObjectOutputStream outputStream =
                     new ObjectOutputStream(new FileOutputStream("user.ser"))) {

            outputStream.writeObject(user);
        }
    }
}

19.3 ObjectInputStream bilan o‘qish

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Main {
    public static void main(String[] args)
            throws IOException, ClassNotFoundException {

        try (ObjectInputStream inputStream =
                     new ObjectInputStream(new FileInputStream("user.ser"))) {

            User user = (User) inputStream.readObject();

            System.out.println(user);
        }
    }
}

19.4 Serialization haqida muhim ogohlantirish

Java native serialization real production’da ehtiyotkorlik bilan ishlatiladi.

Sabablari:

• security risk bo‘lishi mumkin;

• class o‘zgarsa muammo chiqadi;

• format odam o‘qiydigan emas;

• microservice/API’da odatda JSON ishlatiladi.

Real backend’da ko‘proq:

Object -> JSON -> HTTP response
JSON -> Object -> Java DTO

ishlatiladi.

Masalan, Spring Boot’da Jackson kutubxonasi objectni JSONga o‘giradi.

20. Text vs Binary farqi

Qoida:

Text bo‘lsa Reader/Writer.
Binary bo‘lsa InputStream/OutputStream.

21. Real backend misol: uploaded file saqlash

Masalan, Spring Boot’da user rasm yuklaydi. Uni diskka saqlash kerak.

Oddiy Java ko‘rinishi:

public class FileStorageService {
    private final Path uploadDir = Path.of("uploads");

    public void save(String fileName, byte[] bytes) throws IOException {
        Files.createDirectories(uploadDir);

        Path target = uploadDir.resolve(fileName);

        Files.write(target, bytes);
    }
}

Ishlatish:

FileStorageService storageService = new FileStorageService();

storageService.save("avatar.png", imageBytes);

22. Real backend misol: log faylga yozish

public class SimpleLogger {
    private final Path logFile = Path.of("logs/app.log");

    public void log(String message) throws IOException {
        Files.createDirectories(logFile.getParent());

        Files.writeString(
                logFile,
                message + System.lineSeparator(),
                StandardOpenOption.CREATE,
                StandardOpenOption.APPEND
        );
    }
}

Ishlatish:

SimpleLogger logger = new SimpleLogger();

logger.log("Application started");
logger.log("User created");
logger.log("Order paid");

23. CSV fayl o‘qish

users.csv:

id,name,age
1,Ali,25
2,Vali,30
3,Hasan,22

Java’da o‘qish:

Path path = Path.of("users.csv");

try (BufferedReader reader = Files.newBufferedReader(path)) {
    String line;

    reader.readLine(); // headerni o'tkazib yuboramiz

    while ((line = reader.readLine()) != null) {
        String[] parts = line.split(",");

        Long id = Long.parseLong(parts[0]);
        String name = parts[1];
        int age = Integer.parseInt(parts[2]);

        System.out.println(id + " " + name + " " + age);
    }
}

Katta CSV fayllar uchun bu yondashuv readAllLines()dan yaxshiroq.

24. Exception handling

Fayl bilan ishlaganda ko‘p methodlar IOException tashlaydi.

Yuqoriga uzatish:

public void readFile() throws IOException {
    String content = Files.readString(Path.of("data.txt"));
}

Yoki ushlab olish:

public void readFile() {
    try {
        String content = Files.readString(Path.of("data.txt"));
        System.out.println(content);
    } catch (IOException e) {
        System.out.println("Fayl o'qishda xatolik: " + e.getMessage());
    }
}

Real loyihalarda exceptionni shunchaki System.out.println() qilish yetarli emas. Odatda log qilinadi.

25. Juniorlar qiladigan xatolar

Xato 1: Stream/Reader/Writer yopilmasligi

Yomon:

BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"));
String line = reader.readLine();

To‘g‘ri:

try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
    String line = reader.readLine();
}

Xato 2: Katta faylni readAllLines() bilan o‘qish

Yomon:

List<String> lines = Files.readAllLines(Path.of("large.csv"));

To‘g‘ri:

try (BufferedReader reader = Files.newBufferedReader(Path.of("large.csv"))) {
    String line;

    while ((line = reader.readLine()) != null) {
        // process line
    }
}

Xato 3: Fayl nomini tekshirmasdan saqlash

Yomon:

Path target = Path.of("uploads/" + fileName);

Agar fileName ichida ../ bo‘lsa, xavfli bo‘lishi mumkin.

Yaxshiroq:

Path uploadDir = Path.of("uploads").toAbsolutePath().normalize();
Path target = uploadDir.resolve(fileName).normalize();

if (!target.startsWith(uploadDir)) {
    throw new RuntimeException("Invalid file path");
}

Bu path traversal xavfini kamaytiradi.

Xato 4: Encodingni hisobga olmaslik

Yomon:

String content = Files.readString(path);

Yaxshiroq:

String content = Files.readString(path, StandardCharsets.UTF_8);

Ayniqsa o‘zbekcha, ruscha, maxsus belgilar bo‘lsa.

Xato 5: Fayl mavjud emasligini tekshirmaslik

String content = Files.readString(Path.of("data.txt"));

Agar fayl bo‘lmasa, exception chiqadi.

Yaxshi:

Path path = Path.of("data.txt");

if (Files.exists(path)) {
    String content = Files.readString(path);
}

26. Qaysi classni qachon ishlatamiz?

27. Amaliy mashq

Vazifa: User file manager

users.txt fayli bilan ishlaydigan kichik app yozing.

Talablar:

1. users.txt faylini yarating.

2. Faylga quyidagi userlarni yozing:

Ali
Vali
Hasan
Aziz

3. Faylni qator-qator o‘qing.

4. Faqat A harfi bilan boshlanadigan userlarni chiqaring.

5. Yangi user qo‘shing, masalan Sardor.

6. Fayl oxiriga qo‘shib yozing.

7. Fayl mavjud bo‘lmasa, avtomatik yarating.

Namunaviy yechim:

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("users.txt");

        Files.write(
                path,
                List.of("Ali", "Vali", "Hasan", "Aziz"),
                StandardCharsets.UTF_8,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING
        );

        try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
            String line;

            while ((line = reader.readLine()) != null) {
                if (line.startsWith("A")) {
                    System.out.println(line);
                }
            }
        }

        Files.writeString(
                path,
                "Sardor" + System.lineSeparator(),
                StandardCharsets.UTF_8,
                StandardOpenOption.CREATE,
                StandardOpenOption.APPEND
        );
    }
}

Bu kod:

• fayl yaratadi;

• userlarni yozadi;

• faylni qator-qator o‘qiydi;

• A bilan boshlanadiganlarni chiqaradi;

• oxiriga yangi user qo‘shadi.

Xulosa

I/O & Files Java’da tashqi ma’lumotlar bilan ishlash uchun kerak.

Asosiy eslab qoling:

Path path = Path.of("data.txt");

Files.writeString(path, "Hello");

String content = Files.readString(path);

try (BufferedReader reader = Files.newBufferedReader(path)) {
    // katta faylni qator-qator o‘qish
}

Junior darajada eng muhimlari:

• Path;

• Files;

• BufferedReader;

• BufferedWriter;

• InputStream;

• OutputStream;

• try-with-resources;

• IOException;

• UTF-8 encoding;

• katta fayllarni xotiraga birdan yuklamaslik.