Capítulo 14 [Colección, genérico]

Día 02 [Colección, genérico]

contenido principal

• Colecciones
• iterador
• mejoras para
• Los genéricos

metas de enseñanza

• [] Se puede configurar para establecer la diferencia entre una gran variedad de
• [] Uso frecuente hablar colección de funciones Colección
• [] Puede ser utilizado para iterar sobre una colección de elementos que tienen
• [] Puede ser utilizado para contar los detalles indicados
• [] Se puede ajustar mediante el tipo de almacén personalizado
• [] Puede ser utilizado para bucle a través del foreach colección
• [] Se puede definir mediante un conjunto genérico de objetos
• [] Puede apreciarse que los genéricos superior e inferior
• [] Efecto descrito puede ser comodín genérico

conjunto

1. Colecciones marco del aprendizaje

1. aprendizaje superior: el aprendizaje de la parte superior del método de la clase / interfaz abstracta de la CPC, todas las subclases se puede utilizar.
2. Utilice la parte inferior: el fondo no es una interfaz es una clase abstracta, no se puede crear objetos directamente. Necesidad de utilizar los objetos subyacentes utilizando subclases

2. Aprender el objetivo de recogida

1. Será utilizado para almacenar la recopilación de datos
2. Atravesará la colección, los datos sacados
3. Agarre las características de cada colección

Herencia: extraer subclase común, la forma de la clase padre (interfaz)

Capítulo Colección Una colección

1.1 Descripción general de las colecciones

• Conjunto : un recipiente de recogida dispuesto en Java, que puede ser utilizado para almacenar una pluralidad de datos.

Colecciones y matrices son contenedores, la diferencia

• longitud fija de la matriz.
• Una matriz de elementos de memoria del mismo tipo, se puede almacenar el valor de los tipos de datos básicos.
• La longitud colección es variable.
• Colección de objetos se almacenan. Y el objeto puede ser inconsistente. En el desarrollo de múltiples objetos en general se siguen, utilizando conjunto de almacenamiento.

marco 1.2 colecciones

JavaSE proporciona para satisfacer las necesidades de la API, antes de utilizar estas API, para entender su herencia y funcionamiento de la interfaz sola lata; saber cuándo hay que adoptar el cual la clase, y la manera de cooperar entre sí entre las clases, a fin de lograr la flexibilidad.

Estructura de memoria según la cual una colección se puede dividir en dos categorías, a saber, un conjunto de simples java.util.Collectionconjuntos y dualjava。util.Map

Herencia: extraer subclase común, la forma de la clase padre (interfaz)

Interfaz Collection

• Se define por toda Partido Comunista de los métodos de recogida selectiva de residuos
• Todo único conjunto de métodos comunes se puede utilizar
• Ningún método de indexado

interfaces de la colección incluyen

Interfaz 1.List

1. conjunto ordenado (el mismo extracción y elemento de almacenamiento de orden)
2. Permite el almacenamiento de elementos duplicados
3. Un índice, se puede utilizar un ordinario bucle for itera

interfaces de lista de inclusión

• colección del vector
• colección ArrayList
• colección LinkedList

Interfaz 2.Set

colecciones no ordenadas:

Extracción y almacenamiento orden de los elementos puede ser inconsistente

1. No permitir que los elementos duplicados
2. No existe un índice (no se puede utilizar ordinaria bucle for itera)

El juego incluye la interfaz

• colección TreeSet
• colección HashSet
  • colección LinkedHashSet (heredado de colección HashSet)

1.3 Funciones Colección de uso común

Collecntion recogida selectiva es el padre de todas las interfaces, definiendo así un único conjunto común de métodos (y Lista Set) en Collecntion, estos métodos pueden ser usados ​​para operar toda la colección separada. He aquí cómo:

