Java集合框架1-->List

List

1）ArrayList (类似于数组，只是以一个集合元素的形式进行存储)

集合中，元素可以重复

add(); //追加元素,接受的是一个Object所以当使用原生数据类型的时候，需要包裹类，转换为类的对象，在使用转换成基本数据类型，进行输出

例子如下截图：

get(); //获取元素，返回的类型为Object，所以一般需要使用强制类型转换

remove(); //删除信息，使用索引删除信息的原理是删除后，后面的向前移动（注意再次使用的时候，下标越界）；也可以使用直接输入元素进行删除（元素重复应该注意）

indexof(); //只要找到一个就返回了，后面有重复的也不在查找索引值了

toArray();

public Object[] toArray() //在最后类型转换的时候，Object[]不能转换为Integer[]

 

查看源代码得出：ArrayList的底层实现，是使用的一个Object[]数组实现的，各种方法和数组的算法类似，适合数据的搜索。

 

2）       LinkedList

预备知识（链表---模仿北京圣思园）

 

a.  单向链表的例子

package com.Test.java;

 

public class Node {

    String data;

    Node next;

   

    public Node() {

    }

   

    public Node(String data) {

       this.data = data;

    }

}

 

package com.Test.java;

 

public class NodeTest {

    public static void main(String[] args) {

      

       //不同单向链表的例子

       Node node1 = new Node("node1");

       Node node2 = new Node("node2");

       Node node3 = new Node("node3");

      

       node1.next = node2;

       node2.next = node3;

      

       System.out.println(node1.next.next.data);

      

       System.out.println("------------------");

      

       //在单向链表中添加一个节点

       Node node4 = new Node("node4");

      

       node1.next = node4;

       node4.next = node2;

      

        System.out.println(node1.next.next.next.data);

      

       System.out.println("------------------");

      

       //删除node4

       node1.next = node2;

       node4.next = null;

      

       System.out.println(node1.next.next.data);

      

       //循环单向链表

       node3.next = node1;

      

       System.out.println("------------------");

      

       System.out.println(node1.next.next.next.data);

    }

}

 

b.  双向链表的例子

package com.Test.java;

 

public class Node2 {

    String data;

    Node2 previous;

    Node2 next;

   

    public Node2(){

}

   

    public Node2(String data) {

       this.data = data;

    }

}

 

package com.Test.java;

 

public class Node2Test {

    public static void main(String[] args) {

      

       //双向链表的例子

       Node2 node1 = new Node2("node1");

       Node2 node2 = new Node2("node2");

       Node2 node3 = new Node2("node3");

      

       //实现node1 and node2的双向循环

       node1.next = node2;

       node2.previous = node1;

      

       //实现node2 and node3的双向循环

       node2.next = node3;

       node3.previous = node2;

      

       //实现node3 and node1的双向循环

       node3.next = node1;

       node1.previous = node3;

      

       System.out.println(node1.next.next.previous.previous.data);

      

       System.out.println("------------------");

      

       //添加一个node4插入到node1 and node2之间

       Node2 node4 = new Node2("node4");

      

       //实现node1 and node4的双向循环

       node1.next = node4;

       node4.previous = node1;

      

       //实现node4 and node2的双向循环

       node4.next = node2;

       node2.previous = node4;

      

       System.out.println(node1.next.next.previous.data);

      

       System.out.println("-------------------");

      

       //删除node4这个节点的链接

       node1.next = node2;

       node2.previous = node1;

       node4.previous = null;

       node4.next = null;

      

       System.out.println(node1.next.next.previous.previous.data);

    }

}

 

c.  LinkedList对栈和队列的操作的例子

package com.Test.java;

 

import java.util.LinkedList;

 

/**

 * 使用LinkedList,进行队列的操作

 * @author 卢林

*/

public class QueueTest {

    private LinkedList list = new LinkedList();

   

    //实现队列的放入

    public void put(Object o) {

       list.addLast(o);

    }

   

    //实现队列的取出，因为要连续取出，所以不使用getFirst()

    public Object get() {

       return list.removeFirst();

    }

   

    //判断队列是否为空，如果为null，就返回true，反之，则返回false

    public boolean isEmpty() {

       return list.isEmpty();

    }

   

    public static void main(String[] args) {

       QueueTest myQueue = new QueueTest();

      

       //向队列中存放三个元素

       myQueue.put("one");

       myQueue.put("two");

       myQueue.put("three");

      

       //依次取出队列中的元素

       System.out.println(myQueue.get());

       System.out.println(myQueue.get());

       System.out.println(myQueue.get());

      

       //返回的队列是否为null的值

       System.out.println(myQueue.isEmpty());

      

    }

}

 

package com.Test.java;

 

import java.util.LinkedList;

 

/**

 * 使用LinkedList，进行栈的操作

 * @author 卢林

 */

public class StackTest {

    private LinkedList list = new LinkedList();

   

    //压栈的操作，放入第一个元素

    public void push(Object o) {

       list.addFirst(o);

    }

   

    /**

     * 从栈中弹出最后放入的那个元素

     * 因为是弹出，所以要进行删除操作

     * @return return pop's first element

     */

    public Object pop() {

       return list.removeFirst();

    }

   

    /**

     * 从栈中调用一下放入的最后一个元素

     * 不进行删除操作

     * 也可以使用getFirst()，效果一样

     * 但是最好使用那个peekFirst()

     * @return peek's first element

     */

    public Object peek() {

       return list.peekFirst();

    }

   

    //如果栈中元素为null就返回true，反之，则返回false

    public boolean isEmpty() {

       return list.isEmpty();

    }

   

    public static void main(String[] args) {

       StackTest myStack = new StackTest();

      

       //放置元素

       myStack.push("a");

       myStack.push("b");

       myStack.push("c");

      

       //取出被弹出栈的元素的值

       System.out.println(myStack.pop());

        System.out.println(myStack.pop());

       System.out.println(myStack.pop());

      

       //输出栈此时的状态（null or not null）

       System.out.println(myStack.isEmpty());

      

       System.out.println("---------------");

      

       //重新压栈测试

       myStack.push("a");

       myStack.push("b");

       myStack.push("c");

      

       //进行调用，不删除的操作

       System.out.println(myStack.peek());

       System.out.println(myStack.peek());

       System.out.println(myStack.peek());

      

       //输出栈此时的状态（null or not null）

       System.out.println(myStack.isEmpty());

    }

}

 

查看源代码得出：LinkedList的底层是使用双向链表实现的，适合数据的删除和插入, LinkedList中所维护的是一个个的Entry对象。

由于以上代码有注解，所以就不文档说明了