java--集合

集合(Collection)

集合的由来

一.集合的由来

• 数组长度是固定的，当添加的元素超过了数组的长度时需要对数组重新定义，太麻烦，Java内部给我们提供了集合类，能存储任意对象，长度是可以改变的，随着元素的增加而增加，随着元素的减少而减少

二.集合与数组的区别

1.区别1：

• 数组既可以存储基本数据类型，也可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值
• 集合只能存储引用数据类型（对象）集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象

2.区别2：

• 数组长度是固定的，不能自动增长
• 集合的长度是可变的，可以根据元素的增长而增长

三.数组与集合什么时候用？

• 如果元素个数是固定的推荐用数组，节省内存
• 如果元素个数不是固定的推荐用集合

四.集合继承体系图

集合基本功能

一.基本功能

• boolean add(E e)：添加指定元素
• boolean remove(Object o)：删除指定元素
• void clear()：清空集合
• boolean contains(Object o)：判断是否包含指定元素
• boolean isEmpty()：判断集合是否为空
• int size()：获取元素的个数

补充

add方法如果是List集合一直都返回true，因为List集合中可以存储重复元素
如果是Set集合，当存储重复元素的时候，就会返回false

二.注意：

• collectionXxx.java 使用了未经检查或不安全的操作
  注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译
  java编译器认为改程序存在安全隐患
  温馨提示：这不是编译失败，所以先不用理会，等学了泛型你就知道了

案例演示

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

import com.heima.bean.Student;

public class Demo2_collection {

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {
		//demo1();
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		/*
		 c.remove("a");                            //删除指定元素
		System.out.println(c);//[b, c, d]
		
		c.clear();                                 //清空集合
		System.out.println(c);//[]
		
		System.out.println(c.contains("b"));      //判断是否包含指定元素
		System.out.println(c);//true
		
		System.out.println(c.isEmpty());          //判断集合是否为空
		System.out.println(c);//false
		
		System.out.println(c.size());             //获取元素的个数		
		System.out.println(c);//4
		*/
	}

	public static void demo1() {
		Collection c = new ArrayList();             //父类引用指向子类对象
		boolean b1 = c.add("abc");
		boolean b2 = c.add(true);                    //自动装箱 new Boolean(true)
		boolean b3 = c.add(100);
		boolean b4 = c.add(new Student("张三",23));
		
		System.out.println(b1);//true
		System.out.println(b2);//true
		System.out.println(b3);//true
		System.out.println(b4);//true
		
		System.out.println(c.toString());//[abc, true, 100, Student [name=张三, age=23]]
	}
}

集合转数组遍历

一.集合的遍历

• 其实就是依次获取集合中的每一个元素

二.实现方法

• 把集合转成数组，可以实现集合的遍历
• public Object[] toArray() 方法

案例演示

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

import com.heima.bean.Student;

public class Demo3_Collection {
	@SuppressWarnings({ "rawtypes", "unused", "unchecked" })
	public static void main(String[] args) {
		//demo1();
		Collection c = new ArrayList();
		c.add(new Student("张三",23));//Object obj = new Student("张三",23);父类引用指向子类对象
		c.add(new Student("李四",24));//private void add(Object[] elementData)
		c.add(new Student("王五",25));
		c.add(new Student("赵六",26));
		
		Object[] arr = c.toArray();    //将集合转为数组，此时Student类向上转型为Object，不能调用
		                               //Student类中的属性与行为，需要向下转型
		for (int i = 0; i < arr.length; i++) {
			//System.out.println(arr[i].toString());       //打印name和age两个属性
			Student s = (Student)arr[i];                   //向下转型
			System.out.println(s.getName() + "," + s.getAge());//获得属性值，可以做除了打印的其他事
		}
	}

	public static void demo1() {
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		Object[] arr = c.toArray();
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}	
}

Collection集合的带All功能测试

一.带All的功能演示

