conjunto detallado de Java-Lista

presentación de la colección lista

Lista Colecciones general

  Lista conjunto ordenado es un elemento (índice de cada elemento tiene una secuencia que corresponde al primer índice elemento es 0), y el conjunto de repetible.

Enumerar el conjunto de métodos comunes

  Lista es una colección de sub-interfaz de la interfaz Collection tiene todos los métodos, hay algunos métodos de operaciones de índice.

• void add(int index, E element);: El elemento del elemento insertado en el conjunto de índices de lista;
• boolean addAll(int index, Collection<? extends E> c);: El conjunto de todos los elementos de c se insertan en el principio del conjunto de índice de la lista;
• E remove(int index);: Elimina y devuelve el elemento en el índice;
• int indexOf(Object o);: Devuelve la posición de índice en el objeto de lista o la primera aparición de la colección;
• int lastIndexOf(Object o);: Devuelve el índice de la última posición de la junta objeto de la colección de lista que ocurre;
• E set(int index, E element);: El elemento en el índice índice y sustituido por un nuevo elemento del objeto, y 返回被替换的旧元素;
• E get(int index);: Devuelve el índice del conjunto de índices;
• List<E> subList(int fromIndex, int toIndex);: Devuelve el subconjunto índice de fromIndex (inclusive) para indexar toIndex (contienen exclusivo) que consiste en todos los elementos;
• void sort(Comparator<? super E> c) : Lista de elementos de la colección tipo de acuerdo parámetro Comparador;
• void replaceAll(UnaryOperator<E> operator) : restablece todos los elementos del conjunto de acuerdo con las reglas de cálculo operador especificado.
• ListIterator<E> listIterator();: Devuelve un objeto ListIterator que hereda la interfaz Iterator interfaz, un método para aumentar la interfaz Iterator basado en las funciones de avance iterativos y elementos pueden aumentarse:
  bookean hasPrevious(): si se debe devolver un iterador asociado a un conjunto de elementos allí;
  E previous();: devuelve un iterador un elemento superior; una
  void add(E e);: el elemento se inserta en la ubicación especificada;

Ejemplos

1) Ejecutar Principal

public class DemoApplication {

    public static void main(String[] args) {

        List<String> list = new ArrayList();
        list.add(new String("book001"));
        list.add(new String("book002"));
        list.add(new String(" book003 "));
        System.out.println("原列表：" + list);

        //将新字符串插入第二个位置
        list.add(1, new String("newBook002"));
        System.out.println("新增第二个位置元素后列表：" + list);

        //删除第三个元素
        list.remove(2);
        System.out.println("删除第三个元素后列表：" + list);

        //判断指定元素在List集合的位置
        System.out.println("判断newBook002的位置：" + list.indexOf(new String("newBook002")));

        //将第二元素替换新的字符串
        System.out.println("替换的旧值：" + list.set(1, new String("book002")));
        System.out.println("替换第二个元素后的列表：" + list);

        //返回第二个元素
        System.out.println("回第二个元素：" + list.get(1));

        List<String> newList = new ArrayList<>();
        newList.add("book001");
        newList.add("book004");
        newList.add("book002");

        //新增集合
        list.addAll(1, newList);
        System.out.println("新增一个集合后的列表：" + list);

        //返回元素最后一次出现的位置索引
        System.out.println("返回\"book001\"最后一次出现的位置：" + list.lastIndexOf("book001"));

        //截取子集合
        System.out.println("返回一个范围子集合列表：" + list.subList(0, 3));

        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //逆序
                return o2.compareTo(o1);
            }
        });

        //lambda表达式输出
        list.forEach(book -> System.out.println(book));

        list.replaceAll(String::trim);
        System.out.println("replaceAll去除两端空格" + list);

        list.replaceAll(t -> t.replace("book00", "书籍系列"));
        System.out.println("replaceAll替换字符串：" + list);

        System.out.println("正向迭代输出：");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
            //添加元素，会影响list元素
            listIterator.add("book");
        }
        System.out.println("反向迭代输出：");
        while(listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

        System.out.println(list);
    }

}

2) resultados de la ejecución:

原列表：[book001, book002,  book003 ]
新增第二个位置元素后列表：[book001, newBook002, book002,  book003 ]
删除第三个元素后列表：[book001, newBook002,  book003 ]
判断newBook002的位置：1
替换的旧值：newBook002
替换第二个元素后的列表：[book001, book002,  book003 ]
回第二个元素：book002
新增一个集合后的列表：[book001, book001, book004, book002, book002,  book003 ]
返回"book001"最后一次出现的位置：1
返回一个范围子集合列表：[book001, book001, book004]
book004
book002
book002
book001
book001
 book003 
replaceAll去除两端空格[book004, book002, book002, book001, book001, book003]
replaceAll替换字符串：[书籍系列4, 书籍系列2, 书籍系列2, 书籍系列1, 书籍系列1, 书籍系列3]
正向迭代输出：
书籍系列4
书籍系列2
书籍系列2
书籍系列1
书籍系列1
书籍系列3
反向迭代输出：
book
书籍系列3
book
书籍系列1
book
书籍系列1
book
书籍系列2
book
书籍系列2
book
书籍系列4
[书籍系列4, book, 书籍系列2, book, 书籍系列2, book, 书籍系列1, book, 书籍系列1, book, 书籍系列3, book]

  Observarse en los resultados operativos anteriores, System.out.println("判断newBook002的位置：" + list.indexOf(new String("newBook002")));volvemos a un nuevo "newBook002" para la posición de índice se determina, o podemos volver a la posición de índice, lista considerable colección de objetos está determinada sólo por los dos equals()métodos, si la anulación objeto equals()métodos son verdaderas, entonces el depósito lista de los objetos de la colección son de hecho iguales.