JavaSe——集合

A.对象数组

学生类：

package com.core.collection;

/**
 * @author Administration
 * 
 */
public class Student {
	private String name;
	private int age;

	public Student() {
	}

	public Student(String name, int age) {
		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;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

}

测试类：

package com.core.collection;

public class Test {
	public static void main(String[] args) {
		// 我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
		Student[] ss = new Student[5];
		ss[0] = new Student("张三", 12);
		ss[1] = new Student("李四", 13);
		ss[2] = new Student("王五", 14);
		ss[3] = new Student("赵六", 17);
		ss[4] = new Student("小马", 14);
		//遍历
		for (int i = 0; i < ss.length; i++) {
			System.out.println(ss[i]);
		}
	}
}

B.集合框架

l  为什么出现集合类？

•    面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

l  数组和集合类同是容器，有何不同？

•    数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

l  集合类的特点

•    集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

集合的继承体系图解

C.Collection集合框架

/*

 * 集合的由来：

 *      我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。

 *      而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?

 *      数组和StringBuffer。但是呢?StringBuffer的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。

 *      而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用。

 *

 * 数组和集合的区别?

 *      A:长度区别

 *          数组的长度固定

 *          集合长度可变

 *      B:内容不同

 *          数组存储的是同一种类型的元素

 *          而集合可以存储不同类型的元素

 *      C:元素的数据类型问题

 *          数组可以存储基本数据类型，也可以存储引用数据类型

 *          集合只能存储引用类型

 *

 * 刚说过集合是存储多个元的，但是呢，存储多个元素我们也是有不同需求的：比如说，我要这多个元素中不能有相同的元素，

 * 再比如说，我要这多个元素按照某种规则排序一下。针对不同的需求，Java就提供了不同的集合类，这样呢，Java就提供了很多个集合类。

 * 这多个集合类的数据结构不同,结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说判断，获取等。

 * 既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。

 *

 * 数据结构：数据的存储方式。

 *

 * Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)

 *

 * Collection的功能概述：

 * 1：添加功能

 *      booleanadd(Object obj):添加一个元素

 *      booleanaddAll(Collection c):添加一个集合的元素

 * 2:删除功能

 *      voidclear():移除所有元素

 *      booleanremove(Object o):移除一个元素

 *      booleanremoveAll(Collection c):移除一个集合的元素(是一个还是所有)

 * 3:判断功能

 *      booleancontains(Object o)：判断集合中是否包含指定的元素

 *      booleancontainsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)

 *      booleanisEmpty()：判断集合是否为空

 * 4:获取功能

 *      Iterator<E>iterator()(重点)

 * 5:长度功能

 *      intsize():元素的个数

 *      面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?

 * 6:交集功能

 *      booleanretainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

 * 7：把集合转换为数组

 *      Object[]toArray()

 */

Collection的基本功能：

package com.core.collection.demo1;

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

public class Test {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("world");
		c.add("java");
		c.add("hello");
		System.out.println(c);//[hello, world, java, hello]
		
		c.remove("hello");
		System.out.println(c);//[world, java, hello]
		c.remove("world");
		System.out.println(c);//[java, hello]
		
		System.out.println(c.contains("java"));//true
		System.out.println(c.contains("android"));//false
		
		System.out.println(c.isEmpty());//false
		c.clear();//清除所有元素
		System.out.println(c);//[]
		System.out.println(c.isEmpty());//true
		
	}

}

Collection的高级功能：

package com.core.collection.demo1;

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

public class Test {

