常用类之集合

集合：就是用来存放数据的一个容器。

数组和集合的区别

（1）数组能存基本数据类型和引用类型；集合当中只能存放引用数据类型，直接放基本数据类型，也会自动帮你装箱（把基本数据类型转成对象），集合当中只能存放对象。

（2）数组长度是固定，不能再去增长；集合长度是可以改变，根据元素的增长而增加。

什么时候使用数组，什么时候使用集合类。

如果元素个数是固定，推荐使用数组；如果元素不是固定，推荐使用集合。

集合体系

这里介绍集合体系的一部分。

Collection 接口

常用方法

/*

 * 向 collection 中添加指定的元素，

 * 如果添加成功返回 true，没有添加返回 false。

 * 确保此 collection 包含指定的元素。

 */

boolean add(E e) 

/*

 * 将指定 collection 中的所有元素都添加到此 collection 中

 * 如果此 collection 由于调用而发生更改，则返回 true。 否则返回 false。

 */

boolean addAll(Collection<? extends E> c) 

// 移除此 collection 中的所有元素

void clear() 

// 如果此 collection 包含指定的元素，则返回 true。否则返回 false。

boolean contains(Object o) 

// 如果此 collection 包含指定 collection 中的所有元素，则返回 true。否则返回 false。

boolean containsAll(Collection<?> c) 

/*

 * 比较此 collection 与指定对象是否相等。

 * 如果所定义的两个列表以相同的顺序包含相同的元素，则返回 true。

 */

boolean equals(Object o) 

// 如果此 collection 不包含元素，则返回 true。

boolean isEmpty() 

// 返回在此 collection 的元素上进行迭代的迭代器。

Iterator<E> iterator() 

// 从此 collection 中移除指定元素的单个实例，如果存在的话，移除成功，则返回 true。

boolean remove(Object o) 

/*

 * 移除此 collection 中，此 collection和指定 collection的交集

 * 如果此 collection 由于调用而发生更改，则返回 true

 */

boolean removeAll(Collection<?> c) 

/*

 * 把此 collection和指定 collection的交集赋值给调用者

 * 如果此 collection 由于调用而发生更改，则返回 true

 */

boolean retainAll(Collection<?> c) 

// 返回此 collection 中的元素数。

int size() 

// 返回包含此 collection 中所有元素的数组

Object[] toArray() 

// 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

<T> T[] toArray(T[] a)

管理集合元素：

增：add(E e) 

删：remove(Object o) 

改：Collection中没有定义

清空：clear()

查：

个数：size()

判包含：contains(Object o)

判空：isEmpty() 

查找定位某个元素：Collection中没有定义

e.g.

public static void main(String[] args) {

	Collection c = new ArrayList();

	// 会自动帮你装箱（把基本数据类型转成对象）

	c.add(10);

	c.add(true);

}

反编译后：

public static void main(String args[])

{

	Collection c = new ArrayList();

	c.add(Integer.valueOf(10));

	c.add(Boolean.valueOf(true));

}

e.g. Collection 遍历

public static void main(String[] args) {

	Collection c = new ArrayList();

	c.add(new Student("zs"));

	c.add(new Student("ls"));

	c.add(new Student("ww"));

	// （1）转成数组，通过数组遍历

	Object[] array = c.toArray(); // 自动把数组当中所有元素向上转型

	for (int i = 0; i < array.length; i++) {

		if (array[i] instanceof Student) { // 向下转型有风险

			Student s = (Student) array[i]; // 向下转型(转回原来存放的类型)

			System.out.println(s.name);

		}

	}

	System.out.println("-----分割线------");

	// （2）迭代器遍历（推荐）

	Iterator it = c.iterator(); // 放到Iterator内容会自动类型提升为 Object

	// 1.判断有没有元素可以迭代，如果仍有，则返回 true。

	while (it.hasNext()) {

		// 2. 返回游标的下一个元素，游标后移一位

		Object next = it.next();

		if (next instanceof Student) {

			Student s = (Student) next;

			System.out.println(s.name);

		}

	}

}

List 接口

