Java集合--Collection

概述

集合特点：
1、用于存储对象的容器
2、集合的长度是可变的
3、集合中不可以存储基本数据类型
集合容器因为内部的数据结构不同，有多种具体容器，不断给的向上抽取，就形成了集合框架。
注意：
数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。
集合框架的构成及分类

Collection接口

整个集合体系的顶层Collection接口
Collection的常见方法：
1、添加
add(e); (add方法的参数类型是Object。以便于接收任意类型对象。)
addAll(collection);
2、删除
remove(e);
removeAll(collection);
clear();
3、判断。
contains(e);
isEmpty();
4、获取
iterator(); 迭代器，集合的取出元素的方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。
size();
5、获取交集。
retainAll();
6、集合变数组。
toArray();

import java.util.*;
class CollectionDemo {

	public static void main(String[] args) {
		
//		method_add();
		method_ret();
		method_ite();
		
	}
	
	public static void method_ite() {
		
		ArrayList al = new ArrayList();
		
		al.add("Java 01");
		al.add("Java 02");
		al.add("Java 03");
		al.add("Java 04");
		
		//使用迭代器获取集合中元素
		Iterator it = al.iterator();     
		while(it.hasNext()) {
												
			sop(it.next());                  
		}
	
	/*  
	 迭代器可以用for循环来表示
	 for(Iterator it = al.iterator() ; it.hasNext(); ) {
		 sop(it.next());
		} */
	}
	
	public static void method_ret() {
		
		ArrayList al1 = new ArrayList();
		
		al1.add("Java 01");
		al1.add("Java 02");
		al1.add("Java 03");
		al1.add("Java 04");
		
		ArrayList al2 = new ArrayList();
		
		al2.add("Java 01");
		al2.add("Java 02");
		al2.add("Java 05");
		al2.add("Java 06");
		
		//al1.retainAll(al2);  //取交集，al1中只会保留和al2中相同的元素
		al1.addAll(al2);
		
		sop(al1);
		sop(al2);
		
	}
	
	public static void method_add() {
		
		ArrayList al = new ArrayList();
		
	    //  添加元素
		al.add("Java 01");
		al.add("Java 02");
		al.add("Java 03");
		al.add("Java 04");
		
		sop(al);
		
		al.remove("Java 04");  //删除元素，(al.clear())清空集合
		
		sop(al);
		
		sop(al.contains("Java 04"));  //判断元素是否存在
		sop(al.size());
		
		
	}
	
	public static void sop(Object obj) {
		
		System.out.println(obj);
		
	}

}

List

Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

List：特有方法，凡是可以操作角标的方法都是该体系特有的方法。

1、添加

add(index,element);
addAll(index,Collection);

2、删除

        remove(index);

3、修改

        set(index,element);

4、获取

        get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();

import java.util.*;

class Demo1List {
	
	public static void sop(Object obj) {
		
		System.out.println(obj);
		
	}

	public static void main(String[] args) {

                method_1();
		sop("--------------------------------");
		
		method_2();

	}
	
	public static void method_1() {
		
		ArrayList al = new ArrayList();
		
		al.add("Java 01");
		al.add("Java 02");
		al.add("Java 03");
		
		al.add(3,"Java 04");  //在指定位置添加元素。
		sop(al);
		
		al.remove(3);  删除指定位置的元素。
		sop(al);
		
		al.set(2, "Java 01");  //修改元素。
		sop(al);
		
		sop(al.get(0));  //通过角标获取元素。
		sop(al.indexOf("Java 01"));
		sop(al.subList(0,2));  //获取子集
		
                //list特有取出元素的方式
		for(int x = 0; x < al.size() ; x++) {
			sop(al.get(x));
		}
		
	}
	
	public static void method_2() {
		
		ArrayList al = new ArrayList();
		
		al.add("Java 01");
		al.add("Java 02");
		al.add("Java 03");
		
		ListIterator it = al.listIterator();
		
		while(it.hasNext()) {
			
			Object obj = it.next();
			
			if(obj.equals("Java 02"))
				it.remove();	  //将java02的引用从集合中删除了。
			
			sop(obj);
		}
		it.add("Java 04");
		
		sop(it.hasNext());
		sop(it.hasPrevious());  
	//反向获取集合里的元素	
	while(it.hasPrevious()) {
                sop(it.previous());
        }
        sop(al);
     }
  }

注意：

ist集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以，在迭代器时，只能用迭代器的放过操作元素，可Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

Vector、ArrayList、LinkedList

|--List:
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

Vector

Vector特有的取出方式:枚举

枚举和迭代器很像，其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

import java.util.*;

class Demo2Vector {

