Uso del método set (index, object) y add (index, object) / Stack empty () y el método isEmpty () / deque deque en ArrayList y algunos principios

Fuente:
Descargo de responsabilidad: si violé los derechos de alguien, comuníquese conmigo y lo eliminaré.
Bienvenidos expertos para rociarme

ArrayList 中 set （index ， object） 与 add （index ， object)

set: reemplazar el objeto en
la posición del índice original agregar: mover la posición del índice original hacia atrás

List list = new ArrayList ();
list.add (index, obj);
poner el índice + 1 y el índice + Después de que un elemento se mueve hacia atrás un bit , similar a elementData [i + 1] = elementData [i]
y luego poner obj en la posición de índice.
Por supuesto, este proceso debe considerar la racionalidad del índice y si se desbordará.

El método empty () de la pila y el método isEmpty ()

Si no hay elementos en la matriz, devuelve verdadero.
Si hay elementos en la matriz, devuelve falso.

Stack hereda el método en la clase java.util.Vector
Aquí está el método en vector:

aquí está el método en
Stack: La función vacía () en Stack llamará a la función size () en vector y luego juzgará si está vacía.

Resumen: no debería haber diferencia

Deque uso y algunos principios

Referencia: https://www.cnblogs.com/denglh/p/7911513.html

import java.util.Deque;
import java.util.LinkedList;

public class DequeTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        Deque<String> deque = new LinkedList<String>();
        deque.add("d");
        deque.add("e");
        deque.add("f");
        
        //从队首取出元素，不会删除
        System.out.println("队首取出元素:"+deque.peek());
        System.out.println("队列为:"+deque);
        
        //从队首加入元素(队列有容量限制时用，无则用addFirst)
        deque.offerFirst("c");
        System.out.println("队首加入元素后为："+deque);
        //从队尾加入元素(队列有容量限制时用，无则用addLast)
        deque.offerLast("g");
        System.out.println("队尾加入元素后为："+deque);
        
        //队尾加入元素
        deque.offer("h");
        System.out.println("队尾加入元素后为："+deque);
        
        //获取并移除队列第一个元素,pollFirst()也是，区别在于队列为空时,removeFirst会抛出NoSuchElementException异常，后者返回null
        deque.removeFirst();
        System.out.println("获取并移除队列第一个元素后为:"+deque);
        
        //获取并移除队列第一个元素,此方法与pollLast 唯一区别在于队列为空时,removeLast会抛出NoSuchElementException异常，后者返回null
        deque.removeLast();
        System.out.println("获取并移除队列最后一个元素后为:"+deque);
        
        //获取队列第一个元素.此方法与 peekFirst 唯一的不同在于：如果此双端队列为空，它将抛出NoSuchElementException，后者返回null
        System.out.println("获取队列第一个元素为:"+deque.getFirst());
        System.out.println("获取队列第一个元素后为:"+deque);
        
        //获取队列最后一个元素.此方法与 peekLast 唯一的不同在于：如果此双端队列为空，它将抛出NoSuchElementException，后者返回null
        System.out.println("获取队列最后一个元素为:"+deque.getLast());
        System.out.println("获取队列第一个元素后为:"+deque);
        
        //循环获取元素并在队列移除元素
        while(deque.size()>0){
            System.out.println("获取元素为："+ deque.pop()+" 并删除");
        }
        System.out.println("队列为:"+deque);
    }

}

Salida

队首取出元素:d
队列为:[d, e, f]
队首加入元素后为：[c, d, e, f]
队尾加入元素后为：[c, d, e, f, g]
队尾加入元素后为：[c, d, e, f, g, h]
获取并移除队列第一个元素后为:[d, e, f, g, h]
获取并移除队列最后一个元素后为:[d, e, f, g]
获取队列第一个元素为:d
获取队列第一个元素后为:[d, e, f, g]
获取队列最后一个元素为:g
获取队列第一个元素后为:[d, e, f, g]
获取元素为：d 并删除
获取元素为：e 并删除
获取元素为：f 并删除
获取元素为：g 并删除
队列为:[]

La relación de herencia es: deque => cola => colección = "Iterable
1. Cuando se usa la cola, ¿por qué usar deque para recibir cuando se usa una nueva LinkedList en lugar de LinkedList?
　　Respuesta: deque hereda la interfaz de cola porque tiene dos implementaciones, LinkedList y ArrayDeque. Recibir con deque se debe a la conversión ascendente (la subclase se transfiere a la clase principal y las funciones especiales de la subclase se perderán). Puedes probarlo. Usa el método get () para recibir LinkedList.
2. ¿Por qué no es suficiente tener una implementación, sino dos? ¿Siempre hay diferencias entre ellas?
　　Respuesta: ArrayDeque es un Deque implementado basado en punteros de cabeza y cola, lo que significa que no se puede acceder al primer y último elemento. Si desea utilizar iteradores, puede iterar hacia adelante y hacia atrás.
　　　　ArrayDeque es generalmente mejor que las colas de listas enlazadas / colas de dos extremos. Se genera una cantidad limitada de basura (las matrices antiguas se descartarán en la expansión). Se recomienda usar deque, se prefiere ArrayDeque.