T8 Java

T-8

 

 

 

---

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

	El método add(obj) para el tipo Set añade obj al conjunto si no hay ningún elemento previo con el mismo hashCode
	El método add(obj) para el tipo SortedSet por orden natural añade obj al conjunto si no hay ningún elemento previo tal que compareTo devuelva 0
	LinkedList es una clase que implementa List de forma eficiente para insertar elementos al final
	Si dos objetos tienen el mismo hashCode no pueden estar simultáneamente en un Set
	LinkedList es una clase que implementa List de forma eficiente para acceso mediante índice

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

	El índice de los métodos de List debe estar entre 0 y size ambos inclusive
	El método add(obj) para el tipo SortedSet por orden natural añade obj al conjunto si hay algún elemento previo tal que compareTo devuelva 0
	El tipo Set añade métodos nuevos a la interfaz Collection, como por ejemplo tailSet
	SubSet es un tipo que hereda de Iterable
	Un recorrido con un for sobre un Set siempre da el mismo resultado aunque no se puede prever el orden del recorrido

C4.2-13 - Tenemos definido un conjunto ordenado sc de tipo Character y se han insertado los elementos X, C, R, Q, M y H por ese orden. Si la consola nos muestra en pantalla [C, H] Entonces cuales de las siguientes sentencias se ha ejecutado:

	System.out.println(sc.headSet(‘M’));
	System.out.println(sc.headset(‘I’));
	System.out.println(sc.headSet(‘H’));
	System.out.println(sc.subset(‘B’,’J));
	System.out.println(sc.headSet('J'));

C4.2-14 - Tenemos definido un conjunto ordenado sc de tipo Character y se han insertado los elementos X, C, R, Q, M y H por ese orden. Si la consola nos muestra en pantalla [Q, R, X] Entonces cuales de las siguientes sentencias se ha ejecutado:

	System.out.println(sc.tailSet(‘M’));
	System.out.println(sc.subSet(‘N’,’Z’));
	System.out.println(sc.tailSet('N'));
	System.out.println(sc.subSet(‘Q’,’X’));
	System.out.println(sc.tailSet(‘Q’));

C4.2-17 - Si se ejecuta el siguiente código

  Set nube = new HashSet(); 
     Punto p4 = new PuntoImpl(1.,0.); 
     Punto p1 = new PuntoImpl(2.,0.); 
     Punto p2 = new PuntoImpl(3.,0.); 
     Punto p3 = new PuntoImpl(3.,0.);     
     nube.add(p4);nube.add(p1);nube.add(p2);nube.add(p3); 
     for(Punto q:nube){    
         q.setX(7.0); 
     } 
     System.out.println(nube.size()); 
     System.out.println(p4);  

Entonces cuáles de las siguientes afirmaciones son ciertas:

	El programa muestra en la consola un 3
	El programa muestra en la consola un 1
	El programa muestra en la consola (7.0, 0.0)
	El programa muestra en la consola (1.0, 0.0)
	Al final del programa p1 y p2 son idénticos

