Вы находитесь на странице: 1из 21

5. Programa Java que guarda en un array 10 nmeros enteros que se leen por teclado.

A continuacin se recorre el array y calcula cuntos nmeros son positivos, cuntos


negativos y cuntos ceros.

// Contar el nmero de elementos positivos, negativos y ceros de un array de 10


elementos.
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] numeros = new int[10];
int pos = 0, neg = 0, cero = 0; //contadores
int i;

//Leemos los valores por teclado y los guardamos en el array


System.out.println("Lectura de los elementos del array: ");
for (i = 0; i < numeros.length; i++) {
System.out.print("numeros[" + i + "]= ");
numeros[i] = sc.nextInt();
}
//se recorre el array para contar positivos, negativos y ceros
for (i = 0; i < numeros.length; i++) {
if (numeros[i] > 0) {
pos++;
} else if (numeros[i] < 0) {
neg++;
} else {
cero++;
}
}
//mostrar resultados
System.out.println("Positivos: " + pos);
System.out.println("Negativos: " + neg);
System.out.println("Ceros: " + cero);
}
}

6. Programa Java que llene un array con 10 nmeros enteros que se leen por teclado.
A continuacin calcula y muestra la media de los valores positivos y la de los valores
negativos del array.

/*
* Leer 10 nmeros enteros y mostrar la media de los valores positivos y la de los
valores negativos.
*/
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] numeros = new int[10];
int pos = 0, neg = 0; //contadores para positivos y negativos
int i;
double sumaPos = 0, sumaNeg = 0; //suma de positivos y negativos
//Leemos los valores por teclado y los guardamos en el array
System.out.println("Lectura de los elementos del array: ");
for (i = 0; i < numeros.length; i++) {
System.out.print("numeros[" + i + "]= ");
numeros[i]=sc.nextInt();
}
//se recorre el array para sumar positivos y negativos
for (i = 0; i < numeros.length; i++) {
if (numeros[i] > 0){ //sumar positivos
sumaPos += numeros[i];
pos++;
} else if (numeros[i] < 0){ //sumar negativos
sumaNeg += numeros[i];
neg++;
}
}
//mostrar resultados
if (pos != 0) {
System.out.println("Media de los valores positivos: " + sumaPos / pos);
} else {
System.out.println("No ha introducido nmeros positivos");
}
if (neg != 0) {
System.out.println("Media de los valores negativos: " + sumaNeg / neg);
} else {
System.out.println("No ha introducido nmeros negativos");
}
}
}

7. Programa Java para leer la altura de N personas y calcular la altura media. Calcular
cuntas personas tienen una altura superior a la media y cuntas tienen una altura
inferior a la media. El valor de N se pide por teclado y debe ser entero positivo.

/*
* Leer la altura de N personas y calcular la altura media
* Mostra cuntos hay superiores a la media.
*/
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i, N;
int contMas = 0, contMenos = 0;
double media = 0;
//Leer el nmero de personas
do{
System.out.print("Nmero de personas: ");
N = sc.nextInt();
}while(N<=0);
//Se crea el array de tamao N
double[] alto = new double[N];
//Leer alturas
System.out.println("Lectura de la altura de las personas: ");
for (i = 0; i < N; i++) {
System.out.print("persona " + (i+1) + " = ");
alto[i] = sc.nextDouble();
media = media + alto[i]; //se suma la estatura leda para calcular la media
}
//Calcular la media
media = media / N;
//recorremos el array para ver cuantos hay ms altos
//que la media y cuantos ms bajos
for (i = 0; i < alto.length; i++) {
if (alto[i] > media){ //si la estatura es mayor que la media
contMas++;
} else if (alto[i] < media){ //si es menor
contMenos++;
}
}
//Mostrar resultados
System.out.println("Estatura media: " + media);
System.out.println("Personas con estatura superior a la media: " + contMas);
System.out.println("Personas con estatura inferior a la media: " + contMenos);
}
}

1) Crea un array de 10 posiciones de nmeros con valores pedidos


por teclado. Muestra por consola el indice y el valor al que
corresponde. Haz dos mtodos, uno para rellenar valores y otro
para mostrar.

