黑马程序员---Java基础---单列集合Collection(接口)

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

一.Collection(接口):

1.Collection 接口概述：

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。

2.基本方法：

boolean add(Object e)：向集合中添加一个元素

boolean remove(Object o):从集合中移除一个元素

void clear()：清空集合

boolean contains(Object o)：判断集合中是否包含参数对象

boolean isEmpty()：判断集合是否为空

int size()：获取集合内元素的数量

package cn.hebei.sjz_Collection;

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

/*
 * Collection(接口)的成员方法
 */
public class Demo3 {
	public static void main(String[] args) {
		Collection list = new ArrayList();
		// 向集合中添加元素
		list.add("qwe");
		list.add(123);
		list.add('a');
		list.add(2.3);

		System.out.println(list);// [qwe,123,a,2.3]
		// 移除存在的元素
		System.out.println(list.remove(2.3));// true
		// 移除不存在的元素
		System.out.println(list.remove(2));// false
		System.out.println(list);// [qwe,123,a]
		// 判断是否包含元素
		System.out.println(list.contains(123));// true
		// 集合的元素数量
		System.out.println(list.size());// 3
		// 判断集合是否为空
		System.out.println(list.isEmpty());// false
		// 清空集合
		list.clear();
		System.out.println(list);//[]
		System.out.println(list.isEmpty());true
	}
}

3.批量的方法：

boolean addAll(Collection c)：将参数集合加入到当前集合中；

boolean removeAll(Collection c):移除此 collection 中那些也包含在指定 collection 中的所有元素

boolean containsAll(Collection c)：如果此 collection 包含指定 collection 中的所有元素，则返回 true。

boolean retainAll(Collection c):移除此 collection 中未包含在指定 collection 中的所有元素。 

package cn.hebei.sjz_Collection;

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

/*
 * Collection(接口)的批量方法
 */
public class Demo4 {
	public static void main(String[] args) {
		Collection list = new ArrayList();
		list.add(123);
		list.add("qwe");
		list.add('a');
		list.add(2.3);

		Collection list1 = new ArrayList();
		list1.add(123);
		list1.add("qwe");
		list1.add(2.3);
		// 批量添加元素
		//list.addAll(list1);
		//System.out.println(list);//[123,qwe,a,2.3,123,qwe,2.3]
		// 判断list集合是否包含list1集合
		System.out.println(list.containsAll(list1));//true
		// 移除未包含在list1的元素
		//list.retainAll(list1);
		//System.out.println(list);//[123,qwe,2.3]
		// 在list集合中移除list1的元素
		System.out.println(list.removeAll(list1));//true
		list.removeAll(list1);
		System.out.println(list);//[a]
	}
}

4.遍历的方法：

1.Object[] toArray();

2.Iterator iterator();迭代器

package cn.hebei.sjz_Collection;

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

/*
 * Collection 遍历
 * 方法：  1、Object[] toArray();
 * 		2、Iterator  迭代器
 */
