import java.util.PriorityQueue;

public class Task110826 {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.add(5);
        pq.add(1);
        pq.add(3);
        pq.add(4);
        pq.add(2);

        System.out.print("Iterator: ");
        for (int x : pq) {
            System.out.print(x + " ");
        }
        System.out.println();

        System.out.print("Poll: ");
        while (!pq.isEmpty()) {
            System.out.print(pq.poll() + " ");
        }
    }
}

Self-describing data — это данные, которые содержат внутри себя или в непосредственной близости полное описание своей структуры (схему). Это позволяет любому потребителю, не имеющему предварительного знания о формате, корректно интерпретировать содержимое.

Big Data — это термин, обозначающий наборы данных, объём, скорость поступления и разнообразие которых настолько велики, что традиционные инструменты обработки не справляются с ними. Hadoop — это фреймворк для распределённой обработки Big Data на кластерах commodity-оборудования.

Schema Registry — это сервис (например, Confluent Schema Registry), который хранит версии схем Avro, Protobuf и JSON Schema. Producer регистрирует схему и получает уникальный ID. Consumer получает ID вместе с сообщением и запрашивает схему из реестра. Это избавляет от необходимости передавать полную схему в каждом сообщении.

{
  "type": "record",
  "name": "Book",
  "namespace": "com.example.library",
  "doc": "Описание книги в библиотеке",
  "fields": [
    {
      "name": "title",
      "type": "string",
      "doc": "Название книги"
    },
    {
      "name": "author",
      "type": "string"
    },
    {
      "name": "year",
      "type": ["null", "int"],
      "default": null
    },
    {
      "name": "price",
      "type": "double",
      "default": 0.0
    },
    {
      "name": "tags",
      "type": {
        "type": "array",
        "items": "string"
      },
      "default": []
    },
    {
      "name": "metadata",
      "type": {
        "type": "map",
        "values": "string"
      },
      "default": {}
    }
  ]
}

Union type (объединение типов) — это тип данных, значение которого может принадлежать одному из нескольких указанных типов. В Avro union записывается как массив типов, и при сериализации перед значением записывается индекс выбранного типа.

import org.apache.avro.Schema;
import org.apache.avro.generic.GenericData;
import org.apache.avro.generic.GenericRecord;
import org.apache.avro.generic.GenericDatumWriter;
import org.apache.avro.generic.GenericDatumReader;
import org.apache.avro.io.DatumWriter;
import org.apache.avro.io.DatumReader;
import org.apache.avro.io.Encoder;
import org.apache.avro.io.Decoder;
import org.apache.avro.io.EncoderFactory;
import org.apache.avro.io.DecoderFactory;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;

public class AvroGenericExample {
    
    // Схема как JSON-строка
    private static final String BOOK_SCHEMA = "{"
        + "\"type\":\"record\","
        + "\"name\":\"Book\","
        + "\"namespace\":\"com.example\","
        + "\"fields\":["
        + "  {\"name\":\"title\", \"type\":\"string\"},"
        + "  {\"name\":\"author\", \"type\":\"string\"},"
        + "  {\"name\":\"year\", \"type\":[\"null\",\"int\"], \"default\":null},"
        + "  {\"name\":\"price\", \"type\":\"double\", \"default\":0.0}"
        + "]}";
    
    public byte[] serializeBook() throws Exception {
        // Парсинг схемы из JSON-строки
        Schema schema = new Schema.Parser().parse(BOOK_SCHEMA);
        
        // Создание GenericRecord — динамического контейнера данных
        // GenericRecord хранит значения полей в массиве Object[]
        GenericRecord book = new GenericData.Record(schema);
        book.put("title", "Clean Code");
        book.put("author", "Robert C. Martin");
        book.put("year", 2008);  // Avro автоматически оборачивает в union
        book.put("price", 42.50);
        
        // GenericDatumWriter — сериализатор для GenericRecord
        // DatumWriter — это интерфейс, абстрагирующий запись Avro-данных
        DatumWriter<GenericRecord> writer = new GenericDatumWriter<>(schema);
        
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        // BinaryEncoder — кодировщик в бинарный формат Avro
        // EncoderFactory — фабрика для создания encoder-ов (бинарных, JSON и др.)
        Encoder encoder = EncoderFactory.get().binaryEncoder(out, null);
        
        // Сериализация: writer читает поля из GenericRecord по схеме
        // и записывает их в encoder в бинарном формате
        writer.write(book, encoder);
        encoder.flush();  // сброс буфера encoder в поток
        
        return out.toByteArray();
    }
    
    public GenericRecord deserializeBook(byte[] data) throws Exception {
        Schema schema = new Schema.Parser().parse(BOOK_SCHEMA);
        
        // GenericDatumReader — десериализатор
        DatumReader<GenericRecord> reader = new GenericDatumReader<>(schema);
        
        ByteArrayInputStream in = new ByteArrayInputStream(data);
        // BinaryDecoder — декодировщик из бинарного формата
        Decoder decoder = DecoderFactory.get().binaryDecoder(in, null);
        
        // Десериализация: reader читает байты через decoder
        // и строит GenericRecord по схеме
        return reader.read(null, decoder);
    }
}

// Сгенерированный класс (упрощённо)
public class Book extends org.apache.avro.specific.SpecificRecordBase {
    private CharSequence title;
    private CharSequence author;
    private Integer year;
    private double price;
    
    // Avro требует конструктор по умолчанию
    public Book() {}
    
