ORCID iD iconorcid.org/0000-0002-8243-2186

T7 Java

T-7

T-7

 

 

 

C3.1 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

El método compare se implementa en una clase externa al tipo que se quiere comparar

Si c es un objeto de tipo Comparator, la invocación c.compare(p1,p2) devuelve un boolean

La invocación p1.compareTo(p2) devuelve un boolean

Un objeto de tipo Comparable se crea mediante el operador new

El método compareTo debe implementarse en la clase que implementa el tipo


C3.2 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

El método compare debe implicar las mismas propiedades que el método equals

El método compareTo debe ser coherente con el método equals

El método compareTo se implementa mediante invocaciones de los métodos equals de las propiedades

Si un tipo tiene orden natural, su interfaz debe extender a Comparable

El método compareTo recibe dos argumentos del tipo que se quiere comparar


C3.3 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

El método compareTo se implementa en una clase externa al tipo que se quiere comparar

Si p1.equals(p2) es true entonces p1.compareTo(p2) debe ser 0

Si un tipo tiene orden natural, su interfaz debe implementar a Comparable

El método compare se implementa mediante invocaciones de los métodos compareTo de las propiedades del tipo

El método compare recibe dos argumentos del tipo que se quiere comparar


C3.4 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

El método compareTo debe implicar las mismas propiedades que el método equals

El método compare debe ser coherente con el método equals

El método compare debe devolver un valor igual a 0 si el objeto this es igual al argumento formal

El método compareTo debe devolver un valor mayor que 0 si el primer argumento es mayor que el segundo

El método compareTo recibe un argumento del tipo que lo implementa


C3.5 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

La interfaz Comparable sirve para implementar el orden natural de un tipo

Si p1.equals(p2) es true entonces p1.compareTo(p2) debe ser distinto de 0

Si p1.compareTo(p2) es mayor que 0 entonces p1.equals(p2) debe ser true

Si p1.compareTo(p2) es igual a 0 entonces p1.equals(p2) debe ser false

La interfaz Comparator sirve para implementar un orden alternativo de un tipo


c4.10 - Sea el código siguiente: 
  SortedSet<Character> ss = new TreeSet<Character>();   
  ss.add('X'); ss.add('C'); ss.add('R'); ss.add('Q');   
  SortedSet<Character> fin = ss.tailSet('Q');   
  fin.add('S');   ss.add('D');   
  System.out.println(ss);

Indique el resultado en pantalla. Separe los caracteres por comas sin blancos.
Por ejemplo, A,F,Q,R.


c4.11 - Sea el código siguiente: 
   SortedSet<Character> ss = new TreeSet<Character>();  
   ss.add('X'); ss.add('C'); ss.add('F');
    ss.add('P');  ss.add('R'); ss.add('Q');  
   SortedSet<Character> inicio = ss.headSet('G');  
   System.out.println(inicio);

Indique el resultado en pantalla. Separe los caracteres por comas sin blancos. Por ejemplo, A,F,Q,R.


c4.12 - Sea el código siguiente: 
   SortedSet<Character> ss = new TreeSet<Character>();  
   ss.add('X'); ss.add('C'); ss.add('F');
     ss.add('P'); ss.add('R'); ss.add('Q');  
   SortedSet<Character> medio = ss.subSet('G', 'R');  
   System.out.println(medio);

Indique el resultado en pantalla. Separe los caracteres por comas sin blancos. Por ejemplo: A,F,Q,R.


c4.13 - Sea el código siguiente: 
   SortedSet<Character> ss = new TreeSet<Character>();  
   ss.add('X'); ss.add('C'); ss.add('F');
    ss.add('P'); ss.add('R'); ss.add('Q');  
   SortedSet<Character> fin = ss.tailSet('Q');  
   System.out.println(fin);    

Indique el resultado en pantalla. Separe los caracteres por comas sin blancos. 
Por ejemplo: A,F,Q,R


