> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud2-programacion-estructurada/arrays/referencias.md).
# Referencias
A seguinte sentencia é de asignación de tamaño dun vector:
```java
idade = new int[10];
```
Constrúe un vector de elementos de tipo `int` e asígnaselle a variable `idade`.
O operador `new` en Java útilízase para crear novas instancias reservando espazo en memoria para dita instancia. É un dos operadores máis importantes de Java.
**Vamos ver como funciona o operador `new` no caso dos vectores**:
1. Primeiro **calcula o tamaño físico do vector**. É dicir o número de bytes que ocupa o vector. Obtense de multiplicar o tamaño do vector polo tamaño do tipo. Por exemplo, a variable anterior son 10 elementos e cada elemento (`int`) ocupa 32 bits (4 bytes). Polo tanto o vector ocupa 4 · 10 = 40 bytes en memoria.
2. Coñecendo o tamaño do vector, **búscase en memoria un oco libre con tamaño suficiente** para gardar todos os elementos do vector consecutivamente.
3. Reserva a memoria necesaria para almacenar a táboa e a marca como memoria ocupada.
4. Para finalizar recorre todos os elementos inicializándoos.
5. O seguinte paso é asignarlle a variable correspondente a ese espazo. Java dispón dun mecanismo para indicar onde está o vector na memoria. Cada posición de memoria ten unha dirección. En Java cada dirección denomínase **referencia**. A forma de que a variable saiba onde está o vector en memoria é asignándolle a referencia da primeira posición que ocupa. As variables de vectores o que realmente almacenan é a referencia. Neste caso a variable `idade` almacenará o valor `0x00000723`:copy:.
As referencias tamén son coñecidas noutros linguaxes e en Java como **punteiros**.
## Acceso a un elemento dun vector
O acceso en memoria dun elemento dun *array* en Java faise utilizando o índice do vector. Cada elemento dun vector está almacenado en posicións de memoria contiguas. Para acceder a un elemento en concreto, o índice multiplícase polo tamaño do tipo de dato (no caso de `int`, que ocupa 4 bytes), e despois accédese á dirección de memoria correspondente.
A fórmular para calcular esta dirección de memoria é:
`direccion_elemento = direccion_base + (índice_elemento * tamaño_do_elemento / tamaño_direccion_memoria)`:copy:
Para o exemplo anterior, `idade[0]`:copy:, está na posición de memoria base do *array*. Para acceder ao segundo elemento (`idade[1]`:copy:), Java calcula a posición de memoria como: `direccion_elemento = direccion_base + (1 * tamaño_do_elemento / tamaño_direccion_memoria)`:copy:.
### Tamanho das direccións de memoria
En Java, o tamaño dunha dirección de memoria depende da arquitectura da máquina virtual de Java (JVM) e do sistema operativo no que se estea executando o programa. Xeralmente, hai dous tipos de arquitectura:
1. **Arquitectura de 32 bits**: As direccións de memoria teñen un tamaño de **4 bytes** (32 bits).
2. **Arquitectura de 64 bits**: As direccións de memoria teñen un tamaño de **8 bytes** (64 bits).
Supoñendo que cada dirección de memoria ocupa 4 bytes (arquitectura de 32 bits) e dado que o tamaño dun `int` é 4 bytes, o segundo elemento estaría na dirección `direccion_base + 1`:copy: (`direccion_elemento = direccion_base + (1 * 32bits / 32 bits)`:copy:), o terceiro en `direccion_base + 2`:copy: (`direccion_elemento = direccion_base + (2 * 32bits / 32 bits)`:copy:), e así sucesivamente.
Polo tanto o valor de `idade[1]`:copy: atoparíase na dirección de memoria `0x00000724`:copy:, `idade[2]`:copy:en `0x00000725`:copy:, …
Este proceso faise de xeito automática, polo que ao acceder a un elemento mediante `array[indice]`:copy:, Java realiza o cálculo da dirección de memoria para acceder ao valor correcto de forma eficiente.
Por exemplo, se executamos as seguintes liñas:
```java
int t[] = new int[10];
System.out.println(t);
```
obtense a referencia a dirección de memoria que garda a variable. As referencias modifícanse en cada execución, dependendo da ocupación en memoria.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://educacion.gitbook.io/programacion/ud2-programacion-estructurada/arrays/referencias.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.