【我的Java笔记】Collection集合的概述 & List

1.概念：可以储存对象的容器变量

2.容器变量：

数组，StringBuffer和StringBuilder。

对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变)

StringBuffer始终在内存中返回的是字符串类型,也不满足元素类型变化的要求

3.题目：集合和数组的区别

（1）长度的区别:
   数组:长度是固定的;
   集合:长度是可变的
   （2）存储数据类型的区别:
   数组:可以存储引用类型,可以存储基本数据类型
   集合:只能存储引用类型
   （3）存储元素的区别
   数组:在同一个数组中,只能存储同一种数据类型的元素
   集合:可以存储多种数据类型的元素;   

4.集合体系图

collection（接口）

1.概述：表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。
  一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现

2.collection中的成员方法：

（1）添加功能:
   boolean add(Object e)给集合中添加指定的元素
   boolean addAll(Collection c)添加一个集合中的所有元素
  （2） 删除功能:
   void clear()删除一个集合中的所有元素,暴力删除,(会删除所有，不建议使用)
   boolean remove(Object o)删除一个集合中的指定元素
   boolean removeAll(Collection c)删除一个集合中的所有元素?注：删除一个算是删除

   （3）判断功能:
   boolean contains(Object o)判断一个集合中是否包含指定的单个元素
   boolean containsAll(Collection c)判断一个集合中是否另一个集合;注：包含一个集合中的所有元素算是包含.
   boolean isEmpty()判断集合是否为空,如果为空,则返回true
   （4）交集功能:
   boolean retainAll(Collection c)仅保留此 collection 中那些也包含在指定 collection 的元素

注：交集的元素去集合A里了，如果集合A的元素发生了变化则返回true，没有变化则返回false

若两个集合中元素完全相同，则返回false（集合A没有发生改变）

若两个集合中元素完全不同，则返回true（集合A变为空集）
   （5）获取功能;
   int size() 获取集合中的元素数
   Iterator<E> iterator()迭代器
   （6）转换功能:
   Object[] toArray()将集合转换成数组

例：