• public boolean add(E e): El objeto dado a la colección actual.
• public void clear（）: Vaciar la colección de todos los elementos.
• public boolean remove（E e）: Eliminar el objeto dado en la colección actual.
• public boolean contains(E e): Análisis de la colección actual contiene el objeto dado.
• public boolean isEmpty（）: Para determinar si la colección actual está vacía.
• public int size（）: Devuelve el número de elementos de un conjunto.
• public object[] toArray(): Los elementos de la colección, almacenados en la matriz.

Método de presentación:

import java.util.ArrayList;
import java.util.Collection;

public class Demo01Collection{
    public static void main(String[] args){
        // 创建集合对象
        // 使用多态形式
        Collection<String> coll = new ArrayList<String>();
        // 使用方法
        // 添加功能 boolean add(String s)
        coll.add("雷神");
        coll.add("火舞");
        coll.add("蜘蛛侠");
        System.out.println(coll);
        
        // boolean contains(E e) 判断是否在集合中存在
        System.out.println("判断 雷神是否存在集合中"+coll.contains("雷神"));
        
        // boolean remove(E e) 删除在集合中的元素
        System.out.println("删除蜘蛛侠："+coll.remove("蜘蛛侠"));
        System.out.println("删除之后集合中的元素："+coll);
        
        // size() 集合中有几个元素
        System.out.println("集合中有："+coll.size()+"个元素");
        
        // object[] toArray()转换成一个object数组
        object[] objects = coll.toArray();
        // 遍历数组
        for(int i = 0;i < objects.length;i++){
          System.out.println(objects[i]);  
        }
        // void clear() 清空集合
        coll.clear();
        System.out.println("集合中内容为"+coll);
        // boolean isEmpty() 判断是否为空
        System.out.println(coll.isEmpty());
    }
}

consejos: Colección de métodos relacionados con la disposición de éstos, otros métodos pueden ver la API para aprender por su cuenta.

Capítulo II atravesará el modo de ajuste

iterador iterador

2.1 Interfaz Iterator

Iterator interfaz para atravesar la matriz

El desarrollo del programa, a menudo tienen que atravesar todos los elementos de la colección. Para la demanda, JDK proporciona una interfaz dedicada a java.util.Iteratorla interfaz es la combinación de Java de una .Iterator.

Colección interfaz del mapa interfaz con el elemento de almacenamiento se utiliza principalmente, y se utiliza principalmente para iterar Iterator (es decir, transversal) Colección del elemento, y por lo tanto también se refiere Iterator objeto iterador

java.util.Iterator Interfaz: iteradores (traverse de la interfaz)

Hay dos métodos comunes

boolean hasNext () si iteración tiene más elementos son verdaderas

Se determina que no hay un siguiente conjunto de elementos, con un retorno a la verdadera, no devuelve falso

E siguiente () Devuelve el siguiente elemento de la iteración

-> Obtiene la siguiente elemento de la colección.

Iterador iterador es una interfaz que no se pueden utilizar directamente, tenemos que darnos cuenta de la interfaz iterador objeto de clase, clase de implementación para obtener de manera especial.

interfaz Collection tiene un método llamado iterador (), que devuelve un iterador se logra objeto de clase

iterador iterador () Devuelve una colección de los elementos de esta colección será iterador

Uso etapa (énfasis)

1. Usar iterador set () Obtiene iterador objeto de clase implementa utilizando Iterator receptor del interfaz (polimorfismo).

   nota:

   iterador También hay interfaces genéricas, conjunto genérico y consistente de iterador.

2. Uso hasNext iterador elemento de la interfaz se determina que no hay próxima

3. Iterator utilizando el método de interfaz siguiente obtiene el siguiente elemento en el conjunto