	public static void main(String[] args) {
		
		Vector v = new Vector();
		
		v.add("Java 01");
		v.add("Java 02");
		v.add("Java 03");
		v.add("Java 04");
		
                //类似于迭代器
		Enumeration e = v.elements();
		
		while(e.hasMoreElements())
			System.out.println(e.nextElement());

	}

}

LinkedList

LinkedList:特有方法：
addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

import java.util.*;

class Demo3LinkedList {

	public static void main(String[] args) {
		
		LinkedList link = new LinkedList();
		
                //添加元素至最前面
		link.addFirst("Java 01");  //offerFirst()
		link.addFirst("Java 02");
		link.addFirst("Java 03");
		link.addFirst("Java 04");
		link.add(0, "Java 00");
		
		sop(link);
		sop(link.getFirst());  //peekFirst()  //获取第一个元素，但不删除
		sop(link.removeFirst());  //pollFirst()  //获取第一元素，会删除
		sop(link.size());
		
                //LinkedList特有的获取元素的操作
		while(!link.isEmpty())
			sop(link.removeFirst());
		

	}
	
	public static void sop(Object obj) {
		
		System.out.println(obj);
		
	}

}

在JDK1.6出现了替代方法。
offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

使用LinkedList模拟一个堆栈或者队列数据结构（堆栈：先进后出  如同一个杯子，队列：先进先出 First in First out  FIFO 如同一个水管。）

import java.util.*;


//把方法定义到一个类里面，以便不同的调用者，都能够调用
class Queue {
	
	private LinkedList link;
	
	Queue() {
		
		link = new LinkedList();
	
	}
	
	public void myAdd(Object obj) {  //定义一个方法，添加元素至末尾
		
		link.offerLast(obj);
		
	}
	
	public Object myGet() {  //定义一个方法，获取最前面的元素
		
		return link.pollFirst();
		
	}
	
	public boolean myIf() {  //定义一个方法，判断集合是否为空
		
		return link.isEmpty();
	}
	
}

class Test1LinkedList {

	public static void main(String[] args) {
		
		Queue ueue = new Queue();

		ueue.myAdd("Java 01");
		ueue.myAdd("Java 02");
		ueue.myAdd("Java 03");
		ueue.myAdd("Java 04");
		
		while(!ueue.myIf()) {
			
			System.out.println(ueue.myGet());
			
		}
		
	}

}

ArrayList

去除ArrayList集合中的重复元素：

import java.util.*;

class Test2ArrayList {

	public static void main(String[] args) {
		
		ArrayList al = new ArrayList();
		
		al.add("Java 01");
		al.add("Java 02");
		al.add("Java 03");
		al.add("Java 01");
		al.add("Java 03");
		al.add("Java 04");
		
		al = singleElement(al);  //调用去除重复数组的方法
		
		System.out.println(al);

	}
	
	public static ArrayList singleElement(ArrayList al) {
		
		ArrayList newal = new ArrayList();  //定义一个临时容器，用来存储不不重复的元素
		
		//遍历数组
		Iterator it = al.iterator();
		
		while(it.hasNext()) {
			
			Object obj = it.next();
			
			if(!newal.contains(obj)) {  //判断临时数组里面有没有与原数组相同的元素
				
				newal.add(obj);
			}
		}
		
		return newal;
		
	}

}

将自定义对象作为元素存到ArrayList集合中，并去除重复元素

思路：
1、对人描述，将数据封装进人对象。
2、定义容器，将人存入。
3、取出。

import java.util.*;
class Test3ArrayList {

	public static void main(String[] args) {
		
		ArrayList<Person> arr = new ArrayList<Person>();
		
		arr.add(new Person("Jack",20));
		arr.add(new Person("Luck",30));
		arr.add(new Person("Moli",20));
		arr.add(new Person("Paul",25));
		arr.add(new Person("Luck",30));
		
		arr = singleElement(arr);
		
		Iterator<Person> it = arr.iterator();
		
            //获取集合里面每一个对象
		while(it.hasNext()) {
			
			Person p = it.next();
			
			System.out.println(p.getName()+","+p.getAge());
		
		} 

	}
	
	public static ArrayList<Person> singleElement(ArrayList<Person> arr) {
		
		ArrayList<Person> newArr = new ArrayList<Person>();
		
		Iterator<Person> it = arr.iterator();
		
		while(it.hasNext()) {
			
			Person p = it.next();  //使用了泛型，因此不用向下转型
			if(!newArr.contains(p)) {  //contains底层用的是equals，所以要复写equals方法
				
				newArr.add(p);
				
			}
			
		}
		
		return newArr;
		
	}

}

class Person {
	
	private String name;
	private int age;
	
	Person(String name,int age) {
		
		this.name = name;
		this.age = age;
		
	}
	
	public String getName() {
		
		return name;
	}
	public int getAge() {
		
		return age;
	}
	
