【我的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") ;	//若添加元素，则一定返回true
		c.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():判断集合是否为空,如果为空,则返回true
		System.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() ;
	}
}