C4.2-18 - Si se ejecuta el siguiente código, ¿cuáles de las afirmaciones que están a continuación son ciertas?

	En la consola se muestra nube2 [(2.0,0.0)]
	En la consola se muestra nube2 [(4.0,0.0)]
	En la consola se muestra nube [(1.0,0.0), (3.0,0.0)]
	En la consola se muestra nube2 []
	En la consola se muestra nube [(4.0,0.0), (4.0,0.0)]

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

	El método remove de Collection devuelve true si el elemento a borrar no está
	El método add de Set devuelve falso si el elemento es añadido, es decir, si no estaba
	Collection es una interfaz que no es implementada por ninguna clase
	La clase HashSet comprueba si dos objetos son iguales mediante el método hahsCode
	Las dos interfaces hija que heredan de Collection son List y Set

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

	En el tipo List no puede haber elementos repetidos
	Las dos clases que implementan la interfaz List son ArrayList y LinkedList
	En el tipo Set los elementos pueden ser referenciados por un índice
	En el tipo Set los elementos tienen un orden definido
	ArrayList es una clase que implementa List de forma eficiente para búsquedas

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

	LinkedList es una clase que implementa List de forma eficiente para insertar elementos al principio
	Las dos clases que implementan la interfaz Set son HashSet y TreeSet
	En un Set se comprueba si dos objetos son iguales mediante el método equals
	ArrayList es una clase que implementa List de forma eficiente para insertar elementos al final
	ArrayList es una clase que implementa List de forma eficiente para acceso mediante índice

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

	El método subSet(f,p) de SortedSet devuelve un subconjunto entre los valores f y p, incluidos f y p
	LinkedList es una clase que implementa List de forma eficiente para búsquedas
	LinkedList es una clase que implementa List de forma eficiente para borrar elementos
	En el tipo SortedSet hay elementos repetidos siempre que definamos un orden externo
	LinkedList es una clase que implementa List de forma eficiente para insertar elementos en medio

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

	Los métodos de List que no se heredan de Collection son los relativos a uso de índice
	El índice de los métodos de List debe estar entre 0 y size-1 ambos inclusive
	La interface Collection hereda de List
	El método add de Set devuelve falso si el elemento no es añadido, es decir, si ya estaba
	Collection es una interfaz que es implementada por la clase ArrayList

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

	El método remove de Collection devuelve falso si el elemento a borrar no está
	El método frecuency de Collections es un sumatorio
	TreeSet es la clase que implementa SortedSet
	SubSet es un tipo que no hereda de Iterable
	Un recorrido con un for sobre un Set siempre no da el mismo resultado

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

	Un SortedSet definido mediante un orden alternativo comprueba si dos objetos son iguales mediante el método compare
	Si el método compare sobre dos objetos devuelve 0 no pueden estar simultáneamente en un Set
	El método add(obj) para el tipo Set añade obj al conjunto si hay algún elemento previo con el mismo hashCode
	En el tipo Set los elementos no tienen un orden definido
	Un SortedSet ordenado por orden natural comprueba si dos objetos son iguales mediante el método compareTo

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

	En el tipo List los elementos pueden ser referenciados por un índice
	Un SortedSet definido mediante un orden alternativo comprueba si dos objetos son iguales mediante el método compareTo
	HashSet es la clase que implementa SortedSet
	Un SortedSet ordenado por orden natural comprueba si dos objetos son iguales mediante el método compare
	En el tipo List puede haber elementos repetidos

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

	El tipo Set no añade métodos nuevos a la interfaz Collection
	El método subSet(f,p) de SortedSet devuelve un subconjunto entre los valores f y p, incluido f y excluido p
	El método add(obj) para el tipo SortedSet por orden alternativo añade obj al conjunto si hay algún elemento previo tal que compare devuelva 0
	ArrayList es una clase que implementa List de forma eficiente para insertar elementos al principio
	En el tipo SortedSet no hay elementos repetidos pero sí están en orden

t4.9 - Tenemos dos listas de String l1 y l2 vacías y realizamos las siguientes operaciones

     List<String> ls = new LinkedList<String> (); 
     ls.add("A");  ls.add("B");  ls.add("C");
     ls.add("D");  ls.add("E"); 
     List<String> subLs = ls.subList(1, 4); 
     subLs.remove(1);   

