Los genéricos
concepto:
- Public class LinkedList
- se extiende AbstractSequentialList
- Lista de los implementos, deque, Cloneable, java.io.Serializable {}
- interfaz pública deque se extiende cola {}
- interfaz pública de cola se extiende colección {}
- Colección interfaz pública se extiende Iterable {}
Parece que estamos en el código anterior <?> Es lo que es, se llama genéricos, y una colección de objetos utilizados para ser utilizado en conjunto, por lo que nuestra Antes de iniciar una colección, primero hay que entender lo que es genérico. Y el concepto genérico es muy importante, se trata de un programa de mejora, que es actualmente el enfoque de desarrollo de la corriente principal.
Los genéricos son (genéricos) es una nueva característica de JDK1.5, de hecho, un medio "azúcar sintáctica" esencialmente un pequeño compilador con el fin de proporcionar una mejor legibilidad y consejos proporcionados, un nivel de máquina virtual es el concepto de los llamados "genérico" no existe.
papel:
- La sintaxis definida por el elemento de tipo de restricción genérico en la colección, los controles de seguridad, se muestra el error en tiempo de compilación
- Código es más versátil, hay casos detrás
- Los genéricos pueden mejorar la legibilidad del código de programa, pero es sólo un azúcar sintáctica (por ejemplo, una cosa fue compilado eliminado, no aparecen en el código fuente final) para el rendimiento de la ejecución de JVM es de ningún efecto.
Declaración genérica:
interfaz genérica puede ser, método, uso valor de retorno:
- java.util.List genérico interfaz / clase:
public interface Collection {}- Declaración método genérico:
public void impresión (E E)} {- En el primer caso devuelve el método un comunicado valor que indica la ocurrencia de volver E es un genérico, en lugar de las variables de Java ordinarias.
Nombre común:
- E - Elemento (utilizado en la colección, ya que la recogida se almacena en el elemento)
- T - Tipo (clase Java)
- K - Key (键)
- V - Valor (Value)
- N - Number (tipos numéricos)
- ? - indica el tipo de java incertidumbre
public class Test1 {
public static void main(String[] args) {
int[] a = new int[3];
a[0]=1;
a[1]=2;
//int类型的数组，规定了数组里的数据类型，类型不对就报错。
// a[2]="hello";
//1，泛型的标志<>
//2，泛型的好处：规定了数据的类型，不能想放什么数据就放什么类型，要遵守泛型规定的类型
//3，泛型的数据类型只能是引用类型，不能是基本类型
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
//4，如果类型不对，把运行时期才会 报的错ClassCastException直接在编译时期就报出来
// list.add("a");
// list.add('b');
Iterator it = list.iterator();
while(it.hasNext()) {
Integer s = (Integer) it.next();
System.out.println(s);
}
}
- Código es más versátil
- Por la sobrecarga de la manera convencional para lograr polimorfismo, un método del mismo nombre, los diferentes tipos de parámetros.
public class TestOldStyle {
public static void print(Integer[] dArray) {
for( Integer d : dArray) {
System.out.println(d);
}
}
public static void print( String[] sArray) {
for( String s : sArray) {
System.out.println(s);
}
}
public static void main(String[] args) {
Integer[] scores = new Integer[]{100,98,80};
String[] names = new String[]{"语文","数学","英语"};
TestOldStyle.print(scores);
TestOldStyle.print(names);
}
}
de forma genérica:
public class TestGenarics {
public static <E> void print(E[] arr) {
for(E e : arr) {
System.out.println(e);
}
}
public static void main(String[] args) {
Integer[] scores = new Integer[]{ 100,98,80 };
String[] names = new String[]{ "语文","数学","英语" };
Double[] moneys = new Double[] { 10.1,20.2,30.3 };
TestGenarics.print(scores);
TestGenarics.print(names);
TestGenarics.print(moneys);
}
}
Interfaz Collection
Descripción general:
- Inglés Nombre de la colección, se utiliza para almacenar la estructura de datos de objetos. En el que la longitud variable, y la colección se pueden almacenar en diferentes tipos de objetos. Y proporciona un método de funcionamiento de un conjunto de objetos en lotes.
- desventajas matriz: complicado longitud invariable es fijo, un único modo de acceso, de inserción, o operación de eliminación.
colección estructura de herencia
>Collection接口
>-- List接口 ： 数据有序，可以重复。
-- ArrayList子类
-- LinkedList子类
>-- Set接口 ： 数据无序，不可以存重复值
-- HashSet子类
>-- Map接口 ： 键值对存数据
-- HashMap
>-- Collections工具类
Los métodos más comunes:
- complemento booleano (E e): elemento aditivo.
- boolean addAll (Collection c): la adición de un conjunto de pequeñas para colección grande.
- boolean contains (Object o): si esta colección contiene el elemento especificado, devuelve cierto.
- booleano estaVacia (): Si no hay ningún elemento de esta colección, se devuelve cierto.
- Iterator iterador (): devuelve un iterador en los elementos de esta colección.
- remove boolean (Object o): eliminado de esta colección una sola instancia del elemento especificado.
- tamaño int (): devuelve el número de elementos de esta colección.
- Objec [] toArray (): Devuelve una matriz de objetos
interfaz de la lista:
Una colección ordenada (también conocida como secuencia). Esta interfaz de usuario puede ser controlada con precisión a la posición de inserción de cada elemento de la lista. Los usuarios pueden acceder a los elementos basados entero índice (posición en la lista), y la búsqueda de elementos en la lista.
Características:
1, los datos ordenados
2, permitiendo que elemento de almacenamiento de repetición
3, el elemento tiene un índice
Los métodos más comunes:
ListIterator listIterator ()
-
返回此列表元素的列表迭代器（按适当顺序）。
ListIterator listIterator (int index)
-
返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
void add (int index, elemento E)
-
在列表的指定位置插入指定元素（可选操作）。
booleano addAll (int index, Colección <? extiende E> c)
-
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
Lista subLista (int fromIndex, int toIndex)
-
返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
E get (int index)
-
返回列表中指定位置的元素。
int indexOf (Object o)
-
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
Lista de arreglo
Descripción general:
-
存在于java.util包中。 -
内部用数组存放数据，封装了数组的操作，每个对象都有下标。 -
内部数组默认初始容量是10。如果不够会以1.5倍容量增长。 -
查询快，增删数据效率会降低。
Crear un objeto:
- new ArrayList (): La capacidad inicial 10
Métodos de ensayo comunes:
public class Test3_AL {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("aaa");//存入数据
list.add("123");
list.add("ccc");
list.add("ddd");
System.out.println(list);//list中内容
System.out.println(list.size());//集合长度
System.out.println(list.get(1));//根据下标获取元素
System.out.println();
System.out.println(list.remove(2));//移除下标对应的元素
System.out.println(list);
//下标遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
//Iterator迭代遍历，封装了下标
Iterator<String> it = list.iterator();
while (it.hasNext()) {//如果有数据
String s = it.next();//一个一个向后遍历
System.out.println(s);
}
}
}
Lista enlazada
Los métodos más comunes:
- add () get ()
- Talla()
- remove (i)
- remove (datos)
- iterador ()
- addFirst () addLast ()
- GetFirst () getLast ()
- removeFirst () removeLast ()
Repite la prueba, lista doblemente enlazada: la eficiencia de desplazamiento estándar baja, alta eficiencia Repite
public class tt {
public static void main(String[] args) throws Exception {
LinkedList ll = new LinkedList ();
for (int i = 0; i < 100000; i++) {
ll.add(100);
}
f1(ll);
f2(ll);
}
private static void f2(LinkedList<Integer> ll) {
long t = System.currentTimeMillis();
Iterator it = ll.iterator();
while(it.hasNext()) {
it.next();
}
t = System.currentTimeMillis()-t;
System.out.println("=====iterator========="+t);//16
}
private static void f1(LinkedList<Integer> ll) {
long t = System.currentTimeMillis();
for (int i = 0; i < ll.size(); i++) {
ll.get(i);
}
long t1 = System.currentTimeMillis();
System.out.println("~~~~for~~~~~~~"+(t1-t));//9078
}
}