public class Demo02Iterator {
    public static void main(String[] args) {
        // 创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        // 往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("詹姆斯");
        coll.add("麦迪");
        coll.add("艾弗森");
        /*
        * 使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）。
        注意：
            Iterator<E> 接口中也是有泛型的，迭代器的泛型和集合的一致。
        * */
        // 多态   接口          实现类对象
        Iterator<String> it = coll.iterator();

        // 或者使用循环
        // while循环
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-------------");
        // for 循环
        for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) {
            String e = it2.next();
            System.out.println(e);
        }
       /* // 2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
        boolean b = it.hasNext();
        System.out.println(b);

        // 3. 使用Iterator接口中的方法next取出集合中的下一个元素
        String s = it.next();
        System.out.println(s);

        s = it.next();
        System.out.println(s);
        s = it.next();
        System.out.println(s);
        s = it.next();
        System.out.println(s);
        s = it.next();
        System.out.println(s);
        b = it.hasNext();
        System.out.println(b);
    */
    }
}

El principio 2,2 iterador

En el caso que hemos completado todo el proceso de iterador para recorrer la colección. Cuando se atraviesa una colección, obtenido primero llamando conjunto t iterador () método objeto iterador, y luego usar hashNext () método determina si hay un elemento siguiente en el conjunto, si está presente, se invoca siguiente método () del elemento de retirada, se describa otra cosa ha alcanzado el final de la colección, de parada a través de los elementos.

Iterador iterador objeto en el bucle a través de la colección, la forma del puntero interno para realizar un seguimiento de los elementos de la colección, con el fin de permitir a los principiantes a entender mejor cómo el iterador, seguido de demostración Iterator elementos de objeto de una leyenda:

Iterador antes de llamar al siguiente método, el índice del iterador, antes de que el primer elemento, no apunta a ningún elemento, cuando la primera llamada al siguiente método iterador, el índice del iterador se moverá hacia atrás una, que apunta a la primera elementos y devuelve dicho elemento, cuando la llamada al método siguiente de nuevo, el índice del iterador apuntará al segundo elemento y el elemento de devoluciones, y así sucesivamente, hasta que devuelve el método hasNext falso, lo que indica que llegaron al final de la colección, la terminación de atravesando elementos.

2.3 mejoras para

Ciclo mejorado: se utiliza iterador parte inferior, el formato utilizado para el bucle simplifica la escritura iterador

Es una nueva característica que aparece después de JDK1.5
Colección se extiende Iterable : Todas sola colección puede utilizar el bucle for mejorado
pública interfaz Iterable Implementar esta interfaz permite que un objeto se convierta en un comunicado "foreach" de los objetivos

Mejorada para bucle: conjunto y se utiliza para atravesar la matriz

formato

Para (tipo de conjunto de nombre de datos variables / matriz: el nombre de la matriz / nombre de conjunto) {
// código de operación
}

Se utiliza para atravesar la Colección y matrices. Por lo general, llevan a cabo sólo a través de los elementos, adiciones y supresiones no operan en un conjunto de elementos en el proceso de recorrido.

Ejercicio 1: Iterar

public static void main(String[] args) {
	int[] arr = {1,2,3,5,6,9};
    // 使用增强for遍历数组
    for(int i:arr){
        // i 代表数组中的每个元素
        System.out.println(i);
    }
}

Ejercicio 2: paseo por la colección

public static void main(String[] args) {
    	Collection<String> coll = new ArrayList<String>();
    coll.add("神婆");
    coll.add("巫女");
    coll.add("神算子");
    // 使用增强for遍历
    for(String str:coll){
        // 接收变量str代表被便利的集合元素
        System.out.println(str);
    }
}

consejos: nuevos para el bucle deben tener una meta a ser atravesada. Colección única meta o una matriz. Al igual que ocurre para la nueva operación de recorrido.

Capítulo III Genérico

Después JDK5, agregados genéricos ( el genérico ) sintaxis, por lo que puede especificar el diseño del soporte de la API clase genérica o método, por lo que utilizar la API, también se vuelve más compacta, y ha sido la comprobación de sintaxis en tiempo de compilación .

** Los genéricos: ** puede ser visto como un tipo de datos desconocido, no sé qué tipo de datos que pueden utilizar los genéricos

