Arreglos en Java

Arreglos en Java
Los arreglos son colecciones ordenadas de datos del
mismo tipo.
Ejemplos :

Arreglo de bytes:
3 27 50 1 0 4
Arreglo de Strings:
“Ana” “Casa” “Auto” “12” “”

Arreglo de doubles:
3.0 50.4 0.0 -4.3
 Identificación y tamaño de un
arreglo
Cada arreglo se reconoce por un identificador y cada dato
se almacena en una posición indexada.

Un arreglo de largo N, tiene posiciones indexadas mediante

enteros desde 0 hasta N-1.
nombres

“Ana” “Juan” “Pedro” “Pía” “Mario”

Posición: 0 1 2 3 4

El máximo largo posible para un arreglo corresponde al

mayor valor permitido para un int.
 Pasos para crear un arreglo en
Java
1º: Definir una variable que identifique al arreglo, indicando
la naturaleza de los datos que se almacenarán:

tipo[ ] variable
o alternativamente:
tipo variable[ ]

2º: Instanciar el arreglo indicando el largo que tendrá, y

asignarlo a la variable:
variable = new tipo[ entero ]
Creación de un arreglo

Define que la variable edades

referenciará un arreglo de enteros.

int[] edades;
edades = new int[8];

Instancia un arreglo de enteros de

8 posiciones.
Asigna el arreglo instanciado
a la variable edades.
Ejemplos de creación de arreglos
Arreglo de byte de largo 1000:
byte[] valores;
valores = new byte[1000];

Arreglo de double de largo 4:

double nota[];
nota = new double[4];

Arreglo de String de largo 20:

int largo = 20;
String[] nombres;
nombres = new String[ largo ];
Forma abreviada para crear
arreglos
La definición de variable, instanciación del arreglo y su
asignación a la variable puede realizarse en una sola
instrucción:

tipo[ ] variable = new tipo[ entero ]

Ejemplo:

double[] nota = new double[4];

Otra forma para instanciar arreglos

También es posible instanciar arreglos escribiéndolos

como literales en el código fuente:

int[] nota ;
nota = { 23, 14, 55, 18 } ;

Instancia un arreglo de enteros de largo 4.

Acceso a las posiciones de un
arreglo
Se deben accesar mediante un subíndice de tipo entero
(byte, short, int o long):

...
int i;
long[] números;
números = new long[ 20 ];
...
i=0;
while( i < 20 ){
números[ i ] = i ;
i++;
}
...
 Se puede utilizar la propiedad length del arreglo para controlar
procesos iterativos sobre el mismo:

...
int i;
long[] números;
números = new long[ 20 ];
...
i=0;
while( i < números.length ) {
System.out.println( números[ i ] );
i++;
}
Recorrer un arreglo
...
  Tratar de accesar una posición inexistente del
arreglo, por ejemplo, la posición 10 de un arreglo
de largo 10.

Cuando lo anterior ocurre, se genera en tiempo de

ejecución una excepción denominada:

ArrayIndexOutOfBoundsException

Error típico en el manejo de

arreglos
 Una vez instanciado un arreglo, no puede modificarse su largo.
length es una propiedad o atributo del arreglo que contiene el largo
del mismo.

double[] nota;
nota = new double[4];
System.out.println( “El largo es ” + nota.length );
Consideraciones respecto del largo
de un Las
arreglo
propiedades o atributos se consultan sin paréntesis al final, a
diferencia de los métodos.
Consideraciones respecto del
arreglo de parámetros
El arreglo de parámetros declarado al inicio del
método main, es instanciado por Java al momento de
ejecutarse la aplicación.

El arreglo se instancia con un largo igual a la cantidad

de parámetros traspasados en la línea de comandos.

El arreglo debe ser declarado como arreglo de Strings.

Resumen de arreglos
Los arreglos se instancian.

La instanciación ocurre de tres formas:

◦ cuando se utiliza el operador new.
◦ cuando el arreglo es declarado literalmente.
◦ cuando se ejecuta la aplicación, en el caso
particular del arreglo de parámetros del
método main.
Resumen de arreglos
Los arreglos son referenciados desde una variable.

Todas las posiciones del arreglo son del mismo

tipo.

El atributo length permite acceder al largo del

arreglo.

Tratar de acceder una posición inexistente del

arreglo genera una excepción
ArrayIndexOutOfBoundsException.
Matrices
Java permite implementar matrices de la siguiente forma:

tipo[ ] [ ] variable = new tipo[ entero1 ] [ entero2 ]

Por ejemplo:
int[ ][ ] utilidad;
utilidad = new double[10][15];

O mediante literales:

double[ ][ ] uti;
uti = { {-1, 7, 15}, {3, 0, 2}, {4, -3, 12} };

uti[1][2] contiene un 2.
Particularidades de los arreglos
multidimensionales en Java

En rigor Java no provee arreglos multidimensionales.

Java los implementa mediante arreglos de arreglos.

Esto permite crear, por ejemplo, matrices bidimensionales

con cantidades de posiciones distintas por fila:
int[ ][ ] nota;
nota = { {-1,7,15}, {3, 2}, {4,-3,12}, {3} };
import java.util.*;
public class arreglocaracter{
public static void main(String[] args){

String nombre[];

nombre= new String[10];

int i;

Scanner var= new Scanner (System.in);

for(i=0;i<10;i++)
{
System.out.println("Ingrese nombre");
nombre[i]=var.nextLine();

}
for(i=0;i<10;i++)
{
System.out.println("Numero: "+ nombre[i]);
}
import java.util.*;
public class arreglo{
public static void main(String[] args){

int arr[]= new int[10];

int i;
Scanner var= new Scanner (System.in);

for(i=0;i<10;i++)
{
System.out.println("Ingrese numero");
arr[i]=var.nextInt();
}
for(i=0;i<10;i++)
{
System.out.println("Numero: "+ arr[i]);
} } }
import java.util.*;
public class promedio{
public static void main(String[] args){
int mayor=0,menor=1000;
int arr[]= new int[10];
int i;
Scanner var= new Scanner (System.in);
for(i=0;i<10;i++)
{ System.out.println("Ingrese numero");
arr[i]=var.nextInt();}
for(i=0;i<10;i++)
{ if(mayor<arr[i]) mayor=arr[i];
if(menor>arr[i]) menor=arr[i];
}
System.out.println("El numero mayor es"+ mayor);
System.out.println("El numero menor es"+ menor);
double promedio=(mayor+menor)/2;
System.out.println("El promedio es"+ promedio);} }
import java.util.*;
public class nombreconC{
public static void main(String[] args){
String arr[]= new String[10];
int i, con=0;
char letra;
Scanner var= new Scanner (System.in);
for(i=0;i<10;i++)
{ System.out.println("Ingrese nombre");
arr[i]=var.nextLine();
}
for(i=0;i<10;i++)
{
System.out.println("El nombre es : "+ arr[i]); }
for(i=0;i<10;i++)
{
letra=arr[i].charAt(0);
if(letra=='C'|| letra=='c')7
{con++;}
}
System.out.println("La cantidad de nombre que comienzan con c es : "+ con);
} }