java基础语法（二十二）List_java list

List接口常用方法

1、List集合存储元素特点：有序可重复
    有序：List集合中的元素有下标，从0开始，依次递增
    可重复：存储的元素可以重复
2、List既然是Collection接口的子接口，那么肯定List接口有自己"特色"的方法;
    以下只列出List接口特有的常用的方法
        void add(int index,E element) 在列表的指定位置插入指定元素
        E get(int index) 返回列表中指定位置的元素
        int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回-1
        int LastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引
        E remove(int index) 移除列表中指定位置的元素
        E set(int index,E element) 用指定元素替换列表中指定位置的元素
1
2
3
4
5
6
7
8
9
10
11

public class ListTest01 {
    public static void main(String[] args) {
        //创建List类型的集合
        //  List myList = new LinkedList();
        List myList = new ArrayList();

        //添加元素
        myList.add("A");//默认都是向集合末尾添加元素
        myList.add("B");
        myList.add("C");
        myList.add("C");
        myList.add("D");
        myList.add(1,"KING");//在列表的指定位置插入指定元素

        //迭代
        Iterator it = myList.iterator();
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }

        //根据下标获取元素
        Object firstObj = myList.get(0);
        System.out.println(firstObj);

        //因为有下标，所以List集合有自己比较特殊的遍历方式
        //List集合特有的方式，Set没有
        for(int i = 0;i<myList.size();i++){
            Object obj = myList.get(i);
            System.out.println( obj);
        }

        //获得指定对象第一次出现的索引
        System.out.println(myList.indexOf("C"));//3
        //获取指定对象最后一次出现处的索引
        System.out.println(myList.lastIndexOf("C"));//4
        //删除指定下标位置的元素
        //删除下标为0的元素
        myList.remove(0);
        System.out.println(myList.size());//5
        System.out.println("======================");
        //修改指定位置的元素
        myList.set(2,"soft");
        //遍历集合
        for(int i = 0;i<myList.size();i++){
            Object obj = myList.get(i);
            System.out.println( obj);
        }

    }
}
/*
增：add、save、new
删：delete、drop、remove
改：update、set、modify
查：find、get、query、select
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

ArrayList集合

ArrayList集合
1、默认初始化容量10。（底层先创建一个长度为0的数组，当添加第一个元素的时候，初始化容量10）
2、集合底层是一个Object[]数组
3、构造方法：
new ArrayList();
new ArrayList(20);

4、ArrayList集合的扩容：
原容量的1.5倍
ArrayList集合底层是数组，怎么优化？
尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合的时候
估计元素的个数，给定一个初始化容量。
5、数组优点：检索效率比较高
数组缺点：随机增删元素效率比较低。但是向数组末尾添加元素，效率很高，不受影响
6、在这么多集合中，ArrayList集合使用最多
因为往数组末尾添加元素，效率不受影响。另外，检索/查找某个元素的操作比较多
7、ArrayList集合是非线程安全的。

public class ArrayListTest01 {
    public static void main(String[] args) {
        //默认初始化容量是10
        //数组的长度是10
        List list1 = new ArrayList();
        //集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量
        System.out.println(list1.size());//0

        //指定初始化容量
        //数组的长度是20
        List list2 = new ArrayList(20);
        System.out.println(list2.size());//0

        //创建一个HashSet集合
        Collection c = new HashSet();
        c.add(100);
        c.add(200);
        c.add(900);
        c.add(50);
        //通过这个构造方法就可以将HashSet集合转换成List集合
        List list3 = new ArrayList(c);
        for (int i = 0 ;i<list3.size();i++){
            System.out.println(list3.get(i));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

LinkList

单链表

/*
单链表中的节点：
节点是单向链表中的基本单元。
每一个节点Node都有两个属性：
    一个属性：是存储的数据
    另一个属性：是下一个节点的内存地址
 */
public class Node {
    //存储的数据
    Object element;
    //下一个节点的内存地址
    Node next;

    public Node() {
    }