Esconder
1 import javax.swing.JOptionPane;
2 public class arrayApp {
3
4
5 public static void main(String[] args) {
6
7 //Esto es opcional
8 final int TAMANIO=10;
9
10 int num[]=new int[TAMANIO];
11
12 //Invocamos las funciones
rellenarArray(num);
13
14
mostrarArray(num);
15 }
16
17 public static void rellenarArray(int lista[]){
18 for(int i=0;i<lista.length;i++){
19 String texto=JOptionPane.showInputDialog("Introduce un nmero");
20 lista[i]=Integer.parseInt(texto);
21 }
}
22
23
public static void mostrarArray(int lista[]){
24
for(int i=0;i<lista.length;i++){
25
System.out.println("En el indice "+i+" esta el valor "+lista[i]);
26 }
27 }
28 }
29

2) Crea un array de nmeros donde le indicamos por teclado el


tamao del array, rellenaremos el array con nmeros aleatorios
entre 0 y 9, al final muestra por pantalla el valor de cada posicin
y la suma de todos los valores. Haz un mtodo para rellenar el
array (que tenga como parmetros los nmeros entre los que
tenga que generar), para mostrar el contenido y la suma del array
y un mtodo privado para generar nmero aleatorio (lo puedes usar
para otros ejercicios).

Esconder
3) Crea un array de nmeros de un tamao pasado import javax.swing.JOptionPane;
por teclado, el array contendr nmeros aleatorios public class arrayNumAleatorios
primos entre los nmeros deseados, por ltimo nos
indica cual es el mayor de todos. public static void main(Stri
args) {
Haz un mtodo para comprobar que el nmero
//Indicamos el tamao
aleatorio es primo, puedes hacer todos lo mtodos String
que necesites. texto=JOptionPane.showInputDia
ntroduce un tamao");
Esconder int num[]=new
1 import javax.swing.JOptionPane; int[Integer.parseInt(texto)];

2
//Invocamos las funcio
3 public class Ejercicio_DiscoDurodeRoer_Arrays_3 { rellenarNumAleatorioAr
4 m, 0, 9);
5 public static void main(String[] args) {
6 mostrarArray(num);
7 //Indicamos el tamao }
8 String texto=JOptionPane.showInputDialog("Introduce un tamao");
9 int num[]=new int[Integer.parseInt(texto)]; public static void
10 rellenarNumAleatorioArray(int
//Invocamos las funciones lista[], int a, int b){
11
rellenarNumPrimosAleatorioArray(num, 1, 100); for(int
12
i=0;i<lista.length;i++){
13 mostrarArray(num); //Generamos un nm
14 entre los parametros pasados
15 //Saco el primo mayor lista[i]=((int)Mat
16 r(Math.random()*(a-b)+b));
int primoMayor=mayor(num);
}
17 System.out.println("El primo ms grande es el "+primoMayor);
}
18 }
19
public static void
20 public static void rellenarNumPrimosAleatorioArray(int
mostrarArray(int lista[]){
21
for(int
22 int i=0; i=0;i<lista.length;i++){
23 System.out.println
24 //Usamos mejor un while, ya que solo el
aumentara indice
cuando "+i+"
genereesta el valor
un primo
while(i<lista.length){ "+lista[i]);
25
26 int num=((int)Math.floor(Math.random()*(a-b)+b));}
}
27 if (esPrimo(num)){
}
lista[i]=num;
28
i++;
29 }
30 }
31 }
32 private static boolean esPrimo (int num){
33
//Un numero negativo, el 0 y el 1, son directamente no primos.
34
35
36
37 if (num<=1){
38 return false;
39 }else{
40
41 //declaracion
42 int prueba;
43 int contador=0;
44 //Hacemos la raiz cuadrada y lo usamos para dividir el numero original
45 prueba=(int)Math.sqrt(num);
//Bucle que cuenta los numeros divisibles, podemos hacerlo con while
46
for (;prueba>1;prueba--){
47
if (num%prueba==0){
48
contador+=1;
49 }
50 }
51 return contador < 1;
52 }
53 }
54
55 public static void mostrarArray(int lista[]){
56 for(int i=0;i<lista.length;i++){
57 System.out.println("En el indice "+i+" esta el valor "+lista[i]);
}
58 }
59
60
public static int mayor(int lista[]){
61
int mayor=0;
62
for(int i=0;i<lista.length;i++){
63 if(lista[i]>mayor){
64 mayor=lista[i];
65 }
66 }
67
68 return mayor;
}
69
70
71
72
73
4) Crea un array de nmeros de 100 posiciones, que contendr los
nmeros del 1 al 100. Obtn la suma de todos ellos y la media.