    // put(int field, Object value) — индексированный доступ
    public void put(int field, Object value) {
        switch (field) {
            case 0: title = (CharSequence) value; break;
            case 1: author = (CharSequence) value; break;
            case 2: year = (Integer) value; break;
            case 3: price = (Double) value; break;
            default: throw new AvroRuntimeException("Bad index");
        }
    }
    
    public Object get(int field) {
        switch (field) {
            case 0: return title;
            case 1: return author;
            case 2: return year;
            case 3: return price;
            default: throw new AvroRuntimeException("Bad index");
        }
    }
    
    // Типизированные геттеры/сеттеры
    public CharSequence getTitle() { return title; }
    public void setTitle(CharSequence value) { this.title = value; }
}

Writer schema — это схема, которая использовалась при сериализации данных. Reader schema — это схема, которую ожидает потребитель при десериализации. Avro гарантирует совместимость, если reader schema может быть получена из writer schema через набор правил преобразования.

// Writer schema (старая версия)
{
  "type": "record",
  "name": "Book",
  "fields": [
    {"name": "title", "type": "string"},
    {"name": "author", "type": "string"}
  ]
}

// Reader schema (новая версия)
{
  "type": "record",
  "name": "Book",
  "fields": [
    {"name": "title", "type": "string"},
    {"name": "author", "type": "string"},
    {"name": "year", "type": ["null", "int"], "default": null}
  ]
}

import org.apache.avro.file.DataFileWriter;
import org.apache.avro.file.CodecFactory;

public void writeCompressedFile(Schema schema, List<GenericRecord> records) throws Exception {
    // DataFileWriter — высокоуровневый writer для Avro-файлов с заголовком
    DataFileWriter<GenericRecord> writer = new DataFileWriter<>(new GenericDatumWriter<>(schema));
    
    // Установка кодека сжатия
    // Snappy — быстрый кодек от Google, оптимизированный на скорость
    // Deflate — стандартный zlib-сжатие
    // Zstandard (zstd) — современный кодек с лучшим соотношением скорость/сжатие
    writer.setCodec(CodecFactory.snappyCodec());
    
    // Схема записывается в заголовок файла
    writer.create(schema, new File("books.avro"));
    
    for (GenericRecord record : records) {
        writer.append(record);
    }
    
    writer.close();
}

Split — это разбиение большого файла на части для параллельной обработки. В Hadoop InputFormat определяет, как файл разбивается на splits, которые затем обрабатываются отдельными mapper-ами.

import io.confluent.kafka.serializers.KafkaAvroSerializer;
import io.confluent.kafka.serializers.KafkaAvroDeserializer;
import org.apache.kafka.clients.producer.ProducerRecord;

public class KafkaAvroProducer {
    
    public void sendBook(KafkaProducer<String, GenericRecord> producer, GenericRecord book) {
        // KafkaAvroSerializer автоматически:
        // 1. Регистрирует схему в Schema Registry (если ещё не зарегистрирована)
        // 2. Получает schema ID
        // 3. Записывает в сообщение: [magic byte (1)][schema ID (4)][payload]
        ProducerRecord<String, GenericRecord> record = 
            new ProducerRecord<>("books-topic", book.get("title").toString(), book);
        producer.send(record);
    }
}

Throughput — это пропускная способность системы, измеряемая количеством операций или объёмом данных, обрабатываемых за единицу времени. В Kafka throughput измеряется в сообщениях в секунду или мегабайтах в секунду.

GenericRecord record = new GenericData.Record(schema);
record.put("title", "Clean Code");

// Переиспользование GenericRecord для снижения аллокаций
GenericRecord reuse = new GenericData.Record(schema);
while (fileReader.hasNext()) {
    // read перезаписывает reuse вместо создания нового объекта
    GenericRecord record = fileReader.next(reuse);
    process(record);
}

import java.util.Optional;

public class Task120826 {
    public static void main(String[] args) {
        Optional<String> opt = Optional.of("present");
        String result = opt.orElse(getDefault());
        System.out.println(result);
    }

    static String getDefault() {
        System.out.println("default called");
        return "default";
    }
}

public class SynchronizedListIteration {
    
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        list.add("A");
        list.add("B");
        list.add("C");
        
        //Опасная итерация без синхронизации
        // Может выбросить ConcurrentModificationException, если другой поток модифицирует список
        for (String s : list) {
            System.out.println(s);
        }
        
        //Правильная итерация с синхронизацией на списке
        synchronized (list) {
            for (String s : list) {
                System.out.println(s);
            }
        }
        
        //Неатомарная составная операция
        // Между size() и remove() другой поток может изменить список
        if (!list.isEmpty()) {
            list.remove(0); // Может удалить не тот элемент
        }
        
        //Правильная составная операция в синхронизированном блоке
        synchronized (list) {
            if (!list.isEmpty()) {
                String first = list.remove(0);
                System.out.println("Removed: " + first);
            }
        }
        
        // Для итерации с удалением элементов также требуется синхронизация
        synchronized (list) {
            Iterator<String> it = list.iterator();
            while (it.hasNext()) {
                if (it.next().equals("B")) {
                    it.remove(); // Безопасно внутри блока
                }
            }
        }
    }
}

import java.util.*;

public class Task130826 {
    public static void main(String[] args) {
        List<Integer> list = Collections.synchronizedList(new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)));
        Iterator<Integer> it = list.iterator();
        list.add(6);
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
}