List集合

实现类

ArraysList     LinkedList       Vector       Stack     CopyOnWriteArraysList

ArraysList

1.特点：有序   可重复   线程不安全

2.数据结构：基于Object[]elementDate的数组来实现的

3.适应范围：查找,遍历效率高  插入,删除效率低

3.方法：add(元素) 添加元素到集合的末尾

arrayList.add("123");

add(index, element);将元素添加到指定的下标位置

arrayList.add(0, "345");

使用Arrays.asList(元素)方法可以快速的生成一个list集合,返回值为list集合

List<String> list = Arrays.asList("1234", "45456");

addAll(集合) 添加一个集合到集合的末尾

arrayList.addAll(list);

addAll(index, c)将集合添加到指定的下标位置

arrayList.addAll(0, list);

size()查看集合的元素个数,返回值类型为int类型

int size = arrayList.size();

System.out.println("元素的个数" + size);

get(下标)通过下标查找集合中的元素

System.out.println("首元素" + arrayList.get(0));

System.out.println("尾元素" + arrayList.get(arrayList.size() - 1));

indexOf(元素)查找集合中的指定元素的下标,返回值类型为int类型

int index = arrayList.indexOf("1234");

System.out.println("元素1234所在的下标" + index);

contains(元素)查找元素在集合中是否存在,返回值类型为boolean类型

boolean b = arrayList.contains("1234");

System.out.println("元素1234是否存在" + b);

isEmpty()判断集合是否为空 ,返回值类型为boolean类型

boolean b1 = arrayList.isEmpty();

System.out.println("集合是否为空" + b1);

subList(fromIndex, toIndex)从开始下标到结束下标对集合进行截取,返回值为list集合

List<String> list2 = arrayList.subList(0, 2);

System.out.println(list2);

equals()判断两个集合是否相等

boolean b3 = arrayList.equals(list2);

System.out.println("两个集合是否相等" + b3);

arrayList.set(index, element)

参数1:旧元素的下标      参数2:要进行替换的新元素

将指定下标的旧元素修改为新元素,返回的为旧的元素

String s3 = arrayList.set(0, "567");

System.out.println("修改的元素" + s3);

System.out.println("修改后的集合" + arrayList);

对元素进行替换的操作

int index1 = arrayList.indexOf("567");

if (index1 > -1) {

String s4 = arrayList.set(index1, "678");

}

remove(下标)删除指定下标的元素,返回的为旧的元素

String s4 = arrayList.remove(2);

System.out.println("删除的下标为2的元素为" + s4);

remove(元素)删除指定元素,返回值为boolean类型

当泛型为Integer时,如果删除的下标与元素相等时,优先删除指定下标的元素

boolean b4 = arrayList.remove("678");

System.out.println("删除元素678是否成功" + b4);

clear()对集合进行清除

arrayList.clear();

System.out.println(arrayList);