Esconder
1
2 public class SumaMediaArrayApp {
3
4 public static void main(String[] args) {
5
6 //Creo un array
7 int[] numeros=new int[100];
8
//Declaro las variables necesarias
9
int suma=0;
10
double media;
11
12
//Recorro el array, asigno nmeros y sumo
13
for(int i=0;i<numeros.length;i++){
14 numeros[i]=i+1;
15 suma+=numeros[i];
16 }
17
18 //Calculo la media y muestro la suma y la meda
19 System.out.println("La suma es "+suma);
20
media=(double)suma/numeros.length;
21
22
System.out.println("La media es "+media);
23
24 }
25
26 }
27

5) Crea un array de caracteres que contenga de la A a la Z (solo


las maysculas). Despus, ve pidiendo posiciones del array por
teclado y si la posicion es correcta, se aadira a una cadena que
se mostrara al final, se dejar de insertar cuando se introduzca un
-1.

Por ejemplo, si escribo los siguientes numeros


0 //Aadira la A
5 //Aadira la F
25 //Aadira la Z
50 //Error, inserte otro numero
-1 //fin

Cadena resultante: AFZ

Esconder
1 import java.util.Scanner;
2
3 public class FormaPalabrasApp {
4
5 public static void main(String[] args) {
6
7 //restamos La posicion mayor Z a la posicion menor (sumamos 1 para que no s
8 char abecedario[]=new char[('Z'-'A')+1];
9
10 //creamos el abecedario
11 for(int i='A', indice=0;i<='Z';i++, indice++){
abecedario[indice]=(char)i;
12
}
13
14
Scanner sn=new Scanner(System.in);
15
16 //Pedimos un numero, que sern posiciones del array
17 System.out.println("inserte un numero entre 0 y "+(abecedario.length-1)+".
18 int num=sn.nextInt();
19
20 String cadena="";
21
22 while(num!=-1){
23
24 //Comprobamos que el nmero es correcto
25 if(num>=0 && num<abecedario.length){
26
27 cadena+=abecedario[num];
System.out.println("Inserte un numero entre 0 y "+(abecedario.lengt
28 }else{
29
30
System.out.println("Numero no valido inserte un numero entre 0 y "+
31 }
32
33 num=sn.nextInt(); //lo pedimos de nuevo
34
35 }
36
37 //Resultado final
System.out.println("La cadena resultante es "+cadena);
38
39
}
40
41 }
42
43

6) Pide al usuario por teclado una frase y pasa sus caracteres a un


array de caracteres. Puedes hacer con o sin mtodos de String.

Esconder
Version 1: sin metodos de String
1 import java.util.Scanner;
2
3 public class MuestraCaracteresApp {
4
5 public static void main(String[] args) {
6
7 Scanner sn=new Scanner(System.in);
8
9 //Pido al usuario que escriba una frase
10 System.out.println("Escriba una frase");
11
//Recomiendo usar nextLine en lugar de next por los espacios
12
String frase=sn.nextLine();
13
14 //Creamos un array de caracteres
15 char caracteres[]=new char[frase.length()];
16
17 //Recorremos la frase y cogemos cada caracter y lo metemos en el array
18
19 for(int i=0;i<frase.length();i++){
20 caracteres[i]=frase.charAt(i);
System.out.println(caracteres[i]);
21 }
22
23 }
24
25 }
26

7) Crea dos arrays de nmeros con una posicin pasado por


teclado.

Uno de ellos estar rellenado con nmeros aleatorios y el otro


apuntara al array anterior, despus crea un nuevo array con el
primer array (usa de nuevo new con el primer array) con el mismo
tamao que se ha pasado por teclado, rellenalo de nuevo con
nmeros aleatorios.

Despus, crea un mtodo que tenga como parmetros, los dos


arrays y devuelva uno nuevo con la multiplicacin de la posicin 0
del array1 con el del array2 y as sucesivamente. Por ltimo,
muestra el contenido de cada array.

Llama al final al recolector de basura.

Esconder
1 import javax.swing.JOptionPane;
2 public class MultiplicacionApp {
3
4 public static void main(String[] args) {
5
6 //Indicamos el tamao
7 String texto=JOptionPane.showInputDialog("Introduce un tamao");
8 int tamanio=Integer.parseInt(texto);
9
//Creamos los arrays
10 int array1[]=new int [tamanio];
11 int array2[];
12
13 //Rellenamos el array1
14 rellenarNumAleatorioArray(array1, 10, 100);

15
//Apuntamos el array2 al array1
16 array2=array1;
17
18 //Creamos un nuevo array, usando el array1. Array1 tendra una nueva direcci
19 array1=new int[tamanio];
20
21 //Lo volvemos a rellenar, ya que al crear el array de nuevo no contiene los
22 rellenarNumAleatorioArray(array1, 10, 100);
23
24 //Contiene el array con el resultado de multiplicar los valores de los arra

25 int array3[]=multiplicador(array1, array2);

26
//Mostramos el contenido de los arrays
27
28 System.out.println("Array1");
29 mostrarArray(array1);
30
31 System.out.println("Array2");
32 mostrarArray(array2);
33
34 System.out.println("Array3");
mostrarArray(array3);
35
36 //Llamamos al recolector de basura
37 System.gc();
38
39 }
40 public static void rellenarNumAleatorioArray(int lista[], int a, int b){
41 for(int i=0;i<lista.length;i++){
42 //Generamos un nmero entre los parametros pasados
43 lista[i]=((int)Math.floor(Math.random()*(a-b)+b));
}
44 }
45
46
public static void mostrarArray(int lista[]){
47
for(int i=0;i<lista.length;i++){
48 System.out.println("En el indice "+i+" esta el valor "+lista[i]);
49 }
50 }
51
52
53
54
55 public static int[] multiplicador(int array1[], int array2[]){
56 int array3[]=new int[array1.length];
57 for(int i=0;i<array1.length;i++){
array3[i]=array1[i]*array2[i];
58
}
59
return array3;
60 }
61 }
62
63
64

8) Crea un array de nmeros de un tamao pasado por teclado, el


array contendr nmeros aleatorios entre 1 y 300 y mostrar
aquellos nmeros que acaben en un dgito que nosotros le
indiquemos por teclado (debes controlar que se introduce un
numero correcto), estos deben guardarse en un nuevo array.

Por ejemplo, en un array de 10 posiciones e indicamos mostrar los


nmeros acabados en 5, podra salir 155, 25, etc.

Esconder
1 import javax.swing.JOptionPane;
2 public class NumTerminadosEnApp {
3
4 public static void main(String[] args) {
5
6 //Indicamos el tamao
7 String texto=JOptionPane.showInputDialog("Introduce un tamao");
8 int num[]=new int[Integer.parseInt(texto)];
9
10 int ultimoDigito;
do{
11
texto=JOptionPane.showInputDialog("Introduce numero entre 0 y 9");
12 ultimoDigito=Integer.parseInt(texto);
13 }while(!(ultimoDigito>=0 && ultimoDigito<=9));
14
15 //rellenamos el array
16 rellenarNumAleatorioArray(num, 1, 300);
17
//Creamos un array que contenga los numeros terminados en el numero especif
18
int terminadosEn[]=numTerminadosEn(num, ultimoDigito);
19
20
//Mostramos el resultado, mira el metodo de mostrarArrays
21 // mostrarArrayTerminadosEn(num);
22 mostrarArrayTerminadosEn(terminadosEn);
23
24 }
25 public static void rellenarNumAleatorioArray(int lista[], int a, int b){
26 for(int i=0;i<lista.length;i++){
27 //Generamos un nmero entre los parametros pasados
28 lista[i]=((int)Math.floor(Math.random()*(a-b)+b));
}
29 }
30
31 public static void mostrarArrayTerminadosEn(int lista[]){
32
for(int i=0;i<lista.length;i++){
33 //No incluimos las posiciones que tengan un 0
34 if(lista[i]!=0){
35 System.out.println("El numero "+lista[i]+" acaba en el numero desea
36 }
}
37 }
38
39
public static int[] numTerminadosEn (int num[], int ultimo_numero){
40
41 //Array que almacenara los numeros terminados en el numero pedido
42 int terminadosEn[]=new int[num.length];
43
44 int numeroFinal=0;
45
46 for (int i=0;i<terminadosEn.length;i++){
47
48 /*
49 * Restamos el numero por el mismo numero sin unidades
50 * Por ejemplo, 325-320=5
*/
51
numeroFinal=num[i]-(num[i]/10*10);
52
53 //Si el numero obtenido es el buscado, lo aadimos
54 if (numeroFinal==ultimo_numero){
55 terminadosEn[i]=num[i];
56 }
57 }
58
59
60
61
return terminadosEn;
62
}
63
64 }
65
66
67

9) Calcula la letra de un DNI, pediremos el DNI por teclado y nos


devolver el DNI completo.

Para calcular la letra, cogeremos el resto de dividir nuestro dni


entre 23, el resultado debe estar entre 0 y 22. Haz un mtodo
donde segn el resultado de la anterior formula busque en un array
de caracteres la posicin que corresponda a la letra. Esta es la
tabla de caracteres:

POSICION LETRA

0 T

1 R

2 W

3 A

4 G

5 M

6 Y
7 F

8 P

9 D

10 X

11 B

12 N

13 J

14 Z

15 S

16 Q

17 V

18 H

19 L

20 C

21 K

22 E

Por ejemplo, si introduzco 70588387, el resultado sera de 7 que


corresponde a F.
Esconder
1 import javax.swing.JOptionPane;
2 public class LetraDNIApp {
3
4
5 public static void main(String[] args) {
6
7 //Declaramos como constante por lo que dividir
8 final int DIVISOR=23;
9
10 //Insertamos el DNI
String texto=JOptionPane.showInputDialog("Escribe los numero de tu DNI");
11
int dni=Integer.parseInt(texto);
12
13 //Sacamos el resto
14 int res=dni%DIVISOR;
15
16 //Invocamos el metodo
17 char letra=letraNIF(res);
18
19 //Mostramos el DNI completo
20 System.out.println("Tu DNI es " +dni+letra);
21
22 }
23 public static char letraNIF(int res){
24
25 //Definimos el array de char
26 char letrasNIF[]={'T', 'R', 'W', 'A', 'G', 'M', 'Y',
'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z',
27
'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'};
28
29 //Devolvemos el valor en la posicion del array
30 return letrasNIF[res];
31 }
32 }
33

10) Crea un array de nmeros y otro de String de 10 posiciones