Genérico puede ser visto como una variable, el tipo de datos para recibir

E e: Elemento Elemento

T t: Tipo Tipo

3.1 Descripción general Genéricos

Un conjunto de objetos arbitrarios puede ser almacenado, siempre que el conjunto de objetos almacenados, son promovidos a continuación, el tipo de objeto.

Código es el siguiente

/**
    创建集合对象，不使用泛型
     好处：
        集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
     弊端：
        不安全，会引发异常
    */
public static void main(String[] args){
    Collection coll = new ArrayList();
   	// 集合没有限制   可以存放任意类型
    coll.add("abc");
    coll.add("itcast");
    coll.add(1);
    
    // 使用迭代器  Iterator迭代器，是一个接口，无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊。
    Iterator it = coll.iterator();
    while(it.hasNext()){
        // 获取元素
        Object next = it.next();
        System.out.println(next);
        
        // 想要使用string类特有的方法，length获取字符串的长度；不能使用  多态 object obj = "abc"
        // 就需要把迭代出来的对象转成String类型
        String str = (String) it.next();
        System.out.println(it.length());
        
    }
    
}

Se produce una excepción cuando el programa se está ejecutando

java.lang.ClassCastException .

Las excepciones de conversión de tipo racional ocurren:

Dado que la colección de lo que se pueden almacenar tipos de elementos. ClassCastException su vez conduce a una fuerte tiempo de ejecución cuando la eliminación de iniciador.

Colecciones Aunque puede almacenar una gran variedad de objetos, pero en realidad única tienda de objetos del mismo tipo.

Por lo tanto, después de JDK5, agregó genéricos ( el genérico ) sintaxis, por lo que puede especificar el diseño del soporte de la API clase genérica o método, por lo que utilizar la API, también se vuelven más compacto, y ha sido el tiempo de compilación de sintaxis la inspección.

• Genérico : Tipo desconocido puede ser utilizado antes de una clase o método.

consejos: Cuando se crea un objeto en general, va a determinar el tipo específico de tipo desconocido. Cuando no hay genéricos se especifica, el tipo por defecto es el tipo de objeto.

3.2 Beneficios del uso de los genéricos

Crear una colección, utilice los genéricos
beneficios:
1. Evitar tipo de problemas para la conversión, almacenamiento de tipo fijo
2. excepción de ejecución (una vez ejecutado el código produce una excepción), elevado al compilador (escribir el código se quejará)
inconvenientes:
genérica de qué tipo, sólo puede ahorrar qué tipo

public static void main(String[] args){
    Collection<String> list = new ArrayList<>();
    list.add("abc");
    list.add("iteraton");
    // list.add(6);  当集合存储类型确定后，存放的类型不一致就会报错
    Iterator<String> it = list.iterator();
    while(it.hasNaxt){
        String str = it.next();
        //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
        System.out.println(str.length());
        
    }
}

consejos: Los genéricos son parte del tipo de datos, seremos vistos como el nombre de la clase y tipos de datos genéricos se funden.

3.3 con el uso de definiciones genéricas

Genérico para datos flexible aplicado a diferentes tipos de clases, métodos, interfaces. El tipo de datos se pasa como un parámetro

1. Definiciones y contiene clase genérica

Formato Definición:

修饰符 class 类名<代表泛型的变量> {  }

Por ejemplo, ArrayList API en el conjunto:

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

Usando genéricos: la identificación de genérico cuando.

Generic determinar cuando la creación de objetos

Por ejemplo,ArrayList<String> list = new ArrayList<String>();

En este caso, el valor de la variable E es de tipo String, entonces nuestro tipo puede entenderse como:

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

Como otro ejemplo,ArrayList<Integer> list = new ArrayList<Integer>();

En este caso, el valor de la variable E es de tipo entero, entonces se puede entender como un tipo:

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