	public static void main(String[] args) {
		Collection c1 = new ArrayList();
		c1.add("hello");
		c1.add("world");
		c1.add("java");
		System.out.println(c1);//[hello, world, java]
		
		Collection c2 = new ArrayList();
		c2.add("11");
		c2.add("22");
		c2.add("33");
		System.out.println(c2);//[11, 22, 33]
		c1.addAll(c2);
		System.out.println(c1);//[hello, world, java, 11, 22, 33]
		
		c1.removeAll(c2);
		System.out.println(c1);//[hello, world, java]
		
		Collection c3 = new ArrayList();
		c3.add("hello");
		c3.add("android");
		c1.removeAll(c3);
		System.out.println(c1);//[world, java]
		
		Collection c4 = new ArrayList();
		c4.add("world");
		c4.add("other");
		c4.add("math");
		System.out.println(c1.containsAll(c4));//false
		
		Collection c5 = new ArrayList();
		c5.add("world");
		System.out.println(c1.containsAll(c5));//true,只有包含所有的元素，才叫包含
		
		Collection c6 = new ArrayList();
		c6.add("11");
		c6.add("22");
		c6.add("33");
		Collection c7 = new ArrayList();
		c7.add("22");
		c7.add("44");
		System.out.println(c6.retainAll(c7));//true
		System.out.println(c6);//[22]
		System.out.println(c7);//[22, 44]
		//boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
		//假设有两个集合A，B。
		//A对B做交集，最终的结果保存在A中，B不变。
		//返回值表示的是A是否发生过改变。

	}

}

D.Collection集合遍历-数组

l  Object[] toArray()

•    把集合转成数组，可以实现集合的遍历

Iteratoriterator()

•    迭代器，集合的专用遍历方式

1.存储String对象并遍历-使用数组

package com.core.collection.demo3;

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

public class Test {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("world");
		c.add("java");
		c.add("hello");

		//集合遍历，方法1.把集合转成数组
		Object[] array = c.toArray();
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
//		hello
//		world
//		java
//		hello

	}

}

2.存储自定义对象并遍历-使用数组

package com.core.collection.demo4;

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

public class Test {

	public static void main(String[] args) {
		//创建三个学生
		Student s1 = new Student("张三",23);
		Student s2 = new Student("李四",12);
		Student s3 = new Student("王五",34);
		
		Collection c = new ArrayList();
		c.add(s1);
		c.add(s2);
		c.add(s3);
		
		//遍历-数组方式
		Object[] array = c.toArray();
		for (int i = 0; i < array.length; i++) {
			Student s = (Student) array[i];
			System.out.println(s.getName()+"--"+s.getAge());
		}
	}

}

E.Collection集合遍历-迭代器

package com.core.collection.demo5;

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

public class Test {

	public static void main(String[] args) {
		//存储并遍历String对象
		Collection c1 = new ArrayList();
		c1.add("hello");
		c1.add("world");
		c1.add("java");
		//使用迭代器来遍历集合
		Iterator iterator = c1.iterator();
		while (iterator.hasNext()) {
			String next = (String) iterator.next();
			System.out.println(next);
		}
		System.out.println("-----");
		//存储并遍历自定义对象
		Student s1 = new Student("张三",23);
		Student s2 = new Student("李四",12);
		Student s3 = new Student("王五",34);
		
		Collection c2 = new ArrayList();
		c2.add(s1);
		c2.add(s2);
		c2.add(s3);
		
		//遍历-迭代器
		Iterator iterator2 = c2.iterator();
		while (iterator2.hasNext()) {
			Student s = (Student) iterator2.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
	}

}

for循环改进，可以提高效率

package com.core.collection.demo5;

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

public class Test {

	public static void main(String[] args) {
		//存储并遍历String对象
		Collection c1 = new ArrayList();
		c1.add("hello");
		c1.add("world");
		c1.add("java");
		//使用迭代器来遍历集合
		Iterator iterator = c1.iterator();
		while (iterator.hasNext()) {
			String next = (String) iterator.next();
			System.out.println(next);
		}
		System.out.println("-----");
		//存储并遍历自定义对象
		Student s1 = new Student("张三",23);
		Student s2 = new Student("李四",12);
		Student s3 = new Student("王五",34);
		
		Collection c2 = new ArrayList();
		c2.add(s1);
		c2.add(s2);
		c2.add(s3);
		
		//遍历-迭代器
		Iterator iterator2 = c2.iterator();
		while (iterator2.hasNext()) {
			Student s = (Student) iterator2.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		//For循环改进，效率高
		for (Iterator iterator3 = c2.iterator();iterator3.hasNext();) {
			Student s = (Student) iterator3.next();
			System.out.println(s.getName()+"**"+s.getAge());
		}
		
	}

}

F.迭代器原理

public interface Inteator {

    boolean hasNext();

    Object next();

}

 

public interface Iterable {

    Iterator iterator();

}

 

public interface Collection extends Iterable {

    Iterator iterator();

}

 

public interface List extends Collection {