• boolean addAll(Collection c)：将c2中每一个元素添加到c1中
• boolean removeAll(Collection c)：删除的是c1与c2的交集
• boolean containsAll(Collection c)：判断调用的集合是否包含传入的集合
• boolean retailAll(Collection c)：取交集赋值给c1，如果c1改变则返回true，如果c1未改变则返回false

案例演示

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

public class Demo4_CollectionAll {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void demo4() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("z");
		
		Collection c3 = new ArrayList();
		c3.add("a");
		c3.add("b");
		c3.add("c");
		c3.add("d");
		c3.add("e");
		c3.add("f");
		
		/*
		 boolean b = c1.retainAll(c2);                  //取交集
		System.out.println(b);//true
		System.out.println(c1);//[a, b]
		*/
		
		boolean b2 = c1.retainAll(c3);                 //取交集赋值给c1，如果c1改变则返回true，
		                                               //如果c1未改变则返回false
		System.out.println(b2);//false
		System.out.println(c1);//[a, b, c, d]
	}
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void demo3() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("b");//可重复
		
		boolean b = c1.containsAll(c2);               //判断调用的集合是否包含传入的集合
		System.out.println(b);//true
	}
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void demo2() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("z");
		
		boolean b = c1.removeAll(c2);                //删除的是c1与c2的交集
		System.out.println(b); //true       
		System.out.println(c1);//[c,d]
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void demo1() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("c");
		c2.add("d");
		
		c1.addAll(c2);                             //将c2中每一个元素添加到c1中
	    c1.add(c2);                                //将c2看成一个对象添加到c1中
		System.out.println(c1);
	}
}

集合的遍历之迭代器遍历

一.迭代器概述

• 集合是用来存储元素的，存储的元素需要查看，那么就需要迭代
• Iterator it = 集合类对象.iterator()：获取迭代器
• 属于java.util包下，使用时需要导包

二.实现所需方法

• boolean hasNext()：判断集合中是否有元素
• E next()：获取集合中的元素

三.迭代器原理

迭代其实对集合进行遍历，而每一个集合内部的存储结构都是不同的，所以每一个集合存和取都是不一样，那么就需要在每一个类中定义hashNext()和next()方法，这样做是可以的，但会让整个集合体系过于臃肿，迭代器是将这样的方法想上抽取出接口，然后在每个类的内部，定义自己的迭代方式，这样做的好处有二，第一：规定了整个几何体系的遍历方式都是hashNext()和next()方法，第二：代码由底层内部实现，使用者不用管怎么实现，会用即可

案例演示

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

import com.heima.bean.Student;

public class Demo5_Iterator {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		//demo1();
		Collection c1 = new ArrayList(); 
		c1.add(new Student("张三",23));              //Object obj = new Student("张三",23);		                                            
		c1.add(new Student("李四",24));              //private void add(Object[] elementData)
		c1.add(new Student("王五",25));
		c1.add(new Student("赵六",26));

		//获取迭代器
		Iterator it = c1.iterator();
		while (it.hasNext()) {
			//System.out.println(it.next());
			Student s = (Student)it.next();         //向下转型
			System.out.println(s.getName() + "..." + s.getAge());
		}
	}
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void demo1() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		//对集合中的元素迭代
		Iterator it = c1.iterator();            //获取迭代器
		while (it.hasNext()) {                  //判断集合中是否有元素
			System.out.println(it.next());      //获取集合中的元素
		}
	}
}

List集合

List集合的基本方法

• void add(int index,E element)：在指定索引添加元素(索引 >= 0 && 索引 <= size)
• E remove(int index)：通过索引删除元素，将被删除的元素返回
• E get(int index)：通过索引获取指定集合元素
• E set(int index,E element)：根据索引修改指定元素

案例演示

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

