Java for Beginner
676 subscribers
546 photos
155 videos
12 files
836 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
Please open Telegram to view this post
VIEW IN TELEGRAM
Gson: основы сериализации и десериализации

1. Что такое Gson и зачем он нужен

Gson — это библиотека от Google для работы с JSON в Java.


Она позволяет:
Преобразовывать Java-объекты в JSON (сериализация).
Восстанавливать Java-объекты из JSON (десериализация).


Почему Gson?
Простота: минимум кода для работы.
Мощность: поддержка сложных структур (коллекции, вложенные объекты, generics).
Нет зависимостей: работает без дополнительных библиотек.


Пример JSON и его Java-представление

Допустим, у нас есть JSON:
{
"name": "John",
"age": 30,
"isDeveloper": true
}


Ему соответствует Java-класс:
public class Person {
private String name;
private int age;
private boolean isDeveloper;

// Конструктор, геттеры и сеттеры (обязательны для корректной работы)
public Person(String name, int age, boolean isDeveloper) {
this.name = name;
this.age = age;
this.isDeveloper = isDeveloper;
}

// Геттеры и сеттеры (опущены для краткости, но должны быть)
}


Подключение Gson

Через Maven (добавить в pom.xml):

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version> <!-- Актуальная версия на момент 2025 года -->
</dependency>


Через Gradle (добавить в build.gradle):
implementation 'com.google.code.gson:gson:2.10.1'



2. Простая сериализация Java-объекта в JSON


Создание POJO

POJO (Plain Old Java Object) — простой Java-класс с полями, конструктором и геттерами/сеттерами.

Пример:
public class Book {
private String title;
private String author;
private double price;

public Book(String title, String author, double price) {
this.title = title;
this.author = author;
this.price = price;
}

// Геттеры (обязательны для сериализации)
public String getTitle() { return title; }
public String getAuthor() { return author; }
public double getPrice() { return price; }
}


Сериализация с помощью Gson.toJson()

Создаем объект Gson:
Gson gson = new Gson();


Сериализуем объект в JSON-строку:
Book book = new Book("Clean Code", "Robert Martin", 29.99);
String json = gson.toJson(book);


Выводим результат:

System.out.println(json);


Результат:
{"title":"Clean Code","author":"Robert Martin","price":29.99}


Как это работает?

Gson рефлективно анализирует поля класса.
Имена полей становятся ключами JSON.
Примитивы (int, boolean), строки (String) и числа с плавающей точкой (double) преобразуются в соответствующие JSON-типы.


Полный пример кода
import com.google.gson.Gson;

public class Main {
public static void main(String[] args) {
// Создаем объект
Book book = new Book("Clean Code", "Robert Martin", 29.99);

// Сериализуем в JSON
Gson gson = new Gson();
String json = gson.toJson(book);

// Выводим JSON
System.out.println(json);
}
}


Вывод:
{"title":"Clean Code","author":"Robert Martin","price":29.99}


Важные замечания

Поля должны быть private (или иметь геттеры).
Поля со значением null не включаются в JSON (если не настроено иначе).
Gson автоматически обрабатывает вложенные объекты и коллекции.


#Java #middle #Gson
Что выведет код?

public class Task130525 {
public static void main(String[] args) {
String s = "123abc";
int num = Integer.parseInt(s);
System.out.println(num);
}
}


#Tasks
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Глубокое изучение типа данных byte в Java

Тип byte в Java — это один из восьми примитивных типов, представляющий собой 8-битное целое число со знаком. Он занимает ровно 1 байт в памяти и используется в тех случаях, когда важна экономия пространства или требуется работа с низкоуровневыми бинарными данными. Несмотря на кажущуюся простоту, byte имеет ряд особенностей, которые важно понимать для корректной и безопасной работы.

Диапазон и внутреннее представление