    Iterator iterator();

}

 

public class ArrayList implements List {

    public Iteratoriterator() {

        return new Itr();

    }

   

    private class Itr implementsIterator {

        public boolean hasNext() {}

       public Object next(){}

    }

}

 

 

Collection c = new ArrayList();

c.add("hello");

c.add("world");

c.add("java");

Iterator it = c.iterator(); //new Itr();

while(it.hasNext()) {

    String s = (String)it.next();

    System.out.println(s);

}

G.List集合存储和遍历

List集合的存储和遍历和Collection差不多。

特点：

l  List接口概述

•    有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

•    与 set 不同，列表通常允许重复的元素。

H.List集合特有功能

package com.core.collection.demo6;

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

public class Test {

	// List特有功能

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");
		System.out.println(list);//[hello, world, java]
		
		list.add(1, "android");
		System.out.println(list);//[hello, adroid, world, java]
		
//		list.add(5,"xixi");//错误java.lang.IndexOutOfBoundsException:
//		System.out.println(list);
		Object obj = list.get(2);
		System.out.println(obj);//world
		
		Object obj2 = list.remove(2);
		System.out.println("移除的元素："+obj2+",list:"+list);//移除的元素：world,list:[hello, android, java]
		
		/*
		 * List集合的特有遍历功能：
		 * 		size()和get()方法结合使用
		 */

		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			System.out.println(s);//hello android java
		}

	}

}

List集合特有的迭代器——列表迭代器

package com.core.collection.demo7;

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

public class Test {

	// List特有功能

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");
		System.out.println(list);//[hello, world, java]
		Iterator iterator = list.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println("----List集合特有迭代器ListIterator---");
		
		ListIterator iterator2 = list.listIterator();
		while (iterator2.hasNext()) {
			System.out.println(iterator2.next());
		}
		System.out.println("***");
		while (iterator2.hasPrevious()) {
			System.out.println(iterator2.previous());
		}

	}

}

I.并发修改异常的产生原因及解决方案

package com.core.collection.demo8;

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

public class Test {

	// List特有功能

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");
		System.out.println(list);// [hello, world, java]
		Iterator iterator = list.iterator();
		// while(iterator.hasNext()){
		// String next = (String) iterator.next();
		// if("world".equals(next)){
		// list.add("android");//报错，java.util.ConcurrentModificationException
		// }
		// }
		// 解决方案：
		// A.迭代器遍历元素，迭代器修改元素
		// B.集合遍历元素，集合修改元素
		// 迭代器
		while (iterator.hasNext()) {
			String next = (String) iterator.next();
			if ("world".equals(next)) {
				//list.add("android");// 报错，java.util.ConcurrentModificationException
			}
		}
		ListIterator iterator2 = list.listIterator();
		while (iterator2.hasNext()) {
			String next = (String) iterator2.next();
			if ("world".equals(next)) {
				iterator2.add("android");
			}
		}
		System.out.println(list);//[hello, world, android, java]
		System.out.println("---------");
		for (int i = 0; i < list.size(); i++) {
			String next = (String) list.get(i);
			if ("world".equals(next)) {
				list.add("C++");
			}
		}
		System.out.println(list);//[hello, world, android, java, C++]
	}

}

J.List三个子类的特点

l  ArrayList类概述

•    底层数据结构是数组，查询快，增删慢

•    线程不安全，效率高

l  ArrayList案例

•    存储字符串并遍历

•    存储自定义对象并遍历

 

l  Vector类概述

•    底层数据结构是数组，查询快，增删慢

•    线程安全，效率低

l  Vector类特有功能

•    public void addElement(E obj)

•    public E elementAt(int index)

•    public Enumeration elements()

l  Vector案例

•    存储字符串并遍历

•    存储自定义对象并遍历

l  LinkedList类概述

•    底层数据结构是链表，查询慢，增删快

•    线程不安全，效率高

l  LinkedList类特有功能

•    public void addFirst(E e)及addLast(E e)

•    public E getFirst()及getLast()

•    public E removeFirst()及public E removeLast()

l  LinkedList案例

•    存储字符串并遍历

•    存储自定义对象并遍历

K.Vector特有功能

l  Vector类概述

•    底层数据结构是数组，查询快，增删慢