ArrayList<String> arrayList2 = newArrayList<String>(Arrays.asList("12", "123", "1234", );

ArrayList<String> arrayList3 = new ArrayList<String>(Arrays.asList("12", "123", "54643"));

removeAll() 两个集合的差集,返回值为boolean类型

boolean b5 = arrayList2.removeAll(arrayList3);

System.out.println(b5);

System.out.println(arrayList2);

System.out.println(arrayList3);

retainAll() 两个集合的交集,返回值为boolean类型

boolean b6 = arrayList2.retainAll(arrayList3);

System.out.println(b6);

System.out.println(arrayList2);

System.out.println(arrayList3);

clone() 对一个集合进行克隆,返回一个完全一样的集合

ArrayList<String> arrayList4 = (ArrayList<String>) arrayList.clone();

System.out.println(arrayList4);

sort()对集合进行排序

arrayList.sort(new Comparator<String>() {

@Override

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

});

System.out.println(arrayList);

toArray()将一个集合变为数组,返回值类型为Object[]的数组

Object[] objects = arrayList.toArray();

System.out.println(Arrays.toString(objects));

toArray(a)将一个集合变为数组,返回值类型为与括号中的数组类型相同

String[] strings = arrayList.toArray(new String[0]);

System.out.println(Arrays.toString(strings));

4.遍历方法：  1.for循环进行遍历

for (int i = 0; i < arrayList.size(); i++) {

System.out.println(arrayList.get(i));

}

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

 2.for each 进行遍历

for (String string : list) {

System.out.println(string);

}

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

3.迭代器

3.1 获取当前集合的“普通的”迭代器对象

Iterator<String> iterator = arrayList.iterator();

      通过迭代器对象判断是否存在下一个元素

while (iterator.hasNext()) {

System.out.println(iterator.next());

}

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

3.2 获取当前集合的list迭代器对象

       从指定的下标开始正序遍历元素

ListIterator<String> listIterator = arrayList.listIterator();

while (listIterator.hasNext()) {

System.out.println(listIterator.next());

}

//      从指定的下标开始逆序遍历元素

ListIterator<String> listIterator1 = arrayList.listIterator();

while (listIterator1.hasPrevious()) {

System.out.println(listIterator.previous());

5.构造方法： 一:无参构造方法的初始化 : 内部数组初始化成空数组

ArrayList<String>arrayList=new ArrayList<String>();

 二:ArrayList<String>( int initialCapacity)初始化成长度为指定容量的Object[]数组

ArrayList<String>arrayList1=new ArrayList<String>(10);

 三:ArrayList<String>(c)内部的的数组被集合进行初始化

ArrayList<String>arrayList2=new ArrayList<String>(Arrays.asList("11"));

 LinkedList 

1. 特点：有序   可重复   线程不安全
2. 数据结构：双向链表
3. 扩容方式：链表动态扩容：每添加一个节点,链表动态扩容一个元素空间
4. 使用场景：查找,遍历效率低  插入,删除效率高

方法：      方法与ArraysList中的方法一致

add(元素)将元素添加到集合的末尾,返回值为boolean类型

boolean a = linkedList.add("11");

      add(index, element);将元素添加到集合的指定位置,无返回值

linkedList.add(0, "12");

      addAll(集合)将一个集合添加到集合的末尾,返回值为boolean类型        

boolean a1 = linkedList.addAll(Arrays.asList("13", "14"));

      addAll(index, c)将一个集合添加到集合的指定位置,返回值为boolean类型   

boolean a2 = linkedList.addAll(1, Arrays.asList("15", "16"));

      addFirst(元素)将元素添加到集合的首位,无返回值

linkedList.addFirst("17");

      addLast(元素)将元素添加到集合的末位,无返回值

linkedList.addLast("19");

      get(index)通过下标获取集合中的元素,返回值与泛型一样

String s1 = linkedList.get(2);

      getFirst()获取集合中的首元素,返回值与泛型一样       

String s2 = linkedList.getFirst();

      getLast()获取集合中的尾元素,返回值与泛型一样  

String s3 = linkedList.getLast();

      set(index, element)通过下标将集合中的旧元素替换为新元素,返回值与泛型一样,返回的是旧的元素

String S4 = linkedList.set(2, "10");

      remove()移除集合中的首元素,返回值与泛型一样,返回的是删除的元素

String s5 = linkedList.remove();

      remove(index)通过下标将集合中的元素进行删除,返回值与泛型一样,返回的是删除的元素

String s6 = linkedList.remove(2);

      removeFirst()移除集合中的首元素,返回值与泛型一样,返回的是删除的元素

String s7 = linkedList.removeFirst();

      removeLast()移除集合中的尾元素,返回值与泛型一样,返回的是删除的元素

String s8 = linkedList.removeLast();

5.遍历方法：   1.for循环进行遍历

for (int i = 0; i < linkedList.size(); i++) {

System.out.println(linkedList.get(i));

}

        2.for each 进行遍历

for (String string : list) {

System.out.println(string);

}

      3.迭代器

      3.1 获取当前集合的“普通的”迭代器对象

Iterator<String> iterator = linkedList.iterator();

      通过迭代器对象判断是否存在下一个元素

while (iterator.hasNext()) {

System.out.println(iterator.next());

}

       3.2 获取当前集合的list迭代器对象

       从指定的下标开始正序遍历元素

ListIterator<String> listIterator = linkedList.listIterator();

while (listIterator.hasNext()) {

System.out.println(listIterator.next());

}

       从指定的下标开始逆序遍历元素

ListIterator<String> listIterator1 = linkedList.listIterator();

while (listIterator1.hasPrevious()) {

System.out.println(listIterator.previous());

}

Vector

1. 数据结构：基于Object[]elementDate的数组来实现的
2. 特点：线程安全
3. 构造方法：

      无参构造初始:初始化的容量为10,数组扩容2倍

Vector<String> vector = new Vector<String>();

      单参的初始化:初始化的容量尾指定的数字容量

Vector<String> vector1 = new Vector<String>(100);

     双参的初始化:自定义数组的初始化容量和扩容的增长数

Vector<String> vector2 = new Vector<String>(100, 20);

1. Vector和ArrayList的相同点和不同点

相同点:底层都是基于Object[]elementDate数组来实现的

不同点:    

默认初始化  Vector的无参构造默认初始化容量为10

            ArrayList的无参构造默认初始化容量为0,第一次添加后容量变为10

扩容        ArrayList是1.5倍进行扩容

            Vector是2倍进行扩容,也可以自定义扩容

线程与效率  ArrayList线程不安全,效率高

             Vector线程安全,效率低

 Stack

1数据结构：继承自Vector,基于Object[]elementDate的数组来实现的

2特点：先进后出    线程安全

3方法：Stack<String> stack = new Stack<String>();

      push(元素)将元素入栈

stack.push("123");

stack.push("12");

stack.push("13");

System.out.println(stack);

      pop()获取元素,出栈---获取元素并让元素出栈

String s1 = stack.pop();

System.out.println(s1);

System.out.println(stack);

      peek()获取元素---获取元素并且元素不出栈

String s2 = stack.peek();

System.out.println(s2);

System.out.println(stack);

4 遍历方法：

while (!stack.isEmpty()) {

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

}

System.out.println(stack);

CopyOnWriteArraysList

1 数据结构：基于Object[]elementDate的数组来实现的

2 特点：线程安全

3 线程安全的原因：

   1 ：通过ReentrantLock锁来实现

   2：CopyOnWrite：“写入”操作时,先进行数组的复制,然后在新的数组中进行写入操作,然后进行替换,允许读写同时进行。

---

---