Значения byte варьируются от -128 до 127. Это обусловлено использованием 8 бит и представления чисел в формате дополнительного кода (two's complement):

0: 00000000
127: 01111111
-1: 11111111
-128: 10000000

Самый старший бит (MSB) определяет знак: 0 — положительное число, 1 — отрицательное. Формат two's complement позволяет упростить реализацию арифметики на уровне процессора.

Как работает two's complement

Чтобы получить отрицательное значение, берут двоичное представление положительного числа, инвертируют биты и прибавляют единицу:

Пример:
5 → 00000101
~5 → 11111010
+1 → 11111011 → это -5

Этот подход ведет к асимметрии диапазона: -128 можно представить, а +128 — нет, так как 8 бит не хватает.


Размещение в памяти

Так как byte — это примитивный тип, он хранится в стеке, если это локальная переменная, либо в куче, если он является полем объекта. При входе в метод для переменной выделяется 1 байт в стеке. При выходе из метода фрейм стека удаляется целиком, вместе с переменными.

Если byte используется как поле класса, то память выделяется при создании объекта в куче. Освобождение происходит автоматически через сборщик мусора JVM.

Поведение в арифметике и преобразования

Одной из ключевых особенностей byte является то, что в арифметических операциях он автоматически приводится к int. Это значит, что результат выражений типа byte + byte — это int, и его необходимо явно привести обратно к byte, если нужно сохранить в переменной этого типа:
byte b1 = 100;
byte b2 = 30;
byte sum = b1 + b2; // ошибка компиляции
byte sum = (byte)(b1 + b2); // корректно


Переполнение (overflow)

Так как byte хранит только 8 бит, любые арифметические операции, выходящие за диапазон [-128; 127], приводят к оборачиванию значения:
byte b = 127;
b++; // теперь b = -128
Это не ошибка компиляции, но может привести к логическим багам, особенно если разработчик не учитывает граничные значения.


Беззнаковость и побитовые операции

В Java отсутствует беззнаковый byte. Для получения значений в диапазоне 0–255 применяется побитовая маска:
byte b = -1;
int unsigned = b & 0xFF; // результат: 255
Это часто используется при работе с бинарными протоколами, изображениями, файлами и сетевыми буферами.


Применение


Экономия памяти. В массивах или структурах, где значения всегда укладываются в [-128; 127], использование byte позволяет экономить в 4 раза больше памяти по сравнению с int.
Работа с файлами и сетевыми потоками. Классы вроде InputStream и ByteBuffer оперируют byte[] для обработки бинарных данных.
Явное ограничение диапазона. Использование byte вместо int служит также как форма документации: переменная ограничена по смыслу и диапазону.


Инициализация и значения по умолчанию

Для полей класса byte значение по умолчанию — 0.
Для локальных переменных компилятор требует явной инициализации — использование необъявленного byte приведет к ошибке компиляции.


Потенциальные ошибки и рекомендации

Не забывайте про overflow при арифметике.
Используйте явное приведение типов при необходимости.
Помните, что byte[] — это массив чисел, не строка. Учитывайте кодировку, если работаете с текстом.
Для беззнаковой работы применяйте b & 0xFF.


Пример: работа с бинарным файлом
FileInputStream in = new FileInputStream("image.png");
byte[] buffer = new byte[1024];
int bytesRead = in.read(buffer);
in.close();


#Java #для_новичков #beginner #byte
Что выведет код?

public class Task140525 {
public static void main(String[] args) {
byte a = (byte) 0b10000000;
byte b = 1;
byte c = (byte) (a + b);
System.out.println(c);
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
14%
-128
10%
129
52%
-127
24%
Ошибка компиляции
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Базовая десериализация и аннотации в Gson

Десериализация JSON в Java-объект


Метод fromJson(String, Class<T>)
Десериализация — процесс преобразования JSON-строки в Java-объект. Основной метод:

Gson gson = new Gson();
MyClass obj = gson.fromJson(jsonString, MyClass.class);


Пример
Допустим, есть JSON:
{
"model": "Tesla Model S",
"year": 2023,
"electric": true
}


Соответствующий Java-класс:
public class Car {
private String model;
private int year;
private boolean electric;

// Обязателен конструктор по умолчанию (или @SerializedConstructor в новых версиях)
public Car() {}

// Геттеры и сеттеры
public String getModel() { return model; }
public int getYear() { return year; }
public boolean isElectric() { return electric; }
}


Десериализация:
String json = "{\"model\":\"Tesla Model S\",\"year\":2023,\"electric\":true}";
Gson gson = new Gson();
Car car = gson.fromJson(json, Car.class);

System.out.println(car.getModel()); // Tesla Model S


Обработка ошибок

Gson выбрасывает JsonSyntaxException при невалидном JSON:
try {
Car car = gson.fromJson("{invalid json}", Car.class);
} catch (JsonSyntaxException e) {
System.err.println("Ошибка парсинга JSON: " + e.getMessage());
}


Аннотации @SerializedName и @Expose

@SerializedName — для нестандартных ключей JSON

Если имя поля в Java не совпадает с ключом в JSON:
public class User {
@SerializedName("user_name")
private String name; // Сопоставляется с JSON-ключом "user_name"

@SerializedName(value = "user_age", alternate = {"age", "years"})
private int age; // Допустимые альтернативные ключи в JSON
}


Пример JSON:
{"user_name": "Alice", "age": 25}


@Expose — избирательная сериализация/десериализация

Поля без @Expose игнорируются. Требуется особый Gson:
Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.create();


Пример класса:
public class Product {
@Expose
private String name; // Сериализуется и десериализуется

@Expose(serialize = false)
private int id; // Только десериализация (из JSON в Java)

private String secret; // Игнорируется полностью
}


Отличие от Jackson

Аннотации:

В Gson: @SerializedName@JsonProperty в Jackson.
@Expose → Аналог @JsonInclude + @JsonIgnore.

Подход:
Gson использует рефлексию по умолчанию, Jackson — аннотации.

Производительность:
Jackson быстрее в некоторых сценариях, но Gson проще в настройке.

Полный пример

import com.google.gson.*;
import com.google.gson.annotations.*;

public class Main {
static class Device {
@SerializedName("device_name")
@Expose
private String name;

@Expose(deserialize = false)
private String manufacturer;

public Device(String name, String manufacturer) {
this.name = name;
this.manufacturer = manufacturer;
}
}

public static void main(String[] args) {
Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.setPrettyPrinting()
.create();

// Сериализация (manufacturer исключен, т.к. deserialize = false)
Device device = new Device("Phone", "BrandX");
String json = gson.toJson(device);
System.out.println(json);

// Десериализация
String inputJson = "{\"device_name\":\"Tablet\",\"manufacturer\":\"BrandY\"}";
Device parsed = gson.fromJson(inputJson, Device.class);
System.out.println(parsed.name); // "Tablet"
}
}


Вывод:
{
"device_name": "Phone"
}


Ключевые моменты

@SerializedName решает проблему различий в именах JSON/Java.
@Expose дает контроль над процессами сериализации/десериализации.
Для работы
@Expose требуется GsonBuilder.

#Java #middle #Gson #SerializedName #Expose
Что выведет код?

public class Task150525 {
public static void main(String[] args) {
String str = " Hello, World! ";
str.trim().toLowerCase().substring(7);
System.out.println(str);
}
}


#Tasks
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Полный разбор примитивного типа int в Java

Тип int — это один из восьми примитивных типов данных в Java. Несмотря на его кажущуюся простоту, понимание того, как он устроен, работает в памяти и взаимодействует с JVM, критически важно для глубокого освоения языка.


Общая информация


Тип: примитивный (primitive)
Размер: 32 бита (4 байта)
Диапазон значений: от -2,147,483,648 до 2,147,483,647 (т.е. от -2³¹ до 2³¹ - 1)
Знаковый: да (signed)
Формат представления: two's complement (двойное дополнение)


Пример объявления переменной:
int number = 42;



Что значит signed (знаковый тип)?


В типе int один из битов используется для хранения знака числа:
0 — положительное число
1 — отрицательное число


Это позволяет хранить как положительные, так и отрицательные значения. Всего 2³² возможных комбинаций битов. Из них:
половина — для отрицательных чисел
половина — для положительных чисел (включая 0)



Представление чисел: формат two’s complement

Java использует формат двойного дополнения (two’s complement) для хранения отрицательных чисел. Это универсальный и эффективный способ хранения знаковых чисел в бинарной форме.

Как это работает:


Чтобы получить -x:
Возьми двоичное представление x.
Инвертируй все биты (обратное дополнение).
Прибавь 1.


Пример: -5

5 = 00000000 00000000 00000000 00000101
Инверсия = 11111111 11111111 11111111 11111010
+1 → 11111111 11111111 11111111 11111011
Так хранится -5 в памяти.



Где хранится int в памяти?

В стеке (stack)
Если переменная int — локальная переменная метода, она хранится в стековой рамке метода.

В куче (heap)
Если int является полем объекта (int age внутри класса), то он хранится в куче, как часть объекта.


Что такое стековая рамка (stack frame)?

Каждый вызов метода в Java создаёт отдельную область в стеке, называемую stack frame. Она содержит:
Локальные переменные
Временные значения
Адрес возврата
Операнды

Когда метод завершается — стековая рамка удаляется, а память освобождается.



Как происходит запись и удаление int?

Запись: JVM резервирует 4 байта и записывает число в двоичном формате.
Удаление: локальные переменные исчезают при завершении метода. Если int был частью объекта, он удаляется при сборке мусора (GC), когда объект становится недостижимым.



Особенности

1. Переполнение (overflow)

int не выбрасывает исключений при выходе за границы диапазона:

int a = Integer.MAX_VALUE; // 2_147_483_647
a++;
System.out.println(a); // -2_147_483_648 (переполнение)
Чтобы отлавливать такие случаи, используйте Math.addExact(), которая кидает ArithmeticException.


Если продолжить увеличивать значение переменной типа int после переполнения, то поведение будет цикличным. То есть от 2_147_483_647 до -2_147_483_648 не выходя за пределы этих значений.


2. Побитовые операции


Java поддерживает прямые операции над битами:
& — побитовое И
| — побитовое ИЛИ
^ — XOR
~ — побитовое НЕ
<< — сдвиг влево
>> — сдвиг вправо (с сохранением знака)
>>> — сдвиг вправо (без сохранения знака)


Пример:
int x = 5;    // 00000101
int y = 3; // 00000011

int result = x & y; // 00000001 (1)


3. Автоупаковка и Integer-кэш

При автоупаковке int → Integer:
Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true


Но:
Integer a = 1000;
Integer b = 1000;
System.out.println(a == b); // false


Почему?
Значения от -128 до 127 кэшируются.
JVM использует один и тот же объект для этих чисел (ради оптимизации).
Сравнение == проверяет ссылку, а не значение.
Для сравнения значений используйте .equals().



Преобразования типов

int неявно (автоматически) расширяется до long, float, double.

Сужающее преобразование требует явного приведения:
byte b = (byte) 130; // b == -126


#Java #для_новичков #beginner #int
Что выведет код?

public class Task160525 {
public static void main(String[] args) {
int a = 2_000_000_000;
int b = 2_000_000_000;
int c = a + b;
System.out.println(c);
}
}


#Tasks