c4.3 - Sea la lista números formada por los elementos [4, 9, 15, 7, 3]. ¿Cuál será el resultado del siguiente código? 
for (Integer n:numeros) {
     n++;  
} 
System.out.println(numeros);

Se lanza la excepción IndexOutOfBoundsException

[5, 10, 16, 8, 4] y se lanza la excepción IndexOutOfBoundsException

 [4, 9, 15, 7, 3] y se lanza la excepción IndexOutOfBoundsException

[4, 9, 15, 7, 3]

[5, 10, 16, 8, 4]


c4.4 - Sea la lista números formada por los elementos [4, 9, 15, 7, 3]. ¿Cuál será el resultado del siguiente código? 
for (int i = 0; i <= numeros.size(); i++) {     
     numeros.set (i, numeros.get(i) + 1);  
}  
System.out.println(numeros);

5, 10, 16, 8, 4 y se lanza la excepción IndexOutOfBoundsException

5, 10, 16, 8 y se lanza la excepción IndexOutOfBoundsException

4, 9, 15, 7, 3

5, 10, 16, 8, 4

Se lanza la excepción IndexOutOfBoundsException


c4.5 - Sea la lista números formada por los elementos [4, 9, 15, 7, 3]. ¿Cuál será el resultado del siguiente código? 
for (int i = 0; i < numeros.size(); i++) {     
   numeros.set (i, numeros.get(i) + 1);    
}  
System.out.println (numeros);

5, 10, 16, 8, 4 y se lanza la excepción IndexOutOfBoundsException

4, 9, 15, 7, 3

5, 10, 16, 8, 4

5, 10, 16, 8 y se lanza la excepción IndexOutOfBoundsException

Se lanza la excepción IndexOutOfBoundsException


c4.6 - Complete la siguiente sentencia para declarar un conjunto de cadenas de caracteres (Sólo deje los blancos estrictamente necesarios) 
 diccionario = ;


c4.7 - Observe el siguiente diagrama. Indique el método de la interfaz Set que se debe aplicar para obtener cada uno de los siguientes resultados:
 

{1, 2, 3}

{5, 6}

4

false

{1, 2, 3, 4, 5, 6}

{4, 5}

true

{4}

{}


c4.8 - Si en conjunto c1 tenemos los alumnos que aprobaron una asignatura en el curso 2009/10 y en el c2 los que la aprobaron en el curso 2010/11, ¿cómo obtendríamos los alumnos del curso 2010/11 que no son repetidores?

c2.containsAll(c1);

c2.removeAll(c1);

c1.removeAll(c2);

c2.retainAll(c1);

c1.retainAll(c2);


c4.9 - Indique la salida en pantalla del siguiente código: 
SortedSet<Character> ss = new TreeSet<Character>();  
ss.add('X'); ss.add('C'); ss.add('F');
   ss.add('P'); ss.add('R'); ss.add('Q');  
for (Character ch : ss) {   
  System.out.print(ch);  
}

El orden de los caracteres varía cada vez que se ejecuta el bucle for

El orden depende del método hashCode()

X Q R P F C

X C F P R Q

C F P Q R X


t3.2 - Complete el código siguiente para comparar dos objetos de tipo Persona según su edad, utilizando para ello un objeto de la clase ComparadorPersonaEdad, que implementa la interfaz Comparator.No deje más espacios en blanco que los estrictamente necesarios
  Persona p1 = new PersonaImpl(........);  
  Persona p2 = new PersonaImpl(........);  
  <> cmp = ;  
  if(){ 
        mostrar(p1 + " y " +  p2 + " tienen la misma edad");
  }


t3.6 - Complete la clase ComparadorPersonaEdad para definir un SortedSet para el tipo Persona basado en la edad de la persona. No deje más espacios en blanco que los estrictamente necesarios.
public class   {     
    public  ( p1,  p2) {
        int res;           
         = ;        
        if (){           
             res = ;
        } 
        return res;    
    }  
}