	public boolean equals(Object obj) {
		
		if(!(obj instanceof Person))  //判断对象的类型
			throw new RuntimeException();
		
		Person p = (Person)obj;  //向下转型
		
		return this.name.equals(p.name)&&this.age == p.age;   //这里的equals方法调用的是字符串的
		
	}
}

HashSet、TreeSet

HashSet

Set:无序，不可以重复元素。
|--HashSet：数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。

import java.util.*;

class Demo1HashSet {

	public static void main(String[] args) {
		
		HashSet hs = new HashSet();
		
		System.out.println(hs.add("Java 01"));  //添加成功返回true
		System.out.println(hs.add("Java 01"));   //有相同元素，添加失败，返回false
		hs.add("Java 02");
		hs.add("Java 03");
		hs.add("Java 03");
		hs.add("Java 04");
		
		Iterator it = hs.iterator();
		
		while(it.hasNext())
			System.out.println(it.next());

	}

}

往HashSet集合中存入自定义对象，姓名和年龄相同为同一个人，重复元素

思路：

1、定义一个类，用来描述人，并且类里面重写equals，hashCode方法

2、定义一个集合，将人存入

2、取出

import java.util.*;
class Demo2HashSet {

	public static void main(String[] args) {
		
		HashSet<Persons> hs = new HashSet<Persons>();
		
		//添加元素
		hs.add(new Persons("Jack",20));
		hs.add(new Persons("Luck",30));
		hs.add(new Persons("Moli",20));
		hs.add(new Persons("Paul",25));
		hs.add(new Persons("Luck",30));
		
		//获取对象
		Iterator<Persons> it = hs.iterator();
		
		while(it.hasNext()) {
			
			Persons p = it.next();
			
			System.out.println(p.getName()+","+p.getAge());
		
		}

	}

}

class Persons {
	
	private String name;
	private int age;
	
	Persons(String name,int age) {
		
		this.name =name;
		this.age = age;
		
	}
	
	public String getName() {
		
		return name;
		
	}
	public int getAge() {
		
		return age;
		
	}
	
	public int hashCode() {
		
		return name.hashCode(); //字符串中有hashCode()方法
		
	}
	
	//重写equals方法
	public boolean equals(Object obj) {
		
		if(!(obj instanceof Persons))
			throw new RuntimeException();
		
		Persons p = (Persons)obj;
		
		return this.name.equals(p.name)&&this.age == p.age;  //调用的字符串 equals方法
		
	}
	
}

TreeSet

|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.
TreeSet排序的第一种方式：

               让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。

往TreeSet集合中存储自定义对象学生，按照学生的年龄进行排序。

import java.util.*;

class Demo3TreeSet {

	public static void main(String[] args) {
		
		TreeSet<Student> ts = new TreeSet<Student> ();
		
		ts.add(new Student("Jack",20));
		ts.add(new Student("Luck",30));
		ts.add(new Student("Moli",20));
		ts.add(new Student("Paul",25));
		ts.add(new Student("Luck",30));
		
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
		
		

	}

}

class Student implements Comparable<Object> { //实现该接口，强制让学生具有比较性
	
	private String name;
	private int age;
	
	Student(String name,int age) {
		
		this.name =name;
		this.age = age;
		
	}
	
	public String getName() {
		
		return name;
		
	}
	public int getAge() {
		
		return age;
		
	}
	
	
	//重写compareTo方法
	public int compareTo(Object obj) {
		
		if(!(obj instanceof Student))  //判断类型
			throw new RuntimeException();
		
		Student s = (Student)obj;
		
		if(this.age > s.age)
			return 1;
		
		//当年龄相同时，再判断名字即可，字符串已经具有compareTo（）方法
		if(this.age == s.age)  
			return this.name.compareTo(s.name);
		
		return -1;
		
	}
	
}

TreeSet的第二种排序方式。

              当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

往TreeSet集合中存储自定义对象学生，按照学生的姓名进行排序。

import java.util.*;

class Demo4TreeSet {

	public static void main(String[] args) {
		
		TreeSet<Student> ts = new TreeSet<Student> ();
		
		ts.add(new Student("Jack",20));
		ts.add(new Student("Luck",30));
		ts.add(new Student("Moli",20));
		ts.add(new Student("Paul",25));
		ts.add(new Student("Luck",30));
		
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}

	}

}

class ComparatorByName implements Comparator<Object> {
	
	public int compare(Object o1,Object o2) {  //比较器要传入两个 对象进来比较
		
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		
		 int num = s1.getName().compareTo(s2.getName());  //比较两者的名字，如果相同则返回0
		
		if(num == 0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  //基本数据类型中也已经具备了compareTo（）方法
		
		return num;
	}
	
}

二叉树示意图：