常用方法

由 Collection 接口继承来的不再说明，见Collection 接口的常用方法

// 在列表的指定位置插入指定元素

void add(int index, E element) 

/*

 * 将指定 collection 中的所有元素都插入到列表中的指定位置

 * 如果此 collection 由于调用而发生更改，则返回 true。 否则返回 false。

 */

boolean addAll(int index, Collection<? extends E> c) 

// 移除列表中指定位置的元素，返回从列表中移除的元素

E remove(int index) 

// 返回列表中指定位置的元素

E get(int index) 

// 用指定元素替换列表中指定位置的元素，返回被替换的元素

E set(int index, E element) 

// 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1

int indexOf(Object o) 

// 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1

int lastIndexOf(Object o)

// 返回此列表元素的列表迭代器（按适当顺序）

ListIterator<E> listIterator()

// 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始

ListIterator<E> listIterator(int index)

// 返回列表中指定的 [fromIndex, toIndex) 之间的部分视图。

List<E> subList(int fromIndex, int toIndex)

// 使用随附的 Comparator排序此列表来比较元素。

default void sort(Comparator<? super E> c)

管理集合元素：

增：add(E e) ;  add(int index, E element) 

删：remove(Object o) ;  remove(int index) 

改：set(int index, E element) 

清空：clear() 

排序：sort(Comparator<? super E> c) 

子集合：subList(int fromIndex, int toIndex)

查：

个数：size()

判包含：contains(Object o)

判空：isEmpty() 

查找定位某个元素：indexOf(Object o) ; lastIndexOf(Object o)  ;  get(int index)

e.g.

现在有个需求，遍历集合，如果集合中的元素等于某个值，删除这个元素。

List list = new  ArrayList();

list.add("1");

list.add("2");

list.add("3");

list.add("4");

// 遍历集合

Iterator it = list.iterator();

while(it.hasNext()) {

	// 取出对应的元素

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

	// 判断该 元素是否等于 2

	if(str.equals("2")) {

		// 等于 2 就把2给集合当中删除

		list.remove("2");

	}

}

System.out.println(list);

以上代码会报 java.util.ConcurrentModificationException 并发修改异常

在迭代集合的过程当中，是不允许直接修改集合结构。

看下源码：

修改后：

List list = new  ArrayList();

list.add("1");

list.add("2");

list.add("3");

list.add("4");

Iterator it = list.iterator();

while(it.hasNext()) {

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

	if(str.equals("2")) {

		it.remove(); // 删除当前正在迭代集合的元素（正在遍历的元素 next的结果）

	}

}

System.out.println(list);

原理：

e.g. List特有的迭代器

现在换了一个需求，遍历集合，如果集合中的元素等于某个值，在这个元素后添加一个元素。

在迭代器中，只有remove方法，没有add方法。但是在List中有自己特有的迭代器 listIterator

private class ListItr extends Itr implements ListIterator<E>

ListItr 继承了 Itr，所以 Itr 有的方法都能用。

List list = new ArrayList();

list.add("1");

list.add("2");

list.add("3");

list.add("4");

// 在list当中有自己特有的迭代器

ListIterator it = list.listIterator();

while (it.hasNext()) {

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

	if (str.equals("2")) {

		// list.add("myxq"); 	//会发生并发修改异常

		it.add("myxq");

	}

}

System.out.println(list);

ArrayList

数据结构分析

数组的大小是固定的，ArrayList 数组扩容的实现：

查询和修改比较快，通过索引就能找到对应值。

添加和删除比较慢

这也就实现了当我们不指定初始化大小的时候，添加第一个元素的时候，数组会扩容为 10.

添加和删除图示：

ArrayList 去除集合中重复的元素

public static ArrayList removeDuplicates(ArrayList list) {

	// 1.创建一个空的集合

	ArrayList newList = new ArrayList();

	// 2.依次取出每一个元素

	ListIterator it = list.listIterator();

	while (it.hasNext()) {

		// 3.每取出一个元素，要先判断新集合当中 ，是否已经包含了该元素

		Object obj = it.next();

		// 4.如果已经包含该元素，就不把该元素添加到新集合当中，不包含时才添加到新集合当中

		if (!newList.contains(obj)) {

			newList.add(obj);

		}

	}

	return newList;

}

