Gson gson = new Gson();

// Сериализация списка в JSON
List<String> languages = Arrays.asList("Java", "Kotlin", "Python");
String json = gson.toJson(languages);
System.out.println(json); // ["Java","Kotlin","Python"]

// Десериализация JSON обратно в List
List<String> parsedList = gson.fromJson(json, List.class);
System.out.println(parsedList.get(0)); // Java

import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;

// Создаем Type для List<String>
Type listType = new TypeToken<List<String>>() {}.getType();

// Десериализация с сохранением типа
String json = "[\"Apple\", \"Banana\"]";
List<String> fruits = gson.fromJson(json, listType);
System.out.println(fruits.get(0).toUpperCase()); // APPLE (без TypeToken был бы Object!)

// Сериализация массива
int[] numbers = {1, 2, 3};
String numbersJson = gson.toJson(numbers);
System.out.println(numbersJson); // [1,2,3]

// Десериализация обратно в массив
int[] parsedNumbers = gson.fromJson(numbersJson, int[].class);
System.out.println(parsedNumbers[0]); // 1

// Сериализация Map
Map<String, Object> data = new HashMap<>();
data.put("name", "John");
data.put("age", 30);
data.put("skills", Arrays.asList("Java", "SQL"));

String mapJson = gson.toJson(data);
System.out.println(mapJson);
// {"skills":["Java","SQL"],"name":"John","age":30}

// Десериализация Map
Type mapType = new TypeToken<Map<String, Object>>() {}.getType();
Map<String, Object> parsedMap = gson.fromJson(mapJson, mapType);
System.out.println(parsedMap.get("name")); // John

{
  "name": "Alice",
  "address": {
    "city": "New York",
    "street": "5th Avenue"
  }
}

class Address {
    private String city;
    private String street;

    // Конструктор, геттеры и сеттеры
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }

    public String getCity() { return city; }
    public String getStreet() { return street; }
}

class Person {
    private String name;
    private Address address;

    // Конструктор, геттеры и сеттеры
}

String personJson = """
    {
      "name": "Alice",
      "address": {
        "city": "New York",
        "street": "5th Avenue"
      }
    }
    """;

Gson gson = new Gson();
Person person = gson.fromJson(personJson, Person.class);

System.out.println(person.getName()); // Alice
System.out.println(person.getAddress().getCity()); // New York

Address address = new Address("Berlin", "Main Street");
Person person = new Person("Bob", address);

String json = gson.toJson(person);
System.out.println(json);
// {"name":"Bob","address":{"city":"Berlin","street":"Main Street"}}

{
  "team": "Developers",
  "members": [
    {
      "name": "John",
      "role": "Backend"
    },
    {
      "name": "Anna",
      "role": "Frontend"
    }
  ]
}

class TeamMember {
    private String name;
    private String role;
    // конструктор и геттеры
}

class Team {
    private String teamName;
    private List<TeamMember> members;
    // конструктор и геттеры
}

Type teamType = new TypeToken<Team>() {}.getType();
Team team = gson.fromJson(jsonString, teamType);

public class Task190525 {
    public static void main(String[] args) {
        String s1 = "Java";
        String s2 = s1.concat('\u00A9');
        System.out.println(s2);
    }
}

short a = 1000;
short b = 2000;
short c = a + b; // Ошибка компиляции

short c = (short)(a + b);

short s = 32_767;
s++; // теперь s = -32_768

short s = -1;
int unsigned = s & 0xFFFF; // результат: 65535

short s = (short) 40000;
System.out.println(s); // Выведет -25536
Потому что 40000 не помещается в short, и лишние биты отбрасываются.

public class Main {
    public static void main(String[] args) {
        short a = 10;
        short b = 20;
        short c = a + b;
        System.out.println(c);
    }
}

public class User {
    private String name;
    private String email;

    // Конструкторы, геттеры и сеттеры
}

public class UserSerializer implements JsonSerializer<User> {
    @Override
    public JsonElement serialize(User user, Type typeOfSrc, JsonSerializationContext context) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("name", user.getName());
        jsonObject.addProperty("email", user.getEmail().toLowerCase()); // Приводим email к нижнему регистру
        return jsonObject;
    }
}

public class UserDeserializer implements JsonDeserializer<User> {
    @Override
    public User deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jsonObject = json.getAsJsonObject();
        String name = jsonObject.get("name").getAsString();
        String email = jsonObject.get("email").getAsString();

        if (!email.contains("@")) {
            throw new JsonParseException("Invalid email format");
        }

        return new User(name, email);
    }
}

Gson gson = new GsonBuilder()
    .registerTypeAdapter(User.class, new UserSerializer())  // Сериализатор
    .registerTypeAdapter(User.class, new UserDeserializer()) // Десериализатор
    .create();

// Сериализация
User user = new User("John", "John@Example.com");
String json = gson.toJson(user); // {"name":"John","email":"john@example.com"}

// Десериализация
User parsedUser = gson.fromJson(json, User.class);

public class DateSerializer implements JsonSerializer<Date> {
    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy");

    @Override
    public JsonElement serialize(Date date, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(dateFormat.format(date));
    }
}

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateSerializer())
    .create();

Date now = new Date();
String json = gson.toJson(now); // "12.05.2025"

Gson gson = new GsonBuilder()
    .setPrettyPrinting()       // Красивый вывод JSON
    .serializeNulls()         // Включает null-поля
    .excludeFieldsWithoutExposeAnnotation() // Только помеченные @Expose
    .create();

public class User {
    @Expose
    private String name; // Будет сериализовано

    private String password; // Не будет сериализовано
}

Gson gson = new GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .create();

User user = new User("John", "secret");
String json = gson.toJson(user); // {"name":"John"}

Gson gson = new GsonBuilder()
    .setPrettyPrinting()
    .serializeNulls()
    .setDateFormat("dd.MM.yyyy") // Формат даты по умолчанию
    .registerTypeAdapter(User.class, new UserSerializer())
    .excludeFieldsWithoutExposeAnnotation()
    .create();

public class Task210525 {
    public static void main(String[] args) {
        String s1 = new String("Java");
        String s2 = s1.intern();
        String s3 = "Java";
        
        System.out.println(s1 == s2);
        System.out.println(s2 == s3);
    }
}

int a = 1_000_000_000;
int b = 3;
long result = a * b; // результат может быть неверным!

long result = (long) a * b; // безопасно

long x = Long.MAX_VALUE;
x++;
System.out.println(x); // выведет отрицательное число: Long.MIN_VALUE
Это поведение аналогично тому, что происходит с int, short и byte, но требует повышенного внимания при работе с предельными значениями.

long l = -1L;
String binary = Long.toBinaryString(l); // все 64 бита — единицы