Является ли строка примитивом?

Является ли строка примитивом

Ответ: Нет, String НЕ является примитивом в Java. Это один из ключевых принципов языка, хотя String получает специальное обращение с точки зрения синтаксиса и производительности.

Примитивные типы в Java

В Java есть ровно 8 примитивных типов данных:

// Примитивные типы Java
byte      // 8-битное целое число
short     // 16-битное целое число
int       // 32-битное целое число
long      // 64-битное целое число
float     // 32-битное число с плавающей запятой
double    // 64-битное число с плавающей запятой
boolean   // логическое значение (true/false)
char      // одиночный символ (16-битный)

// String НЕ в этом списке!
public final class String implements Comparable<String>, ... {
    // String - это обычный класс
}

String - это объект (reference type)

// Примитив - хранится в стеке
int number = 42;
boolean flag = true;

// String - это объект, ссылка хранится в стеке, объект в куче
String text = "Hello"; // ссылка text в стеке, объект в куче
String another = new String("Hello"); // явное создание через new

// Сравнение
int a = 5;
int b = 5;
System.out.println(a == b); // true - примитивы сравниваются по значению

String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

System.out.println(s1 == s2);  // true - одна и та же ссылка (String pool)
System.out.println(s1 == s3);  // false - разные ссылки на куче
System.out.println(s1.equals(s3)); // true - сравнение содержимого

Почему String выглядит как примитив

Java дает String "синтаксический сахар" для удобства:

// 1. Литеральное создание (без new)
String text = "Hello"; // компилятор превращает в String pooling

// 2. Оператор + для конкатенации
String message = "Hello" + " " + "World"; // работает как примитивы

// 3. Специальная обработка в Java Virtual Machine
// Все строковые литералы автоматически добавляются в String pool

Отличия примитивов от String

// ПРИМИТИВЫ
int x = 10;
int y = 10;
System.out.println(x == y); // true
System.out.println(x == 10); // true

// STRING (ОБЪЕКТ)
String s1 = "test";
String s2 = "test";
String s3 = new String("test");

System.out.println(s1 == s2);  // true (из pool)
System.out.println(s1 == s3);  // false (разные объекты)
System.out.println(s1.equals(s3)); // true

// Примитив передается по значению
int a = 5;
changeInt(a);
System.out.println(a); // 5 - не изменился

// String передается по ссылке, но String immutable
String original = "original";
changeString(original);
System.out.println(original); // "original" - не изменился (из-за immutability)

public static void changeInt(int value) {
    value = 100; // не влияет на a
}

public static void changeString(String s) {
    s = "changed"; // не влияет на original
}

String pool и память

// String pool находится в куче
public class StringPoolExample {
    public static void main(String[] args) {
        // Все эти ссылки указывают на ОДИН объект в pool
        String a = "hello";
        String b = "hello";
        String c = "hello";
        
        System.out.println(a == b); // true (одна ячейка в pool)
        System.out.println(a == c); // true
        
        // Это создает новый объект на куче (вне pool)
        String d = new String("hello");
        System.out.println(a == d); // false (разные объекты)
        
        // Можно явно добавить в pool
        String e = d.intern();
        System.out.println(a == e); // true (e теперь указывает на pool)
    }
}

Размер в памяти

// Примитив int - 4 байта (ровно)
int x = 100;

// String - минимум 40+ байт даже для пустой строки
String empty = ""; // ~40 байт overhead + содержимое
String hello = "Hello"; // ~40 байт overhead + 10 байт (5 символов * 2 байта на char)

Практические следствия

// 1. String immutable - не изменяется после создания
String original = "Hello";
String modified = original.toUpperCase(); // создается новый String
// original все еще = "Hello"

// 2. Сравнивай с equals(), не с ==
if (userInput.equals("password")) { // правильно
    // ...
}

// 3. Конкатенация в цикле неэффективна
// Плохо:
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // создает новый String каждый раз!
}

// Хорошо:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

Вывод

String - это **объект (reference type)**, а не примитив. Но язык относится к нему специально из-за частоты использования и удобства синтаксиса. Всегда помни:

• String хранится на куче
• Сравнивай с .equals(), не с ==
• String immutable
• 8 примитивов + все остальное (включая String) = объекты