    public Node(Object element, Node next) {
        this.element = element;
        this.next = next;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Link {
    //头结点
    Node header ;
     int size = 0;
     public int size(){
         return size;
     }
    //向链表中添加元素
    public void add(Object data){
        //创建一个新的节点对象
        //让之前单链表的末尾节点next指向新节点对象
        if (header == null){
            //说明还没有节点
            //new一个新的节点对象作为头节点对象
            //这个时候的头结点既是一个头结点，又是一个末尾节点
            header= new Node(data,null);
        }else{
            //说明头结点已经存在了
            //找出当前末尾节点，让当前末尾节点的next是新节点
            Node currentLastNode = findLast(header);
            currentLastNode.next = new Node(data,null);
        }
        size++;
    }

    /**
     * 专门查找末尾节点的方法
     * @param node
     * @return
     */
    private Node findLast(Node node){
        if(node.next==null){
            return node;
        }
        return findLast(node.next);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class Test {
    public static void main(String[] args) {
        Link link = new Link();
        link.add(100);
        link.add(200);
        System.out.println(link.size);
    }
}
1
2
3
4
5
6
7
8

双链表

链表的优点:
由于链表上的元素在空间存储上内存地址不连续。
所以随机增删元素的时候不会有大量元素位移,因此随机增删效率较高。
在以后的开发中。如果遇到随机增删集合中元素的业务比较多时,建议
使用LinkedList。
链表的缺点:
不能通过数学表达式计算被查找元素的内存地址,每-次查找都是从头
节点开始遍历,直到找到为止。所以LinkedList集合检索/查找的效率
较低。
ArrayList :把检索发挥到极致。
LinkedList :把随机增删发挥到极致。
加元素都是往末尾添加，所以ArrayList用的比LinkedList多。|

public class LinkListTest01 {
    public static void main(String[] args) {
        // LinkedList集合底层也是有下标的。
        //注意:ArrayList之所以检索效率比较高，不是单纯因为下标的原因。是因为底层数组发挥的作用。
        // LinkedList集合照祥有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历。
        List list = new LinkedList();
        list.add("a");
        list.add("b");
        list.add("c");
        for(int i =0;i<list.size();i++){
            Object obj = list.get(i);
            System.out.println(obj);
        }
        //LinkList集合有初始化容量吗？没有
        //最初这个链表中没有任何元素。first和last引用都是null。
        //不管是LinkedList还是ArrayList，以后写代码时不需要关心具体是哪个集合。
        //因为要面向接口编程，调用的方法都是接口中的方法。
        //List list2 = new ArrayList();//底层是数组
        List list2 = new LinkedList();//底层是双向链表
        //以下这些方法都是面向接口编程
        list2.add("123");
        list2.add("456");
        list2.add("789");
        for(int i =0;i<list2.size();i++){
            Object obj = list2.get(i);
            System.out.println(obj);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Vector:

1、底层也是一个数组
2、初始化容量：10
3、怎么扩容？
扩容之后是原容量的2倍
4、ArrayList集合扩容特点：
扩容之后是原容量的1.5倍
5、Vector中所有的方法都是线程同步的，都带有synchronized关键字。
是线程安全的。效率比较低，使用较少。
6、怎么将一个线程不安全的ArrayList集合转换成线程安全的？
使用集合工具类
java.util.Collections;
java.util.Collection是集合接口
java.util.Collections是集合工具类

public class VectorTest {
    public static void main(String[] args) {
        //创建一个Vector集合
        List vector = new Vector();
        //Vector vector = new Vector();
        vector.add(1);
        vector.add(2);
        vector.add(3);
        //遍历
        for(int i =0;i<vector.size();i++){
            Object obj = vector.get(i);
            System.out.println(obj);
        }
        //遍历
        Iterator it = vector.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }

        List myList = new ArrayList();//非线程安全的
        //变成线程安全的
        Collections.synchronizedList(myList);
        myList.add("111");
        myList.add("222");
        myList.add("333");
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30