•    线程安全，效率低

l  Vector类特有功能

•    public void addElement(E obj)

•    public E elementAt(int index)

•    public Enumeration elements()

package com.core.collection.demo9;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

public class Test {

	// Vector特有功能

	public static void main(String[] args) {
		Vector v = new Vector();
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");
		
		//变量
		for (int i = 0; i < v.size(); i++) {
			String next = (String) v.elementAt(i);
			System.out.println(next);
		}
		System.out.println("-------");
		Enumeration en = v.elements();
		while(en.hasMoreElements()){
			String next = (String) en.nextElement();
			System.out.println(next);
		}
	}

}

L.LinkedList的特有功能

l  LinkedList类概述

•    底层数据结构是链表，查询慢，增删快

•    线程不安全，效率高

l  LinkedList类特有功能

•    public void addFirst(E e)及addLast(E e)

•    public E getFirst()及getLast()

•    public E removeFirst()及public E removeLast()

l  LinkedList案例

•    存储字符串并遍历

•    存储自定义对象并遍历

package com.core.collection.demo10;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

public class Test {

	// LinkedList特有功能

	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("hello");
		list.add("world");
		list.add("java");
		System.out.println(list);//[hello, world, java]
		
		list.addFirst("begin");
		list.addLast("end");
		System.out.println(list);//[begin, hello, world, java, end]
		
		String first = (String) list.removeFirst();
		System.out.println(list+","+first);//[hello, world, java, end],begin
		String last = (String) list.removeLast();
		System.out.println(list+","+last);//[hello, world, java],end
	}

}

M.ArrayList集合去除重复元素

l  ArrayList

•    去除集合中字符串的重复值(字符串的内容相同)

•    去除集合中自定义对象的重复值(对象的成员变量值都相同)

去除相同字符串

package com.core.collection.demo9;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

public class Test2 {

	// ArrayList
	// 去除集合中字符串的重复值(字符串的内容相同)
	// 去除集合中自定义对象的重复值(对象的成员变量值都相同)

	public static void main(String[] args) {
		ArrayList list1 = new ArrayList();
		list1.add("hello");
		list1.add("world");
		list1.add("java");
		list1.add("android");
		list1.add("hello");
		list1.add("java");
		System.out.println(list1);// [hello, world, java, android, hello, java]
		// 去重复
		ArrayList list2 = new ArrayList();
		// 遍历list1，判断
		for (int i = 0; i < list1.size(); i++) {
			String next = (String) list1.get(i);
			if(!list2.contains(next)){
				list2.add(next);
			}
		}
		System.out.println(list2);//[hello, world, java, android]
		//遍历集合list2
		Iterator iterator = list2.iterator();
		while(iterator.hasNext()){
			String next = (String) iterator.next();
			System.out.println(next);
		}
	}

}

去除相同对象

Student类：

package com.core.collection.demo9;

/**
 * @author Administration
 * 
 */
public class Student {
	private String name;
	private int age;

	public Student() {
	}

	public Student(String name, int age) {
		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;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}


	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

测试类：

package com.core.collection.demo9;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

public class Test3 {

	// ArrayList
	// 去除集合中自定义对象的重复值(对象的成员变量值都相同)

	public static void main(String[] args) {
		ArrayList list1 = new ArrayList();
		Student s1 = new Student("张三", 16);
		Student s2 = new Student("李四", 17);
		Student s3 = new Student("王五", 18);
		Student s4 = new Student("张三", 19);
		Student s5 = new Student("李四", 17);
		list1.add(s1);
		list1.add(s2);
		list1.add(s3);
		list1.add(s4);
		list1.add(s5);
		System.out.println(list1);
		
		ArrayList list2 = new ArrayList();
		for (int i = 0; i < list1.size(); i++) {
			Student s = (Student) list1.get(i);
			if(!list2.contains(s)){
				list2.add(s);
			}
		}
		
		//遍历输出list2
		
		for (Iterator iterator = list2.iterator(); iterator.hasNext(); ) {
			Student s = (Student) iterator.next();
			System.out.println(s);
		}
		// Student [name=张三, age=16]
		// Student [name=李四, age=17]
		// Student [name=王五, age=18]
		// Student [name=张三, age=19]
	}

}