donde insertaremos notas entre 0 y 10 (debemos controlar que
inserte una nota valida), pudiendo ser decimal la nota en el array
de nmeros, en el de Strings se insertaran los nombres de los
alumnos.
Despus, crearemos un array de String donde insertaremos el
resultado de la nota con palabras.

Si la nota esta entre 0 y 4,99 , sera un suspenso

Si esta entre 5 y 6,99 , sera un bien.

Si esta entre 7 y 8,99 sera un notable.

Si esta entre 9 y 10 sera un sobresaliente.


Muestra por pantalla, el alumno su nota y su resultado en palabras.
Crea los mtodos que creas conveniente.

Esconder
1 import javax.swing.JOptionPane;
2 public class NotasApp {
3
4 public static void main(String[] args) {
5
6 //Tamao del array
7 final int TAMANIO=10;
8
9 //Creamos los arrays
10 String nombres[]=new String[TAMANIO];
11 double notas[]=new double[TAMANIO];
12
//Rellenamos el array de una vez
13
rellenarArrays(notas, nombres);
14
15 //Devuelve las notas con palabras
16 String resultado[]=aadeResultado(notas);
17
18 //Mostramos el resultado
19 mostrarArrays(nombres, notas, resultado);
20
}
21
22
public static void rellenarArrays(double notas[], String nombres[]){
23
for(int i=0;i<notas.length;i++){
24
//Introducimos los valores de una vez, se pueden hacer en metodos separ
25 nombres[i]=JOptionPane.showInputDialog("Introduce el nombre del alumno
26
27 double nota;
28 //Validamos la nota
do{
29
String texto=JOptionPane.showInputDialog("Introduce una nota del al
30 nota=Double.parseDouble(texto);
31 System.out.println(nota<=0 || nota>=10);
32 }while(nota<=0 || nota>=10);
33 notas[i]=nota;
34 }
35 }
36
37 public static void mostrarArrays(String nombres[], double notas[], String resulta
38 for(int i=0;i<nombres.length;i++){
39 System.out.println("El alumno "+nombres[i]+" tiene una nota de "+notas[
}
40 }
41
42
public static String[] aadeResultado(double notas[]){
43
44
String resultado[]=new String[notas.length];
45
for(int i=0;i<notas.length;i++){
46 //Convertimos la nota a entero, despues se quedara como estaba
47 switch((int)notas[i]){
48 case 1:
49 case 2:
50 case 3:
51 case 4:
52 resultado[i]="Suspenso";
53 break;
54 case 5:
55 case 6:
56 resultado[i]="Bien";
break;
57
case 7:
58
case 8:
59
resultado[i]="Notable";
60 break;
61 case 9:
62 case 10:
63 resultado[i]="Sobresaliente";
64 break;
65 }
}
66
return resultado;
67
}
68 }
69
70
71
72
73
74

12) Crea dos arrays multidimensionales de 23 y rellenalos como


quieras (nmeros aleatorios, por teclado o definido al crear el
array).

Haz un mtodo que sume los arrays multidimensionales, es decir,


la posicin 0, 0 del array1 con la posicin del array2 y as
sucesivamente, este metodo no debe devolver nada, haciendo que
deba pasarse el array multidimensional de suma como parmetro.
Muestra el contenido de cada array multidimensional.

Esconder
1 public class SumaMatricesApp {
2
3 /**
* @param args
4
*/
5
public static void main(String[] args) {
6
7 //Creamos los arrays multidimensionales
8 int tabla1[][]=new int [2][3];
9
int tabla2[][]=new int [2][3];
10
int sumamatrices[][]=new int [tabla1.length][tabla1[0].length];
11
12 //Rellenamos los dos primeros arrays
13 rellenarArrays(tabla1, 1, 200);
14 rellenarArrays(tabla2, 1, 200);
15
16 //Sumamos los arrays
SumaMatrices(tabla1, tabla2, sumamatrices);
17
18
//Mostramos los arrays
19 System.out.println("Array1 ");
20 imprimirTabla(tabla1);
21
22 System.out.println("Array2");
23 imprimirTabla(tabla2);
24
25
26
27 System.out.println("La suma de matrices es ");
28 imprimirTabla(sumamatrices);
29 }
30 public static void rellenarArrays(int tabla[][], int a, int b){
31 for(int i=0;i<tabla.length;i++){
32 for(int j=0;j<tabla[0].length;j++){
33 tabla[i][j]=((int)Math.floor(Math.random()*(a-b)+b));
34 }
}
35 }
36
37 public static void imprimirTabla (int tabla[][]){
38
for (int i=0;i<tabla.length;i++){
39
for (int j=0;j<tabla[0].length;j++){
40 System.out.print(tabla[i][j]+ " ");
41 }
42 System.out.println("");
43 }
System.out.println("");
44
45
}
46
public static int[][] SumaMatrices (int tabla1[][], int tabla2[][], int sumamatri
47
48
for (int i=0;i<sumamatrices.length;i++){
49
for (int j=0;j<sumamatrices[0].length;j++){
50 sumamatrices[i][j]=tabla1[i][j]+tabla2[i][j];
51 }
52 System.out.println("");
53 }
54 return sumamatrices;
}
55
56
}
57
58
59

13) Dado un array de nmeros de 5 posiciones con los siguiente


valores {1,2,3,4,5}, guardar los valores de este array en otro array
distinto pero con los valores invertidos, es decir, que el segundo
array debera tener los valores {5,4,3,2,1}.
Esconder
1
public class Ejercicio_DiscoDurodeRoer_Arrays_10 {
2
3
public static void main(String[] args) {
4
5 int[] array1={1,2,3,4,5};
6
7 int[] array2=new int[array1.length];
8
9 for(int i=(array1.length-1),j=0;i>=0;i--,j++){
10 array2[j]=array1[i];
11 System.out.println(array2[j]);
12 }
13 }
14
}
15