Your SlideShare is downloading. ×
Tema6
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Tema6

3,774
views

Published on

Published in: Technology, Travel

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
3,774
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
161
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. ARREGLOS JAVA Ing. Zenaida Huanca Llamo Programación en Java TEMA 6
  • 2. Creando y usando Arreglos
    • Una coleción de datos almacenados bajo un solo nombre es conocido como estructura de datos.
    • Un objeto es un tipo de estructura de datos, porque se puede almacenar multiples datos en sus variables de instancia.
    • La única estructura de datos en Java es array.
  • 3. Arreglos Unidimensionales
    • En un arreglo, todos los datos (elementos) deben tener el mismo tipo de datos.
    • Un arreglo unidimensional puede ser visualizado:
    • Un arreglo cuyos elementos estan alineados en una sola linea se denominan arreglos unidimensionales .
  • 4. Creando Arreglos
    • int[] a;
    • String[] b;
    • int a[];
    • String b[];
    • Para separar el espacio de memoria del arreglo hay que usar la palabra clase new :
    • a = new int[10];
    • Tener cuidado no acceder a los elementos de un arreglo antes que el arreglo haya sido inicializado. Haciendo eso causara la excepción NullPointerException .
  • 5. Creando Arreglos
    • int[] a = new int[10];
    • int n = 10;
    • int[] a = new int[n];
  • 6. Creando Arreglos
    • Un arreglo puede ser inicializado al mismo tiempo que es declarado:
    • int[] a = {3, 0, 3, 4, 5};
    • La palabra new no es usada si un inializador está presente.
    • Cuando un arreglo es creado usando new , los elementos del arreglo toman por valores por defecto:
      • Números son asignados a cero.
      • boolean elementos son seteados a false .
      • Arreglo de objetos son seteados a null .
  • 7. Visualizando Arreglos
    • Cada elemento tiene un índice , que especifica su posición dentro del arreglo.
    • Si un arreglo tiene n elementos, solo los números entre 0 y and n – 1 son índices válidos.
    • En un arreglo con 10 elementos, the elementos pueden ser numerados desde 0 hasta 9.
  • 8. Procesando los elementos de un Arreglo
    • Si es necesario visitar los elementos en un arreglo, un loop puede ser usado:
      • El contador será inicializado a 0.
      • Cada pasada a través del loop, el contador se incrementará.
      • El loop terminará cuando el contador llega hasta el número de elementos en el arreglo.
    • El número de elementos en un arreglo a es dado por la expresión a.length .
  • 9. Procesando los elementos en un Arreglo
    • int sum = 0;
    • int i = 0;
    • while (i < a.length) {
    • sum += a[i];
    • i++;
    • }
  • 10. Ejemplo Arreglos Unidimensionales
    • import java.io.*;
    • class arreglo {
    • int A[]; int i,x;
    • BufferedReader br=new BufferedReader (new InputStreamReader (System.in));
    • String temp;
    • public arreglo()
    • {
    • A=new int[50];
    • }
    • public void ingresa() throws IOException
    • {
    • for (i=0;i<3;i++)
    • {
    • System.out.println(&quot;Ingrese valor: &quot;+(i+1)+&quot;: &quot;);
    • temp=br.readLine();
    • x=Integer.parseInt(temp);
    • A[i]=x;
    • }
    • }
  • 11. Ejemplo Arreglos Unidimensionales
    • public void listado()
    • {
    • for(i=0;i<3;i++)
    • {
    • System.out.println(&quot;valor : &quot;+ (i+1)+ &quot;: &quot;+A[i]);
    • }
    • }
    • }
    • public class testarreglo
    • {
    • public static void main(String args[]) throws IOException
    • {
    • arreglo x;
    • x=new arreglo();
    • x.ingresa();
    • x.listado();
    • }
    • }
  • 12. Como los Arreglos son almacenados
    • Una variable array contiene una referencia a donde los elementos del arreglos son almacenados.
    • El almacenamiento para un arreglo llamado a contiene 10 enteros:
    • Arrays son “garbage collected” de igual forma como otros objetos. Cuando no hay mas referencias a un arreglo, el espacio ocupado por el arreglo puede ser restaurado automaticamente.
  • 13. Redimensionando un Arreglo
    • Si bien los arreglos tienen tamaño definido. Es posible redimensionar un arreglo si este se llena. El truco es crear un nuevo arreglo para remplazar el antiguo.
    • Redimensionar un arreglo toma tres pasos:
    • 1. Crear un nuevo arreglo que sea mas grande que el anterior.
    • 2. Copiar los elementos del antiguo arreglo en el nuevo arreglo.
    • 3. Asignar el nuevo arreglo a la variable del arreglo antiguo.
  • 14. Redimensionando un Arreglo
    • Codigo que duplica el tamaño del arreglo accounts :
    • BankAccount[] tempArray =
    • new BankAccount[accounts.length*2];
    • for (int i = 0; i < accounts.length; i++)
    • tempArray[i] = accounts[i];
    • accounts = tempArray;
    • Duplicar el tamaño de un arreglo provee plenitud de espacio para los nuevos elementos.
  • 15. Redimensionando un Arreglo
    • Cuando un arreglo es redimensionado, el antiguo arreglo puede ser utilizado por el garbage collector.
    • El copiado de elementos desde el antiguo arreglo al nuevo usualmente no es un proceso largo. Si los elementos son objetos, solo las referencias de los objetos son copiadas, no los objetos.
    • Adicionalmente, Java provee un método llamado System.arraycopy que puede ser usado para copiar los elementos desde un arreglo a otro.
  • 16. Redimensionando un Arreglo
    • Un llamado de System.arraycopy copia los elementos de accounts into tempArray , iniciando en la posición 0 in ambos arreglos:
    • System.arraycopy(accounts, 0, tempArray,0, accounts.length);
    • El último argumento es el número de elementos a ser copiados.
    • Instancias de la clase de Java Vector muestra como los arrays crecen automaticamente cuando ellos estan llenos.
  • 17. Ejemplo Aplicativo
    • class arreglo
    • {
    • int A[]; int i,j,x;
    • BufferedReader br=new BufferedReader (new InputStreamReader (System.in));
    • String temp;
    • public arreglo()
    • {
    • A=new int[3];
    • }
    • public void ingresa() throws IOException
    • {
    • for (i=0;i<3;i++)
    • { System.out.println(&quot;Ingrese valor: &quot;+(i+1)+&quot;: &quot;);
    • temp=br.readLine();
    • x=Integer.parseInt(temp);
    • A[i]=x;
    • }
    • }
  • 18. Ejemplo Aplicativo
    • public void listado()
    • {
    • for(i=0;i<A.length;i++)
    • {
    • System.out.println(&quot;valor :[&quot;+ (i+1)+ &quot;: &quot;+A[i]);
    • }
    • }
    • public void copia(arreglo B)
    • {
    • System.arraycopy(A, 0, B.A, 0, 3);
    • }
    • }
  • 19. Ejemplo Aplicativo
    • public class testarreglo
    • {
    • public static void main(String args[]) throws IOException
    • {
    • arreglo x=new arreglo();
    • arreglo y=new arreglo();
    • x.ingresa();
    • x.listado();
    • x.copia(y);
    • y.listado();
    • }
  • 20. Arreglos Multidimensionales
    • Un array multidimensional es un array de arrays.
    • Es decir una matriz de 4x2 en realidad en Java está formada por 5 arrays: 1 array con 4 arrays.
    • Y si estuvieramos hablando de tres dimensiones entonces tendriamos un array de arrays de arrays
    • Para crear un array bidimensional:
    • modificador_acceso tipo [][]nombre=new tipo [long][long]
  • 21. Arreglos Bidimensionales
    • Ejemplo
    • int [][]notas =new int [6][4]
    • Al igual que los arrays unidimensionales tambien podemos inicializar a los arrays bidimensionales.
    • private int [][]numeros = {{1,2,3},{1,2,3}};
    • private String [][]dias = {{“Lunes”,”Martes”},{“Miercoles}};
  • 22. Ejemplo Apicativo Arreglos Bidim.
    • import java.io.*;
    • class arreglo1
    • {
    • int A[][]; int i,j,x;
    • BufferedReader br=new BufferedReader (new InputStreamReader (System.in));
    • String temp;
    • public arreglo()
    • {
    • A=new int[50][50];
    • }
  • 23. Ejemplo Aplicativo Arreglos Bidim.
    • public void ingresa() throws IOException
    • {
    • for (i=0;i<3;i++)
    • { for (j=0;j<3;j++)
    • {
    • System.out.println(&quot;Ingrese valor: &quot;+(i+1)+&quot;,&quot;+(j+1)+&quot;: &quot;);
    • temp=br.readLine();
    • x=Integer.parseInt(temp);
    • A[i][j]=x;
    • }
    • } }
    • public void listado()
    • {
    • for (i=0;i<3;i++)
    • {
    • for(j=0;j<3;j++)
    • {
    • System.out.println(&quot;valor [&quot;+ (i+1)+&quot;,&quot;+(j+1)+ &quot;: &quot;+A[i][j]);
    • }
    • }
    • }
    • }
  • 24. Ejemplo Aplicativo Arreglo Bidim.
    • public class testarreglo1
    • {
    • public static void main(String args[]) throws IOException
    • {
    • arreglo1 x;
    • x=new arreglo1();
    • x.ingresa();
    • x.listado();
    • }
    • }