public static void main(String[] args) {

	ArrayList list = new ArrayList();

	list.add("a");

	list.add("a");

	list.add("b");

	list.add("b");

	list.add("c");

	list.add("c");

	list.add("d");

	System.out.println(list);

	ArrayList newList = removeDuplicates(list);

	System.out.println(newList);

}

ArrayList 去除集合中重复的自定义对象元素

class Student {

	String name;

	int age;

	Student(String name, int age) {

		this.name = name;

		this.age = age;

	}

	@Override

	public String toString() {

		return "Student [name=" + name + ", age=" + age + "]";

	}

}

@SuppressWarnings({ "unchecked", "rawtypes" })

public class Test {

	public static ArrayList removeDuplicates(ArrayList list) {

		// 1.创建一个空的集合

		ArrayList newList = new ArrayList();

		// 2.依次取出每一个元素

		ListIterator it = list.listIterator();

		while (it.hasNext()) {

			// 3.每取出一个元素，要先判断新集合当中 ，是否已经包含了该元素

			Object obj = it.next();

			// 4.如果已经包含该元素，就不把该元素添加到新集合当中，不包含时才添加到新集合当中

			if (!newList.contains(obj)) {

				newList.add(obj);

			}

		}

		return newList;

	}

	public static void main(String[] args) {

		ArrayList list = new ArrayList();

		list.add(new Student("张三", 20));

		list.add(new Student("张三", 20));

		list.add(new Student("李四", 21));

		System.out.println(list);

		ArrayList newList = removeDuplicates(list);

		System.out.println(newList);

	}

}

以上代码发现并没有去重。

原因是 contains 是用equals（如果没有重写，默认是Object的equals，比较的是地址）判断有没有相同的元素。

修改后

class Student {

	String name;

	int age;

	Student(String name, int age) {

		this.name = name;

		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;

	}

}

@SuppressWarnings({ "unchecked", "rawtypes" })

public class Test {

	public static ArrayList removeDuplicates(ArrayList list) {

		// 1.创建一个空的集合

		ArrayList newList = new ArrayList();

		// 2.依次取出每一个元素

		ListIterator it = list.listIterator();

		while (it.hasNext()) {

			// 3.每取出一个元素，要先判断新集合当中 ，是否已经包含了该元素

			Object obj = it.next();

			// 4.如果已经包含该元素，就不把该元素添加到新集合当中，不包含时才添加到新集合当中

			if (!newList.contains(obj)) {

				newList.add(obj);

			}

		}

		return newList;

	}

	public static void main(String[] args) {

		ArrayList list = new ArrayList();

		list.add(new Student("张三", 20));

		list.add(new Student("张三", 20));

		list.add(new Student("李四", 21));

		System.out.println(list);

		ArrayList newList = removeDuplicates(list);

		System.out.println(newList);

	}

}

LinkedList

数据结构分析

添加和删除比较快，查询和修改比较慢。

LinkedList 特有的方法

// 将指定元素插入此列表的开头。

void addFirst(E e) 

// 将指定元素添加到此列表的结尾。

void addLast(E e) 

// 获取但不移除此列表的头（第一个元素）。

E element() 

// 返回此列表的第一个元素。

E getFirst() 

// 返回此列表的最后一个元素。

E getLast() 

// 获取并移除此列表的头（第一个元素）。

E remove() 

// 移除并返回此列表的第一个元素。

E removeFirst() 

// 移除并返回此列表的最后一个元素。

E removeLast() 

// 将指定元素添加到此列表的末尾（最后一个元素）。

boolean offer(E e) 			// 类似  add(E e)

// 在此列表的开头插入指定的元素。

boolean offerFirst(E e) 	// 类似  addFirst(E e)

// 在此列表末尾插入指定的元素。

boolean offerLast(E e) 		// 类似  addLast(E e)

// 获取但不移除此列表的头（第一个元素）。