t3.8 - Complete el siguiente código que ordena un array de personas según su orden natural y según su edad (utilizando la clase ComparadorPersonaEdad). No deje más espacios en blanco que los estrictamente necesarios.
Persona\[] v = {p1, p2, p3, p4};  
;  
System.out.println("Array ordenado según el orden natural: ");  
System.out.println(v);  
;  
System.out.println("Array ordenado según el orden alternativo de edad: ");  
System.out.println(v);


t4.12 - Dado el siguiente codigo: 
    List<String> ls1 = new LinkedList<String>();     
    ls1.add("A");ls1.add("B");ls1.add("B");ls1.add("E");ls1.add("E");     
    List<String> ls2 = new LinkedList<String>();     
    ls2.add("C");ls2.add("C");ls2.add("E");ls2.add("E");ls2.add("A");   
  
     .................................   
  
    System.out.println(ls1);
Relacione la sentencia que debería ir en la línea de puntos con el resultado que saldría en la consola

ls1.add(3,"H");

ls1.remove(2);

ls1=ls1.subList(2,4);

ls1.addAll(ls2);

ls1.set(3,"H");

ls1.retainAll(ls2);

ls1.removeAll(ls2);


t4.13 - Dado el siguiente codigo: 
    SortedSet<Character> ls1 = new TreeSet<Character>();     
    ls1.add('A');ls1.add('B');ls1.add('B');ls1.add('E');ls1.add('E');     
    SortedSet<Character> ls2 = new TreeSet<Character>();     
    ls2.add('C');ls2.add('C');ls2.add('E');ls2.add('E');ls2.add('A');   
    .................................   
    System.out.println(ls1);
Relacione la sentencia que debería ir en la línea de puntos con el resultado que saldría en la consola

ls1.retainAll(ls2);

ls1.removeAll(ls2);

ls1=ls2.subSet('B','D');

ls1.remove('A');

ls1=ls2.tailSet('C');

ls1.addAll(ls2);

ls1=ls2.headSet('C');


C4.1 -  Complete el grafo de interfaces de la figura.

3

1

4

5

2

Iterable


Collection


List


Set


SortedSet



C4.2 - Sea la números un List<Integer> formado por los elementos {7, 6, 5, 1, 7}, y sea la siguiente secuencia de operaciones: 
numeros.remove (3);  
numeros.add (2, 1);  
List<Integer> numeros2 = numeros.subList (2, 4);  
numeros2.add (1, 3); 
System.out.println(numeros);
Indique el resultado en pantalla. Separe los números por comas sin blancos.
Por ejemplo: 7,6,1,7

 


exc-1 - Tenemos el siguiente esquema de código Java
// bloque 1
try{
     //bloque 2
}
catch (ArithmeticException e){
     // bloque 3
}
catch (NullPointerException e){
     // bloque 4
}
finally{     
     //bloque 5
}
//bloque 6

Entonces si se produce una excepcion en el bloque 2 de tipo ArithmeticException se ejecutan los bloques siguientes:

1 -> 3 -> 5 -> 6

1 -> 2 -> 3 -> 6

 1 -> 2 -> 3 -> 5 -> 6

1 -> 2 -> 3 -> 4 -> 5 -> 6

1 -> 2 -> 3 -> 4 -> 6


exc-2 - Tenemos el siguiente esquema de código Java
// bloque 1
try{
     //bloque 2
}
catch (ArithmeticException e){
     // bloque 3
}
catch (NullPointerException e){
     // bloque 4
}
finally{     
     //bloque 5
}
//bloque 6

Entonces si se produce una excepcion en el bloque 2 de tipo NullPointerException se ejecutan los bloques siguientes:

1 -> 2 -> 3 -> 4 -> 6

1 -> 2 -> 5 -> 6

 1 -> 2 -> 4 -> 5 -> 6

1 -> 2 -> 3 -> 4 -> 5 -> 6

1 -> 2 -> 4 -> 6


Puntuacion Total

Aciertos

Aciertos Parciales

No hay comentarios:

Publicar un comentario

Suscribirse a: Entradas (Atom)