Ejemplos de clases personalizadas genérica

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

uso:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

2. Definir una que comprende genérico método

El método definido que contiene genérico: definición genérica de la correspondencia entre el tipo de retorno método modificado

Formato Definición:

修饰符 <泛型> 返回值类性 方法名（参数列表（使用泛型））{
        方法体；
 }

Contiene un método genérico, cuando se invoca el método para determinar los tipos de datos genéricos
qué tipo de paso de parámetros, lo que es el tipo genérico

La definición de una clase genérica

public class GenericMethod{
    public <M> void method1(M m){
        System.out.println(m);
    }
    // 静态方法
    public static <S> void method2(S s){
        System.out.println(s);
    }
}

Definir la clase de prueba:

public static void main(String[] args){
    // 创建GenericMethod对象
    GenericMethod gm = new GenericMethod();
    /*
    调用含有泛型的方法method01
    传递什么类型，泛型就是什么类型
    */
    gm.method01("acb");
    gm.method01(1);
    
    // 静态方法不建议创建对象
    // 直接通过类名.方法名调用
    Generic.method02("静态方法");
    Generic.method02(123);
}

3. comprendiendo el interfaz genérica

Formato Definición:

修饰符 interface 接口名<代表泛型的变量>{
    
}

Utilizando el formato:

1. tipo genérico siempre incierto hasta que se cree un objeto, es determinado tipo genérico

por ejemplo

interfaz genéricos definidos que contiene

public interface GenericInterface<I>{
    public abstract void method(I i):
}

clase de implementación de interfaz

/**
 * 含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
 * public interface Interctor<E>{
 *     E next();
 * }
 * Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法默认的就是String
 * public final class Scanner implements Iterator<String>{
 *     public String next(){}
 * }</>
 * */
public class GenericInterfaceImpl1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

Categoría de prueba

public class Demo04GenericInterface {
    public static void main(String[] args) {
        GenericInterfaceImpl1 impl1 = new GenericInterfaceImpl1();
        impl1.method("abc");
        impl1.method("字符串");
    }
}

2. determinar el tipo genérico definido en la clase

interfaz genéricos definidos que contiene

public interface GenericInterface<I>{
    public abstract void method(I i):
}

clase de implementación de interfaz

public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

Categoría de prueba

public class Demo04GenericInterface {
    public static void main(String[] args) {
        GenericInterfaceImpl1<String> impl1 = new GenericInterfaceImpl1();
        impl1.method("abc");
        impl1.method("字符串");
    }

3.4 genéricos comodines

Cuando una clase genérica o interfaz, transferencia de datos, el tipo genérico de la incertidumbre, por comodín <?> Fig. Pero una vez que el uso de genéricos comodines, utilice la clase de objeto método sólo es común, los elementos en el método de colección en sí no se puede utilizar.

1. utilizar comodines básicos

Genéricos comodines: No sé qué tipo de recepción, entonces usted puede utilizar, lo que indica un comodín desconocido ??.

En este caso sólo recibe los datos, los datos no se puede almacenar en el conjunto.

Código de ejemplo:

public static void main(String[] args){
    ArrayList<String> list1 = new ArrayList<>();
    list1.add("a");
    list1.add("b");
    
    // 使用多态写法
    Collection<Integer> list2 = new ArrayList<>();
    list2.add(1);
    list2.add(2);
    
    method(list1);
    method(list2);
}
/*
定义一个方法，能遍历所有类型的ArrayList集合
因为不确定ArrayList集合的数据类型，所以使用泛型的通配符？来接收数据类型
注意：
	泛型没有继承的概念的
*/
public static void method(Collection<?> list){
    // 使用迭代器遍历集合
    Iterator<?> it = list.iterator();
    while(it.hasNext()){
        // it.next()方法，取出的元素是object，可以接受任意的数据类型
        Object o = it.next();
        System.out.println(o);
    }
}

consejos: la herencia Colección Genérico no existe