public class Demo1 {
	public static void main(String[] args) {
		Collection list = new ArrayList();
		list.add("刘德华");
		list.add("张学友");
		list.add(2.3);
		list.add(2);

		// 遍历1 Object[] toArray();
		Object[] objArray = list.toArray();
		for (int i = 0; i < objArray.length; i++) {
			System.out.println(objArray[i]);
		}
		System.out.println("...............");
		
		// 遍历2 Iterator迭代器
		Iterator it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

二.List(接口):

1.新增的方法：

void add(int index,Object element):将element添加到index位置，原index位置上的元素，及后续元素全部后移；

Object remove(int index)：移除index位置上的元素；

Object get(int index):获取index位置上的元素；

Object set(int index,Object element):将index位置上的元素替换为参数的element元素

2.遍历的方法：

1.ListIterator listIterator()：列表迭代器

2.结合Collection的size()，和本接口的get(int index)方法，可以使用for循环遍历；

package cn.hebei.sjz_List;

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

/*
 *  List的特有功能：

 */
public class Demo {
	public static void main(String[] args) {
		// 实例化一个List集合
		List list = new ArrayList();
		// 添加元素
		list.add("xule");
		list.add(2);
		// 在索引位置处添加元素，原位置的元素及后续元素后移
		list.add(1, "zhao");
		System.out.println(list);// [xule,zhao,2]
		// 移除指定索引的元素
		list.remove(0);
		System.out.println(list);// [zhao,2]
		// 获取指定索引的元素
		System.out.println(list.get(1));// 2
		// 替换指定索引位置的元素
		list.set(0, "xiajia");
		System.out.println(list);// [xiajia,2]

		// 遍历 方式一： ListIterator
		ListIterator listIt = list.listIterator();
		while (listIt.hasNext()) {
			System.out.print(listIt.next());// xiajia2
		}

		// 遍历 方式二：结合Collection的size()，和本接口的get(int index)方法，可以使用for循环遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i));// xiajia2
		}

	}
}

3、List三个子类的特点：

ArrayList(类):数组实现；线程不安全的(不同步的)，效率高；

无特有成员，全部使用父类的

Vector(类):数组实现；线程安全的(同步的)，效率低；

特有成员：

public void addElement(Object obj):将元素obj添加到集合；

public Object elementAt(int index)：获取index位置上的元素；

package cn.hebei.sjz_Vector特有成员;

import java.util.Vector;

/*
 * Vector 特有成员
 */
public class Demo {
	public static void main(String[] args) {
		// 定义一个集合
		Vector vec = new Vector();

		// 填充集合
		vec.add("aaa");
		vec.add("ddd");
		// vector特有的添加元素方法
		vec.addElement("bbb");
		vec.addElement("ccc");
		// 获取指定索引位置的元素
		System.out.println(vec.get(1));// ddd
		System.out.println(vec.elementAt(1));// ddd
		System.out.println(vec);// [aaa,ddd,bbb,ccc]
	}
}

LinkedList(类):链表实现；线程不安全的(不同步的)，效率高；

特有成员：

public void addFirst(E e)及addLast(E e)  压栈

public E getFirst()及getLast()    获取第一个元素，获取第二个元素

public E removeFirst()及public E removeLast()    移除第一个元素，移除最后一个元素

package cn.hebei.sjz_LinkedList特有成员;

import java.util.LinkedList;

/*
 * LinkedList特有成员
 */
public class Demo {
	public static void main(String[] args) {
		// 定义一个LinkedList集合
		LinkedList list = new LinkedList();

		// 压栈
		list.addFirst("aaa"); // 先入后出
		list.addFirst("bbb");
		list.addFirst("ccc");
		System.out.println(list); // [ccc,bbb,aaa]
		// 获取第一个元素
		System.out.println(list.getFirst());// ccc
		// 获取最后一个元素
		System.out.println(list.getLast());// aaa
		// 移除第一个元素
		System.out.println(list.removeFirst());// ccc
		System.out.println(list);// [bbb,aaa]
		// 移除最后一个元素
		System.out.println(list.removeLast());// aaa
		System.out.println(list);// [bbb]
	}
}

三、Set（接口）：

1.无序的；

2.不能存储重复值；

package cn.hebei.sjz_Set;

import java.util.Collection;
import java.util.HashSet;

/*
 * Set集合
 */
public class Demo {
	public static void main(String[] args) {
		// 实例化一个Set对象
		Collection<String> set = new HashSet();
		// 填充元素
		set.add("xu");
		set.add("zhao");
		set.add("le");
		// 存储重复元素
		String s = new String("zhao");
		String s1 = new String("le");
		set.add(s1);// 填充失败
		set.add(s);// 填充失败
		set.add("hao");
		System.out.println(set);// [hao,zhao,le,xu]
	}
}

2、HashSet(类):哈希表实现；

保证元素唯一性：元素的hashCode()和equals()

3、LinkedHashSet(类):链表、哈希表实现(特例：有序的)

由链表保证顺序；

由哈希表保证元素唯一；

4、TreeSet(类):树实现；

排序和保证元素唯一性：

1.自然排序：

要存储的元素 实现：Comparable接口

            重写compareTo()方法；

 "a".compareTo("b"):负数：存到左边

 0：不存；

正数：存到右边

package cn.hebei.sjz_TreeSet自然排序;

public class Student implements Comparable<Student> {//实现Comparable接口
	String name;
	int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public int compareTo(Student o) {//重写compareTo()方法
		// 先按姓名排序
		int n1 = this.name.compareTo(o.name);
		// 再按年龄排序
		int n2 = (n1 == 0) ? this.age - o.age : n1;
		return n2;
	}

}

package cn.hebei.sjz_TreeSet自然排序;

import java.util.TreeSet;

public class Demo {
	public static void main(String[] args) {
		// 实例化一个TreeSet集合
		TreeSet<Student> set = new TreeSet();
		// 填充元素
		set.add(new Student("xu", 23));
		set.add(new Student("zhao", 24));
		set.add(new Student("le", 23));
		set.add(new Student("le", 24));
		// 遍历
		for (Student s : set) {
			System.out.println(s.name + "," + s.age);
			/*结果：     le,23
					le,24
					xu,23
					zhao,24*/
		}
	}
}

2.比较器：

1).要存储的元素无需实现任何接口；

2).自定义比较器，实现：Comparator接口

      重写：compare()方法

3).在实例化TreeSet时，将自定义比较器传递给TreeSet的构造方法；

package cn.hebei.sjz_TreeSet比较器;

import java.util.Comparator;
import java.util.TreeSet;

/*
 * TreeSet排序
 * 比较器：
 * 			1>.自定义比较器，实现Comparator接口；
 * 				重写compare()方法；
 * 			2>.实例化TreeSet时，将自定义比较器对象作为参数传递给TreeSet的构造方法；
 */
public class Demo {
	public static void main(String[] args) {
		// 实例化一个TreeSet
		TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				int n1 = o1.name.compareTo(o2.name);
				int n2 = n1 == 0 ? (o1.age - o2.age) : n1;
				return n1;
			}
		});
		set.add(new Student("xu", 23));
		set.add(new Student("zhao", 24));
		set.add(new Student("le", 23));
		// 遍历
		for (Student stu : set) {
			System.out.println(stu.name + "," + stu.age);
			/*结果   le,23
				  xu,23
				  zhao,24*/
		}
	}
}