E peek() 					// 类似  element() 

// 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

E peekFirst() 				// 类似  getFirst() 

// 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

E peekLast() 				// 类似  getLast() 

// 获取并移除此列表的头（第一个元素）

E poll() 					// 类似  remove()

// 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

E pollFirst() 				// 类似  removeFirst()

// 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

E pollLast() 				// 类似  removeLast()

// 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。

boolean removeFirstOccurrence(Object o) 

// 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

boolean removeLastOccurrence(Object o) 

// 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个（尾部）到第一个（头部）的顺序返回。

Iterator<E> descendingIterator()

栈：先进后出

// 出栈：从此列表所表示的堆栈处弹出一个元素。

E pop() 					// 底层调用  removeFirst(e);

// 入栈：将元素推入此列表所表示的堆栈。

void push(E e) 				// 底层调用  addFirst(e);

Vector

Vector使用很少，一般都使用ArrayList 从1.2开始并到List

特有的方法

// 将指定的组件添加到此向量的末尾，将其大小增加 1。

void addElement(E obj) 

// 返回此向量的组件的枚举。

Enumeration<E> elements()

e.g. 特有的遍历元素

Vector vc = new Vector();

vc.add("a");

vc.add("b");

vc.add("c");

// 获取所有元素

Enumeration e = vc.elements();

while (e.hasMoreElements()) {

	System.out.println(e.nextElement());

}

与ArrayList对比

（1）都是使用数组来实现的

（2）Vector是线程安全的，内部加了锁；ArrayList当中方法没有加锁

集合的嵌套

class Student {

	String name;

	Student(String name) {

		this.name = name;

	}

}

public class Test {

	public static void main(String[] args) {

		/**

		 * 学科  学科当中是有很多班级

		 * 班级当中又有很多学生

		 */

		Student stu1 = new Student("zs1");

		Student stu2 = new Student("ls1");

		// 班级1

		List<Student> c1 = new ArrayList<>();

		c1.add(stu1);

		c1.add(stu2);

		Student stu3 = new Student("zs2");

		Student stu4 = new Student("ls2");

		// 班级2

		List<Student> c2 = new ArrayList<>();

		c2.add(stu3);

		c2.add(stu4);

		// 学科 (集合当中又存储集合)

		List<List<Student>> x = new ArrayList<>();

		x.add(c1);

		x.add(c2);

		// 把所有班级当中 的学生姓名打印出来

		for (List<Student> g : x) {

			// 取出每一个班级

			for (Student per : g) {

				System.out.println(per.name);

			}

		}

	}

}

最新文章

1. 透过HT for Web 3D看动画Easing函数本质
2. wget 断点续传 & nginx文件服务器
3. <页面里折合与打开>
4. ReferenceError: $ is not defined （绝对路径和相对路径）
5. VisualSVN-Server 安装以及使用教程
6. 使用自定义setTimeout和setInterval使之可以传递参数和对象参数
7. “CEPH浅析”系列之八——小结
8. PHP入门 - - 06-->HTML的表格标签
9. Android VideoView播放视频
10. 160920、springmvc上传图片不生成临时文件
11. OpenJudge 2721 忽略大小写比较字符串大小
12. JVM Class详解之一
13. kernel pwn 入门环境搭建
14. P1316 丢瓶盖--（二分答案）
15. 【.net ajax显示后台返回值】
16. SSH的配置文件
17. Linux cp 强制覆盖
18. elasticsearch常见异常及解决办法
19. linux 操作系统rz sz 快速上传和下载文件
20. 【agc019C】Fountain Walk

热门文章

1. [leetcode]存在重复
2. /etc/apt/sources.list 和 /etc/apt/sources.list.d
3. Python_比较运算符
4. K8S 1.12大特性最快最深度解析：Kubernetes CSI Snapshot（上）
5. orm多表的创建和基于对象的查询
6. python中is与==的区别，编码和解码
7. vue中watch的详细用法（转载）
8. Android adb的一些用法
9. C#格式化信息,格式化数字、格式化日期
10. go语言开发IDE