entonces el contenido de ls es (exprese una lista como un conjunto de caracteres separados por comas sin blancos, por ejemplo: A,B,C,D

     ls= 

t4.8 - Tenemos dos listas de String l1 y l2 vacías y realizamos las siguientes operaciones

  List<String> ls = new LinkedList<String>();  
  ls.add("A");  ls.add("B");  ls.add("C");
   ls.add("D");  ls.add("E");  
  List<String> subLs = ls.subList(1, 4);  
  ls.set(2, "F");    

entonces el contenido de subLs es (exprese una lista como un conjunto de caracteres separados por comas sin blancos, por ejemplo: A,B,C,D

    subLs=

t4.7 - Tenemos dos listas de String l1 y l2 vacías y realizamos las siguientes operaciones

  List<String> ls = new LinkedList<String>();  
  ls.add("A");  ls.add("B");  ls.add("C");  
  ls.add("D");  ls.add("E");  
  List<String> subLs = ls.subList(1, 4);    

entonces el contenido de subLs es (exprese una lista como un conjunto de caracteres separados por comas sin blancos, por ejemplo: A,B,C,D

    subLs=

t4.6 - Tenemos dos listas de String l1 y l2 vacías y realizamos las siguientes operaciones

  l1.add("A");  l1.add("B");  l1.add("C");
  l2.add("B");  l2.add("B");  l2.retainAll(l1);  

entonces el contenido de l2 es (exprese una lista como un conjunto de caracteres separados por comas sin blancos, por ejemplo: A,B,C,D

    l2=	

t4.5 - Tenemos dos listas de String l1 y l2 vacías y realizamos las siguientes operaciones

  l1.add("A");  l1.add("B");  l1.add("C");
  l1.add("B");  l2.add("B");  l1.removeAll(l2);  

entonces el contenido de l1 es (exprese una lista como un conjunto de caracteres separados por comas sin blancos, por ejemplo: A,B,C,D

    l1=

t4.4 - Relaciona los métodos de Collection con las operaciones habituales de conjuntos en matemáticas

- addAll retainAll containsAll contains size removeAll Cardinal - addAll retainAll containsAll contains size removeAll Inclusión - addAll retainAll containsAll contains size removeAll Diferencia - addAll retainAll containsAll contains size removeAll Unión - addAll retainAll containsAll contains size removeAll Intersección - addAll retainAll containsAll contains size removeAll Pertenece

addAll retainAll containsAll contains size removeAll

t4.2 - Se desea crear un comparador alternativo para el tipo Punto de forma que un Punto es menor que otro si su distancia al origen es menor. Entonces el código es (no deje espacios en blanco):

  public class ComparadorPuntoDistanciaOrigen  {         
       public int compare( p1,  p2){       
               Punto origen = new (0.,0.);       
               Double d1 = ;       
               Double d2 = ;        
               ;       
       }  
  }

t4.1 - Queremos construir un orden alternativo para String que ordene dos cadenas de caracteres por su tamaño de menor a mayor. Entonces el código es (no deje espacios en blanco):

public class ComparatorStringLongitud implements Comparator<String> {       
       public int compare( s1,  s2){   
             int r=0;   
               if()  {      
               r=-1; 
               }  
               else if (){       
                           r=1;   
                    }
                 return r; 
          }  
  }

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 ls2 = new TreeSet(); 

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

- [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1=ls2.headSet('C'); - [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1.removeAll(ls2); - [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1.addAll(ls2); - [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1.retainAll(ls2); - [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1=ls2.subSet('B','D'); - [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1=ls2.tailSet('C'); - [A, B, C, E] [A] [B, E] [B] [A, E] [C] [C, E] ls1.remove('A');

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

- [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1.remove(2); - [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1.retainAll(ls2); - [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1.removeAll(ls2); - [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1.add(3,"H"); - [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1=ls1.subList(2,4); - [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1.set(3,"H"); - [A, B, B, E, E, C, C, E, E, A] [A, B, B, H, E, E] [A, B, E, E] [B, B] [A, E, E] [B, E] [A, B, B, H, E] ls1.addAll(ls2);

t4.11 - Tenemos dos listas de Character con el siguiente contenido:

 ls1 = [A, B, C, D, E]  

 ls2 = [B, C, E, F, H]     

Relacione las operaciones con el resultado de cómo quedaría ls1 después de ejecutarla

- ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1=ls1.subList(2,4); - ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1.addAll(ls2); - ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1.retainAll(ls2); - ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1.remove(2); - ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1.add(3,'H'); - ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1.set(3,'H'); - ls1=[A, B, C, D, E, B, C, E, F, H] ls1=[A, B, C, H, D, E] ls1=[A, B, D, E] ls1=[A, D] ls1=[B, C, E] ls1=[C, D] ls1=[A, B, C, H, E] ls1.removeAll(ls2);

t5.3 - Si en una clase se quiere definir un atributo privado PI común a todos los objetos se debería escribir:

    PI=3.14159;  

t5.2 - Ponga nombre a los modificadores de comportamiento:

Todas las instancias de la clase comparten el mismo valor para el atributo:
No se permite cambiar el valor inicial del atributo:

t5.1 - Ponga nombre a los modificadores de acceso:

El atributo es accesible desde cualquier punto del programa en el que se disponga de un objeto de la clase:

El atributo es accesible sólo desde los métodos de la propia clase:

El atributo es accesible desde los métodos de las clases que hereden de la propia:

t4-10 - Se desea crear un SortedSet para el tipo Persona ordenado por edad de menor a mayor y que pueda haber dos personas distintas con la misma edad. Entonces el Comparator debe ser (no deje espacios en blanco):

public class ComparatorPersonaEdad implements Comparator<Persona> {
      public int compare(Persona p1, Persona p2){  
                int r;  
                r =  ;   
                if (r==0){    
                     ; 
                } 
                return r; 
     }
}

---

Puntuacion Total
Aciertos
Aciertos Parciales