public class Demo1_List {
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		list.set(1, "z");                      //根据索引修改指定元素
		System.out.println(list);
	}

	public static void demo4() {
		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Object obj1 = list.get(0);             //通过索引获取指定集合元素
		System.out.println(obj1);
		//通过索引遍历List集合
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}

	public static void demo3() {
		List list = new ArrayList<>();
		list.add("111");
		list.add("222");
		list.add("333");
		
		list.remove(111);                      //删除的时候不会自动装箱，把111当成索引
		System.out.println(list);
	}

	public static void demo2() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Object obj = list.remove(1);          //通过索引删除元素，将被删除的元素返回
		System.out.println(obj);//b
		System.out.println(list);//[a, c, d]
	}

	public static void demo1() {
		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(1,"e");                     //在指定索引添加元素(索引 >= 0 && 索引 <= size)
		list.add(10,"e");                    //java.lang.IndexOutOfBoundsException,索引越界异常
		System.out.println(list);
	}
}

List集合存储学生并遍历

一.实现方法

• int size()：获取集合长度
• E get(int index)：获取集合元素

案例演示

import java.util.ArrayList;
import java.util.List;
import com.heima.bean.Student;

public class Demo2_List {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Student("张三",23));        //Object obj = new Student();
		list.add(new Student("李四",24));
		list.add(new Student("王五",25));
		list.add(new Student("赵六",26));
		
		for (int i = 0; i < list.size(); i++) {
			Student s = (Student)list.get(i);
			System.out.println(s.getName() + "..." + s.getAge());
		}
	}
}

并发修改异常

一.ConcurrentModifcationException的出现

• 迭代器遍历，使用集合方法修改集合

二.解决方案

• 迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
• 集合遍历元素，集合修改元素

案例演示

需求：有一个集合，请问：我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素

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

public class Demo3_List {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");                          //Object obj = new String();
		list.add("b");
		list.add("world");
		list.add("c");
		list.add("d");
		list.add("e");
		
		/*Iterator it = list.iterator();       //获取迭代器
		while (it.hasNext()) {
			String str = (String)it.next();    //向下转型
			if ("world".equals(str)) {
				list.add("javaee");            //便利的同时在增加元素，并发修改
			}
		}*/
		
		ListIterator lit = list.listIterator();//获取迭代器
		while (lit.hasNext()) {
			String str = (String)lit.next();  //向下转型
			if ("world".equals(str)) {
				lit.add("javaee");            //迭代器修改元素
			}
		}
		System.out.println(list);//[a, b, world, javaee, c, d, e]
	}
}

ListIterator的基本方法

• boolean hasNext()：判断是否有下一个
• boolean hasPrevious()：判断是否有前一个
• Object next()：返回下一个元素
• Object previous()：返回上一个元素

案例演示

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

public class Demo4_ListIterator {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");                             //Object obj = new String();
		list.add("b");
		list.add("world");
		list.add("c");
		list.add("d");
		list.add("e");
		
		ListIterator lit = list.listIterator();    //获取迭代器
		while (lit.hasNext()) {                    //判断下一个
			System.out.println(lit.next());        //获取元素并将指针向后移动
		}
		
		while (lit.hasPrevious()) {                //判断前一个
			System.out.println(lit.previous());    //获取元素并将指针向前移动
		}
	}
	
}

Vector

一.Vector类的概述

二.Vector类的特有功能

• public void addElement(E obj)：添加元素
• public E elementAt(int index)：
• public Enumeration elements()：获取枚举

案例演示

Vector的迭代：

import java.util.Enumeration;
import java.util.Vector;

public class Demo5_Vector {
	public static void main(String[] args) {
		Vector v = new Vector();
		v.addElement("a");
		v.addElement("b");
		v.addElement("c");
		v.addElement("d");
		
		Enumeration en = v.elements();               //获取枚举
		while (en.hasMoreElements()) {               //判断集合中是否有元素
			System.out.println(en.nextElement());    //获取集合中的元素
		}
	}

}

LinkedList