import java.util.ArrayList;import java.util.Collection;public class CollectionDemo {public static void main(String[] args) {//创建一个Collection集合对象Collection c = new ArrayList() ;//子实现类去实现Collection对象//添加功能://boolean add(Object e):给集合中添加指定的元素//boolean flag = c.add("hello") ;//若添加元素，则一定返回truec.add("hello") ;c.add("world") ;c.add("123") ;System.out.println(c);//boolean remove(Object o):删除一个集合中的指定元素System.out.println("remove:"+c.remove("hello")) ;System.out.println("remove:"+c.remove("javaweb")) ;//boolean contains(Object o):判断一个集合中是否包含指定的单个元素System.out.println("contains:"+c.contains("world"));//boolean isEmpty():判断集合是否为空,如果为空,则返回trueSystem.out.println("isEmpty:"+c.isEmpty());//int size():获取集合中的元素数System.out.println("size:"+c.size());System.out.println("c:"+c);}}

例（将集合转为数组）：

import java.util.ArrayList;import java.util.Collection;public class CollectionDemo {public static void main(String[] args) {//创建Collection集合对象Collection c = new ArrayList() ;//给集合中添加元素c.add("伊卡尔迪") ;c.add("佩里西奇") ;c.add("坎德雷瓦") ;//将集合转换数组Object[] objs = c.toArray() ;//遍历对象数组for(int i = 0 ;i  < objs.length ; i ++){//需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度//要获取字符串长度:需要使用length(),该方法属于String类的特有功能String s = (String) objs[i] ;//向下转型System.out.println(s+"----"+s.length());}}}

Iterator(迭代器)

1.集合中的专有遍历方式（接口）：

Iterator iterator( ) 迭代器

2.成员方法：

（1）Object next()获取功能（返回迭代的下一个元素）

（2）boolean hasNext()判断功能（判断一个集合中是否有下一个可以迭代的元素）

3.使用迭代器的循环方法：

（1）while循环while(it.hasNext()){

it.next();

}

（2）for 循环

for(Iterator it=c.iterator() ; it.hasNext() ;)

4.迭代器原理图解：

例：

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class CollectionDemo {public static void main(String[] args) {//创建集合对象Collection c = new ArrayList() ;//ArrayList是List集合的子实现类(存储和取出一致的)//给集合中添加元素c.add("hello") ;c.add("world") ;c.add("java") ;c.add("java") ;c.add("java") ;c.add("java") ;//获取迭代器对象Iterator it = c.iterator() ;while(it.hasNext()){//需求：获取字符串的同时,还要获取字符串长度//获取元素Object obj = it.next() ;//向下转型String s = (String)it.next() ;System.out.println(s+"----"+s.length());}}}

List (接口)

1.概述：List集合是一个有序的集合（下标和元素是一一对应的）

注：该集合中元素是可以重复的

2.List集合中的特有方法：

（1）添加功能:
   void add(int index, Object element)在列表的指定位置插入指定元素
   （2）删除功能:
   Object remove(int index)移除列表中指定位置的元素（返回被删除的元素）

   （3）获取功能:
   ListIterator listIterator()列表迭代器:List集合的专有遍历方式
   Object get(int index)返回列表中指定位置的元素
   （4）替换
   set(int index,Object element)用指定元素替换列表中指定位置的元素（返回被替代的元素）

3.List集合中的遍历方式：

（1）toArray ( )

（2）Collection集合中的Iterator iterator ( )

（3）遍历注意事项：

使用迭代器去遍历集合时，不能直接给集合添加元素！

解决方法：①使用迭代器遍历集合，使用迭代器添加元素

     ②使用集合遍历，使用集合添加元素

4.List集合的列表迭代器 ListIterator listIterator()：

（1）正向遍历：①boolean hasNext():判断是否有下一个可以迭代的元素

 ②Object next():如果有可以遍历的元素,就获取这个元素
  
  （2）逆向遍历： ①boolean hasPrevious():判断是否有上一个可以迭代的元素
②  Object  previous():如果有上一个可以迭代的元素,就获取上一个元素

注：要使用逆向遍历则必须现有正向遍历存在，否则直接使用逆向遍历无意义！

例（逆向遍历）：

import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class ListDemo {public static void main(String[] args) {//创建集合对象List list = new ArrayList() ;//给集合中添加元素list.add("hello") ;list.add("world") ;list.add("java") ;//获取列表迭代器ListIterator it = list.listIterator() ;while(it.hasNext()){String s = (String)it.next();System.out.println(s);}System.out.println("-----------------------");//boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)//Object  previous():如果有上一个可以迭代的元素,就获取上一个元素while(it.hasPrevious()){String s = (String)it.previous() ;System.out.println(s);}}}

练习

/* * 需求：有一个集合，判断此集合里是否存在“world”这个元素，若存在，则在其后添加一个“javaee”元素 *  * 注：1.当使用迭代器遍历集合时，不能直接给集合去添加元素。否则会抛出异常： * java.util.ConcurrentModificationException:并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常 *   2.解决方法： *     使用迭代器遍历集合,使用迭代器添加元素 *     使用集合遍历,使用集合添加元素 * */import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class ListDemo {public static void main(String[] args) {//创建List集合对象List list = new ArrayList() ;//给集合中添加元素list.add("hello") ;list.add("world") ;list.add("java") ;/*错误方法：Iterator it = list.iterator() ;//遍历while(it.hasNext()){String s = (String)it.next() ;//判断if("world".equals(s)){//添加元素list.add("javaee") ;}}注：此种方法错误！使用迭代器遍历集合，不能直接给集合去添加元素。否则会抛出异常：java.util.ConcurrentModificationException并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常*///方法1:使用迭代器遍历集合,使用迭代器添加元素ListIterator it = list.listIterator() ;//ListIterator迭代器中含有其特有的添加功能add(); 而Iterator迭代器中不存在while(it.hasNext()){String s = (String) it.next() ;//判断if("world".equals(s)){//使用迭代器添加it.add("javaee") ;}}/*//方法2:使用集合遍历(普通for循环size()和get()相结合),使用集合添加元素for(int x = 0 ; x <list.size() ; x ++){String s = (String) list.get(x) ;//判断if("world".equals(s)){//集合添加list.add("javaee") ;}}*///输出集合System.out.println("list:"+list);}}

6重要.List集合子实现类的特点：

（1）ArrayList：
底层数据结构是数组的形式，满足数组结构的特点：查询快，增删慢
从线程安全问题来看：线程不安全，不同步，执行效率高
（2）Vector：
底层数据结构是数组的形式，特点：查询快，增删慢
从线程角度看：线程安全的类，同步，执行效率低
（3）LinkedList：
底层数据结构是链接列表，特点：查询慢，增删快
从线程角度看：线程不安全的一个类，不同步，执行效率高

注：若实现多线程程序，则要使用安全的类（Vector类）

若在一般需求中没有要求，则采用ArrayList类，安全则需使用Vector类

Vector类（List的子实现类）

1.特点：

底层数据结构是数组的形式，特点：查询快，增删慢

从线程角度看：线程安全的类，同步，执行效率低

2.特有功能：

（1）public void addElement(E obj)——>相当于ArrayList类的：add(Object e)

（2）public Enumeration<E> elements()枚举——> 相当于：Iterator iterator()

Enumeration<E>接口：向量的组件枚举的两个方法：

boolean hasMoreElements()——> 相当于：hasNext()
Object nextElement()——>相当于：next();

LinkedList类（List的子实现类）

1.特点：

底层数据结构是链接列表，特点：查询慢，增删快
从线程角度看：线程不安全的一个类，不同步，执行效率高

2.特有方法：

特有功能:
（1）添加功能：
public void addFirst(E e)将指定元素插入此列表的开头
public void addLast(E e)将指定元素添加到此列表的结尾
（2）获取功能：
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素
（3）删除功能：
public Object removeFirst()移除并返回此列表的第一个元素
public Object removeLast()移除并返回此列表的最后一个元素

例1：

import java.util.LinkedList;public class LinkedListDemo {public static void main(String[] args) {LinkedList<String> link = new LinkedList<>();//添加元素link.addFirst("hello");link.addFirst("world");link.addLast("Java");System.out.println(link);//public Object getFirst()返回此列表的第一个元素//public Object getLast()返回此列表的最后一个元素String s1 = link.getFirst();String s2 = link.getLast();System.out.println(s1+","+s2);//public Object removeFirst()移除并返回此列表的第一个元素//public Object removeLast()移除并返回此列表的最后一个元素String s3 = link.removeFirst();String s4 = link.removeLast();System.out.println(s3+","+s4);}}

结果：

[world, hello, Java]
world,Java
world,Java

*练习：去除集合中重复元素

练习一

/** * 需求:ArrayList去除集合中字符串的重复元素 *  * 分析： * 1)首先创建一个集合 * 2)给集合中添加很多重复元素 * 3)再次创建一个新集合 * 4)获取迭代器遍历 * 5)获取到该集合中的每一个元素 * 判断新集合中是否包含这些有素 * 有,不搭理它 * 没有.说明不重复,添加进来 * 6)遍历新集合 */public class ArrayListDemo {public static void main(String[] args) {//1)创建一个集合ArrayList array = new ArrayList() ;//2)给集合中添加多个重复元素array.add("hello") ;array.add("hello") ;array.add("hello") ;array.add("world") ;array.add("world") ;array.add("world") ;array.add("Java") ;array.add("Java") ;array.add("hello") ;array.add("Javaweb") ;array.add("JavaEE") ;array.add("JavaEE") ;//3)创建一个新的集合ArrayList newArray = new ArrayList() ;//4)遍历旧集合,获取当前迭代器对象Iterator it = array.iterator() ;while(it.hasNext()){String s = (String) it.next() ;//拿到了每一个字符串元素//判断新集合是否包含旧集合中的元素if(!newArray.contains(s)){//不包含,就将元素直接添加到新集合中newArray.add(s) ;}}//遍历新集合Iterator it2 = newArray.iterator() ;while(it2.hasNext()){String s = (String) it2.next() ;System.out.println(s);}}}

练习二

/** *  需求:ArrayList去除集合中字符串的重复元素,并且不能使用创建新集合的方式 */ import java.util.ArrayList;import java.util.Iterator;public class ArrayListDemo1 {public static void main(String[] args) {//创建一个集合,添加重复元素ArrayList array = new ArrayList() ;array.add("hello") ;array.add("hello") ;array.add("hello") ;array.add("world") ;array.add("world") ;array.add("world") ;array.add("Java") ;array.add("Java") ;array.add("hello") ;array.add("Javaweb") ;array.add("JavaEE") ;array.add("JavaEE") ;//System.out.println(array);/** * 选择排序逻辑(remove()移除元素方法): * 拿0索引对应的元素依次和后面索引对应的元素进行比较 * 同理,1索引对应的元素和后面..... * 前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素 */for(int x = 0 ;x <array.size() -1 ; x ++){for(int y= x +1 ; y <array.size() ;y++){//判断if(array.get(x).equals(array.get(y))){array.remove(y) ;y -- ;}}}//遍历集合Iterator it = array.iterator() ;while(it.hasNext()){String s = (String) it.next() ;System.out.println(s);}}}

练习三

/* * ArrayList去除自定义对象的重复值(成员变量值一样) * */import java.util.ArrayList;import java.util.Iterator;public class Test {public static void main(String[] args){Student s1 = new Student("伊卡尔迪",24);Student s2 = new Student("伊布拉希莫维奇",36);Student s3 = new Student("伊卡尔迪",24);Student s4 = new Student("穆里尼奥",51);Student s5 = new Student("佩里西奇",27);Student s6 = new Student("斯帕莱蒂",55);Student s7 = new Student("伊布拉希莫维奇",36);ArrayList<Student> list = new ArrayList<>();list.add(s1);list.add(s2);list.add(s3);list.add(s4);list.add(s5);list.add(s6);list.add(s7);//使用双重for循环和ArrayList类中的remove()删除方法for(int i=0; i<list.size()-1;i++){for(int j=i+1; j<list.size();j++){if(list.get(i).equals(list.get(j))){list.remove(j);j--;}}}Iterator<Student> it = list.iterator();while(it.hasNext()){Student s = it.next();System.out.println(s);}}}class Student{String name;int age;public Student(){}public Student(String name, int age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//重写toString()方法public String toString(){return name+","+age;}@Override//重写equals()方法public boolean equals(Object obj) {Student s = (Student)obj;if(s.name==this.name && s.age==this.age){return true;}else{return false;}}}

例2：使用LinkedList类模仿“栈”结构的特点（addFirst() 和 removeFirst() 方法）

/* * 需求：自定义栈的集合类 * */import java.util.LinkedList;public class StackTest {public static void main(String[] args) {MyStack ms = new MyStack();//调用添加功能ms.add("hello");ms.add("world");ms.add("java");//判断当前集合是否为空while(!ms.isEmpty()){System.out.println(ms.get());}}}//模仿“栈”特点的工具类class MyStack {//成员变量private LinkedList link ;//无参构造//通过无参进行LinkedList集合对象 的创建public MyStack(){link = new LinkedList() ;}//添加功能public void add(Object obj){link.addFirst(obj) ;//向集合中列表插入到第一个元素}//获取功能public Object get(){return link.removeFirst() ;//删除集合列表中的第一个元素,返回值是被删除的元素}//定义判断集合是否为空public boolean isEmpty(){return link.isEmpty() ;}}