Java and Stack Java в Java делит память на два типа: один - это память стека, а другой - память кучи.
Некоторые основные типы переменных, определенных в функциях, и эталонные переменные объектов выделяются в памяти стека функции. Когда переменная определяется в блоке кода, Java выделяет пространство памяти для переменной в стеке. Когда объем переменной превышает объем переменной, Java автоматически отпустит пространство памяти, выделяемое для переменной, и пространство памяти может использоваться отдельно немедленно.
Хиповая память используется для хранения объектов и массивов, созданных новыми. Память, выделенная в куче, управляется автоматическим коллектором мусора Java. После того, как массив или объект генерируется в куче, в стеке можно определить специальную переменную. Значение этой переменной равно первому адресу массива или объекта в памяти кучи. Эта специальная переменная в стеке становится эталонной переменной для массива или объекта. В будущем вы можете использовать эталонную переменную в памяти стека в программе для доступа к массиву или объекту в куче. Справочная переменная эквивалентна псевдониме или кодовому имени для массива или объекта.
Справочные переменные - обычные переменные. При определении память выделяется в стеке. Справочные переменные выпускаются за пределами сферы действия при запуске программы. Сам массив и объект выделяется в куче. Даже если программа работает за пределами блока кода, где расположены новые операторы для генерации массива и объекта, память кучи, занятая массивом и самим объектом, не будет выпущена. Массив и объект становятся мусором только тогда, когда нет эталонной переменной, указывающей на него, и больше нельзя использовать, но все еще занимают память и высвобождаются коллекционером мусора в неопределенное время. Это также главная причина, по которой Java занимает больше памяти. На самом деле, переменные в стеке указывают на переменные в памяти кучи, что является указателем в Java!
Куча и стека на Java
Java делит память на два типа: один - это память стека, а другой - память кучи.
1. Стептя и куча - это места, используемые Java для хранения данных в оперативной памяти. В отличие от C ++, Java автоматически управляет стеками и кучами, и программисты не могут настроить стеки или кучи напрямую.
2. Преимущество стека состоит в том, что скорость доступа быстрее, чем куча, уступая только регистрам, расположенным непосредственно в процессоре. Но недостатком является то, что размер и срок службы данных в стеке должен быть детерминированным и отсутствовать гибкость. Кроме того, данные стека могут быть переданы. Преимущество кучи состоит в том, что она может динамически распределять размер памяти, и срок службы не нужно сообщать компилятору заранее. Коллекционер мусора Java автоматически собирает данные, которые больше не используются. Но недостаток в том, что память должна быть динамически распределена во время выполнения, скорость доступа медленнее.
3. Есть два типа данных в Java.
Одним из них являются основные типы (примитивные типы), существует 8 типов, а именно int, короткие, длинные, байт, поплавок, двойной, логический, чар (примечание,
Нет основного типа строки). Этот тип определения определяется формой, такой как int a = 3; длинный B = 255 л; и называется автоматической переменной. Стоит отметить, что автоматическая переменная содержит буквальные значения, а не экземпляры класса, то есть не ссылки на класс, и здесь нет класса. Например, int a = 3; Вот ссылка, указывающая на тип Int,
Укажите буквальное значение 3. Из -за размера этих буквальных значений может быть известно время жизни этих буквальных значений (эти буквальные значения определяются в блоке программы, а после выхода программного блока значение поля исчезает).
Для достижения скорости он существует в стеке.
Кроме того, очень важная особенность стека заключается в том, что данные в стеке могут быть переданы. Предположим, мы определяем одновременно:
int a = 3;
int b = 3;
Компилятор сначала обрабатывает int a = 3; Сначала он создаст ссылку на переменную A в стеке, а затем выяснит, есть ли адрес с буквальным значением 3. Если она не найдена, он откроет адрес с буквальным значением 3, а затем укажет A на адрес 3. Затем процесс int b = 3; После создания эталонной переменной B, поскольку в стеке уже есть буквальное значение 3, B напрямую указывает на адрес 3. Таким образом, A и B оба указывают на 3 одновременно.
Особенно важно отметить, что эта буквальная ссылка отличается от ссылок на объекты класса. Предполагая, что ссылки двух объектов класса указывают на объект одновременно, если одна ссылка объекта изменяет внутреннее состояние объекта, то другая эталонная переменная объекта немедленно отражает это изменение. Вместо этого изменение его значения с помощью буквальной ссылки не приведет к соответствующему изменению другого значения. Как и в приведенном выше примере, после того, как мы определим значения A и B, пусть A = 4; Затем B не будет равен 4 или равна 3. Внутри компилятора, когда встречается a = 4, он будет повторно поиск, есть ли буквальное значение 4 в стеке. Если нет, повторно откройте адрес для хранения значения 4; Если это уже существует, напрямую укажите А на этот адрес. Следовательно, изменение значения А не повлияет на значение b.
Другим типом являются данные класса упаковки, такие как целое число, строка, двойная и т. Д., Которые завершают соответствующие основные типы данных. Все эти данные класса существуют в куче. Java использует новый () оператор () для отображения компилятора и создает динамически только по мере необходимости во время выполнения, поэтому он более гибкий, но недостаток в том, что это занимает больше времени.
В Java есть шесть различных мест, где можно хранить данные:
1. Зарегистрировать. Это самая быстрая область хранения, потому что она расположена в другом месте, чем в других областях хранения - процессора. Тем не менее, количество регистров чрезвычайно ограничено, поэтому компилятор выделяется регистрами в соответствии с требованиями. Вы не можете напрямую контролировать его, и при этом вы не можете чувствовать никаких признаков существования регистра в программе.
2. Stack. Расположенный в ОЗУ общего назначения, но с его «указателем стека» вы можете получить поддержку от процессора. Если указатель стека движется вниз, новая память выделяется; Если он поднимается, эти память освобождается. Это быстрый и эффективный способ распределения хранения, второго только для регистров. При создании программы компилятор Java должен знать точный размер и жизненный цикл всех данных, хранящихся в стеке, поскольку он должен генерировать соответствующий код, чтобы переместить указатель стека вверх и вниз. Это ограничение ограничивает гибкость программы, поэтому, хотя некоторые данные JA VA хранятся в стеке - особенно ссылки на объекты, в нем нет объектов Java.
3. Кучи. Универсальный пул памяти (также существует в RAM) для хранения так называемых объектов Java. Преимущество кучи состоит в том, что компилятору не нужно знать, сколько областей хранения выделять из кучи, и при этом он не должен знать, как долго хранится данные в куче. Поэтому существует большая гибкость в распределении хранения в куче. Когда вам нужно создать объект, вам нужно только написать простую строку кода в новом. При выполнении этой строки кода он автоматически хранит и распределяется в куче. Конечно, соответствующий код должен быть оплачен за эту гибкость. Для распределения хранилища требуется больше времени, чем хранить его со стеком.
4. Статическое хранение. «Статический» здесь означает «в фиксированной позиции». Статическое хранилище хранит данные, которые всегда существовали при запуске программы. Вы можете использовать статическое ключевое слово, чтобы определить, что конкретный элемент объекта является статичным, но сам объект Java никогда не хранится в статическом пространстве хранения.
5. Постоянное хранение. Постоянные значения обычно хранятся непосредственно внутри кода программы, и это безопасно для этого, потому что они никогда не будут изменены. Иногда в встроенной системе сама константа отделяется от других частей, поэтому в этом случае необязательно поместить ее в ПЗУ.
6. Несоответствующее хранилище. Если данные полностью выживают вне программы, их можно оставить без какого -либо контроля над программой и может существовать, когда программа не работает.
С точки зрения скорости, существует связь следующим образом:
Зарегистрировать <стек <heap <Другое
"Приведенный выше отрывок извлечен из" мышления на Java ""
Вопрос 1:
String str1 = "abc"; String str2 = "abc"; System.out.println (str1 == str2); //истинный
Вопрос 2:
String str1 = new String ("ABC"); String str2 = new String ("ABC"); System.out.println (str1 == str2); // ЛОЖЬ Вопрос 3:
Строка S1 = "Ja"; String S2 = "VA"; Строка S3 = "java"; Строка S4 = S1 + S2; System.out.println (s3 == s4); // false system.out.println (s3.equals (s4)); // true
Некоторые основные типы переменных, определенных в функции и эталонных переменных объекта, все выделены в памяти стека функции.
Когда переменная определяется в блоке кода, Java выделяет пространство памяти для этой переменной в стеке. Когда сфера действия переменной превышает переменную, Java автоматически отпустит пространство памяти, выделенное для переменной, и пространство памяти может быть использовано отдельно немедленно.
Хиповая память используется для хранения объектов и массивов, созданных новыми.
Память, выделяемая в куче, управляется автоматическим коллекционером мусора Java Virtual Machine.
После того, как массив или объект генерируется в куче, в стеке можно определить специальную переменную, так что значение этой переменной в стеке равно первое адреса массива или объекта в памяти кучи, а переменная в стеке становится эталонной переменной для массива или объекта.
Справочная переменная эквивалентна имени, данному массиву или объекту. Вы можете использовать эталонные переменные в стеке в программе для доступа к массиву или объекту в куче.
В частности: стек и куча - это места, которые используются Java для хранения данных в оперативной памяти. В отличие от C ++, Java автоматически управляет стеками и кучами, и программисты не могут настроить стеки или кучи напрямую.
Куча Java - это область данных среды выполнения, из которой объекты выделяют пространство. Эти объекты создаются с помощью таких инструкций, как новый, Newarray, Anewarray и Multianewarray. Они не требуют явного выпуска программного кода. Куча отвечает за сбор мусора. Преимущество кучи состоит в том, что она может динамически распределять размер памяти, и срок службы не обязательно сообщать компилятору заранее, потому что она динамически распределяет память во время выполнения. Коллекционер мусора Java автоматически собирает данные, которые больше не используются. Но недостаток заключается в том, что, поскольку ему необходимо динамически распределять память во время выполнения, скорость доступа медленнее.
Преимущество стека состоит в том, что скорость доступа быстрее, чем куча, уступая только регистрам, а данные стека могут быть переданы. Но недостатком является то, что размер и срок службы данных в стеке должен быть детерминированным и отсутствовать гибкость. В стеке в основном хранится некоторые основные типы переменных (, int, короткие, длинные, байт, поплавок, двойной, логический, чар) и объектные ручки.
Очень важной особенностью стека является то, что данные, существующие в стеке, могут быть обмен. Предположим, мы определяем одновременно:
int a = 3;
int b = 3;
Компилятор сначала обрабатывает int a = 3; Сначала он создаст ссылку в стеке с переменной A, а затем выясните, есть ли значение 3 в стеке. Если это не найдено, он будет хранить 3, а затем точку A до 3. Затем процесс int b = 3; После создания эталонной переменной B, поскольку в стеке уже есть значение 3, B напрямую указывает на 3. Таким образом, A и B оба указывают на 3 одновременно. В настоящее время, если a = 4 снова установлен; Затем компилятор снова будет искать, есть ли 4 значения в стеке. Если нет, храните 4 и точку от A до 4; Если это уже существует, укажите A на этот адрес напрямую. Следовательно, изменение значения А не повлияет на значение b. Следует отметить, что этот обмен данными отличается от обмена ссылками из двух объектов, указывающих на один объект одновременно, потому что в этом случае модификация A не повлияет на B, это осуществляется компилятором, что способствует сохранению пространства. Переменная ссылка объекта изменяет внутреннее состояние этого объекта и будет влиять на ссылку на другую ссылку объекта.
Строка - это специальные данные упаковки. Можно использовать:
String str = new String ("ABC"); String str = "abc"; Есть две формы для создания. Первый - использовать новый () для создания нового объекта, который будет храниться в куче. Новый объект создается каждый раз, когда его называют.
Второй тип - сначала создать переменную STR для объекта класса строки в стеке, а затем выяснить, хранится ли в стеке «ABC». Если нет, храните «ABC» в стеке и позвольте Str наметить на «ABC». Если уже есть «ABC», напрямую позвольте STR наметить на «ABC».
При сравнении, являются ли значения в классе равными, используйте метод equals (); При тестировании, указывают ли ссылки двух классов обертки на один и тот же объект, используйте == и используйте пример ниже, чтобы проиллюстрировать вышеуказанную теорию.
String str1 = "abc"; String str2 = "abc"; System.out.println (str1 == str2); //истинный
Видно, что Str1 и STR2 указывают на тот же объект.
String str1 = new String ("ABC"); String str2 = new String ("ABC"); System.out.println (str1 == str2); // ЛОЖЬ Новый метод состоит в том, чтобы генерировать разные объекты. Генерируйте по одному за раз.
Следовательно, во втором пути создаются несколько строк «ABC», и в памяти есть только один объект. Этот метод написания полезен и сохраняет пространство памяти. В то же время он может в определенной степени улучшить скорость работы программы, поскольку JVM автоматически решает, необходимо ли создавать новый объект на основе фактической ситуации данных в стеке. Для кода строки str = new String ("ABC");, новые объекты создаются в куче независимо от того, равны ли их строки или нет, необходимы ли это для создания новых объектов, тем самым увеличивая бремя на программе.
С другой стороны, примечание: когда мы определяем класс, используя формат, такой как String Str = "ABC";, мы всегда считаем само собой разумеющимся, что создаем объект Str String Class. (Не обязательно, потому что если нет заранее, оно будет создано. Это создание объекта. Если уже есть, то укажите на исходный объект)! Объект, возможно, не был создан! И, может быть, просто укажите на объект, который был создан ранее. Только с помощью метода нового () мы можем убедиться, что новый объект создается каждый раз. Из -за неизменного характера класса строк, когда строковая переменная должна часто преобразовать его значение, вам следует рассмотреть возможность использования класса StringBuffer для повышения эффективности программы.