java集合02-list

集合

foreach

jdk5.0新增foreach，遍历collection和数组

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Demo03 {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("tom");
        coll.add("jerry");
        coll.add(false);

        // for(集合元素的类型 局部变量：集合元素)
        for(Object obj:coll){
            System.out.println(obj);
        }

        // 遍历数组
        int[] arr = new int[]{1,2,3,4,5,6};
        for(int a:arr){
            System.out.println(a);
        }

        // practice
        String[] arr1 = new String[]{"aa","aa","aa"};
        
        // 普通for循环赋值
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = "gg";
        }
        for (int i = 0;i < arr1.length;i++){
            System.out.println(arr1[i]); // gg gg gg
        }

        // 增强for循环,不会修改原有数组中的元素
        for(String s:arr1){
            s = "hh";
        }
        for (int i = 0;i < arr1.length;i++) {
            System.out.println(arr1[i]); // gg gg gg
        }
    }
}

collection子接口：List接口

有序，可重复 – 动态数组

具体实现类：ArrayList, LinkedList, Vector

比较三种实现类的异同

同：三个类都是实现了List接口，存储数据的特点相同：存储有序的，可重复的数据

异：

• arraylist作为list接口的主要实现类；线程不安全，效率高，底层使用Object[]存储

• linkedlist：对于频繁的插入，删除操作，使用此类效率比arraylist高。底层使用双向链表存储

• vector作为list接口的古老实现类 jdk1.0；线程安全，效率低

ArrayList源码分析

jdk 7 与jdk 8 不同

---

jdk 7 情况下

ArrayList list = new ArrayList();
// 底层创建了长度是10的Object[]数组elementData
list.add(123);
// elementData[0] = new Integer(123);
list.add(11);
// 如果此次的添加导致底层elementData数组容量不够，则扩容
// 默认情况下，扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中

jdk 8 中的变化

ArrayList list = new ArrayList();
// 底层Object[] elementData初始化为{}，并没有创建长度为10的数组
list.add(123);
// 第一次调用add()方法时，底层才创建了长度为10的数组，并将数据123添加到element[0]

小结

jdk中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存

---

LinkedList源码分析

LinkedList link = new Linkedist();
// 内部声明了Node类型的first和last属性，默认值是null
link.add(123);
// 将123封装在Node当中，创建了Node对象
// 其中Node定义为：双向链表
private static class Node<E> {
  E item;
  Node<E> next;
  Node<E> prev;
  Node(Node<E> prev, E element,Node<E> next){
    this.item = element;
    this.next = next;
    this.prev = prev;
  }
}

Vector源码分析

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。

在扩容方面，默认扩容为原来的2倍。

---

List接口中的常用方法

package com.collection;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

// List接口中的常用方法
public class Demo04 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("aa");
        list.add(425);
        list.add("joe");
        list.add(123);
        System.out.println(list);

        // 1, add()

        // void add(int index,Object ele)：在index位置插入ele元素
        list.add(1,"bb");
        System.out.println(list);

        // 2, addAll()

        // boolean addAll(int index, Collection eles)
        // :从index位置开始将eles中的所有元素添加到原有list中
        List list1 = Arrays.asList(1,2,3);
        list.addAll(1,list1);
        System.out.println(list.size()); // 8

        // 3, get()

        // Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0)); // 123

        // 4, indexOf()

        // int indexOf(Object obj) :返回obj在当前集合中首次出现的位置
        int index = list.indexOf(456);
        System.out.println(index); // -1 not exist
        int index1 = list.indexOf(123);
        System.out.println(index1); // 0

        // 5, lastIndexOf()

        // int lastIndexOf(Object obj): 返回obj在集合中末次出现的位置
        System.out.println(list.lastIndexOf(123)); // 8

        // 6, remove()

        // Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj); // 123 被删除对象的元素
        System.out.println(list);

        // 7，set()

        // Object set(int index, Object ele)
        // 设置指定index位置的元素为ele
        list.set(1,"cc");
        System.out.println(list);

        // 8, sublist()

        // List sublist(int fromIndex, int toIndex)
        // 返回从fromIndex到toIndex位置的子集合（左闭右开）
        System.out.println(list.subList(2,4));
        // 不会对原list造成影响
        
    }
}

总结

增：add(Object obj)

删：remove(int index) / remove(Object obj)

改：set(int index, Object ele)

查：get(int index)

插：add(int index, Object ele)

长度：size()

遍历：

1. Iterator迭代器方法
2. 增强for循环
3. 普通的循环

// traversal
        // 方式1：iterator迭代器方法
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        // 方式2：增强for循环
        for(Object obj1:list){
            System.out.println(obj1);
        }

        // 方式3：普通for循环
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }

list面试小测

区分List中remove(int index)和remove(Object obj)

package com.collection;

import java.util.ArrayList;
import java.util.List;

// list practice
public class Demo05 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list); // [1,2]
    }

    private static void updateList(List list) {
        list.remove(2); // object or index? index
        list.remove(new Integer(2)); // remove object 2
    }
}

​

​