List类及子类_list 所有子类

List类

概述

/*

• List接口继承自Collection接口，是单列集合的一个重要分支，习惯上我们把实现了List接口的集合称为List集合
• 1.允许出现重复的元素，所有元素以线性方式存储，在程序中可以通过索引来访问结合中指定的元素。
• 2.元素有序，元素的存入顺序和取出顺序是一致的。

*/

常用方法

1.public E get(int index)返回集合中指定位置的元素
2.public E remove(int index)移除集合中指定位置的元素，返回移除的元素
3.public E set(int index,E element)用指定元素替换集合中指定位置的元素，返回更新前的元素

package SE03.n1Collection;

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

public class Demo03List {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("小王");
		list.add("小李");
		list.add("小明白");
		list.add(2,"小清楚");//指定索引位置插入元素
		System.out.println("输出集合"+list);
		System.out.println("get()方法："+list.get(2));//	返回集合中指定位置的元素
		System.out.println("remove()方法："+list.remove(2));//移除集合中指定位置的元素，返回移除的元素
		System.out.println("输出集合"+list);
		System.out.println("set()方法："+list.set(1, "小可爱"));
		//用指定元素替换集合中指定位置的元素,返回更新前的元素
		System.out.println("输出集合"+list);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果：
输出集合[小王, 小李, 小清楚, 小明白]
get()方法：小清楚
remove()方法：小清楚
输出集合[小王, 小李, 小明白]
set()方法：小李
输出集合[小王, 小可爱, 小明白]

ArrayList

/*

• ArrayList集合数据存储的结构是数组结构，元素增删慢，查找快，由于日常开发中使用最多的功能就是查询数据、
• 遍历数据，所以，ArrayList是最常用的集合，但是，倘若我们的需求的容易是经常要增删，不怎么查找的话，就不应该
• 任意的滥用ArrayList
• 由于数组在内存空间中的存储位置是连续的，所以查找快
  */
  常用方法与List类同

LinkedList

/*

• LinkedList数据存储结构是链表结构。方便元素添加、删除的集合。
• LinkedList是双向链表。在一定程度上缓解了链表查找慢的缺陷。
• 实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而
• LinkedList提供了大量的首尾操作的方法。
  */

常用方法

1.public void addFirst(E e);将指定元素插入此列表的开头
2.public void addList(E e);将制定元素添加到此列表的结尾
3.public E getFirst();返回此列表的第一个元素
4.public E getLast();返回此列表的最后一个元素
5.public E removeFirst();移除并返回此列表的第一个元素
6.public E removeLast();移除并返回此列表的最后一个元素
7.public E pop();从此列表所表示的堆栈处弹出一个元素
8.public E push(E e);将元素推入此列表所表示的堆栈
9.public boolean isEmpty();如果列表不包含元素则返回true
PS：在开发时，LinkedList可以作为堆栈、队列的数据结构使用,pop方法与push方法与堆栈的增删相同

package SE03.n1Collection;
import java.util.LinkedList;
public class Demo05LinkedList {

	public static void main(String[] args) {
		LinkedList<String>ll=new LinkedList<String>();

		ll.add("小明");
		ll.add("小白");
		ll.add("小明白");
		ll.addFirst("小清楚");
		System.out.println(ll);//将指定元素插入此列表的开头
		ll.addLast("小糊涂");//将制定元素添加到此列表的结尾
		System.out.println(ll);
		System.out.println(ll.getFirst());//返回此列表的第一个元素
		System.out.println(ll.getLast());//返回此列表的最后一个元素
		System.out.println(ll.removeFirst());//移除并返回此列表的第一个元素
		System.out.println(ll);//输出集合
		System.out.println(ll.removeLast());//移除并返回此列表的最后一个元素
		System.out.println(ll);//输出集合
		System.out.println(ll.pop());//从此列表所表示的堆栈处弹出一个元素
		System.out.println(ll);//输出集合
		ll.push("好东西");//将元素推入此列表所表示的堆栈
		System.out.println(ll);//输出集合
		System.out.println(ll.isEmpty());//如果列表不包含元素则返回true
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

结果：
输出集合：[小清楚, 小明, 小白, 小明白]
输出集合：[小清楚, 小明, 小白, 小明白, 小糊涂]
返回列表第一个元素：小清楚
返回列表最后一个元素：小糊涂
移除并返回此列表的第一个元素小清楚
输出集合：[小明, 小白, 小明白, 小糊涂]
移除并返回此列表的最后一个元素小糊涂
输出集合：[小明, 小白, 小明白]
从此列表所表示的堆栈处弹出一个元素小明
输出集合：[小白, 小明白]
输出集合：[将元素推入此列表所表示的堆栈好东西, 小白, 小明白]
如果列表不包含元素则返回true：false

HashSet

/*

• Set接口和List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有功能上
• 的扩充，只是比Collection接口更严格了，与List不同的是，set接口中的元素是无序的，并且都会以某种规则
• 保证存入的元素不会重复出现。
• set集合有多个子类，比如：HashSet，LinkedHashSet
• HashSet是Set接口的一个实现类，底层实现是一个HashMap支持。它根据对象的哈希值来确定元素的存储位置，
• 因此具有良好的查找性能。保证元素唯一性的方式依赖于：hashCode()和equals()
  */
  注意！
  1.HashSet存储数据的结构是：哈希表
  2.当需要向HashSet中存储自定义类时，要重写hashCode()和equals()

package SE03.n1Collection;

import java.util.HashSet;
import java.util.Iterator;

public class Demo06HashSet {
/*
 * Set接口和List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有功能上
 * 的扩充，只是比Collection接口更严格了，与List不同的是，set接口中的元素是无序的，并且都会以某种规则
 * 保证存入的元素不会重复出现。
 * set集合有多个子类，比如：HashSet，LinkedHashSet
 * 
 * HashSet是Set接口的一个实现类，底层实现是一个HashMap支持。它根据对象的哈希值来确定元素的存储位置，
 * 因此具有良好的查找性能。保证元素唯一性的方式依赖于：hashCode()和equals()
 */
	public static void main(String[] args) {
		HashSet<String> set=new HashSet<String>();
		set.add("小明");
		set.add("小白");
		set.add("小明白");
		set.add("小明");
		for (String name : set) {
			System.out.println(name);
		}
		HashSet<Student> sett=new HashSet<Student>();
		sett.add(new Student(19,"x名"));
		sett.add(new Student(11,"x名"));
		sett.add(new Student(12,"x名"));
		sett.add(new Student(13,"x名"));
		sett.add(new Student(13,"名x"));
		for (Student student : sett) {
			System.out.println(student);
		}
		System.out.println();
		//可以用foreach也可以用迭代器
		
		Iterator<Student> it=sett.iterator();
		while(it.hasNext()) {
			Student s = it.next();
			System.out.println(s);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

Student类

package SE03.n1Collection;

public class Student {
	int age;
	String name;
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@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;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

结果：
小明
小白
小明白
Student [age=19, name=x名]
Student [age=13, name=名x]
Student [age=13, name=x名]
Student [age=12, name=x名]
Student [age=11, name=x名]

Student [age=19, name=x名]
Student [age=13, name=名x]
Student [age=13, name=x名]
Student [age=12, name=x名]
Student [age=11, name=x名]

LinkedHashSet

与HashSet不同的是，增加了一条链表，用来维护顺序

package SE03.n1Collection;
import java.util.HashSet;
public class Demo07LinkedHashSet {
	public static void main(String[] args) {
		HashSet<String> set=new HashSet<String>();
		set.add("小明");
		set.add("小白");
		set.add("小明白");
		set.add("小明");//重复的数据只会存一个
		for (String name : set) {
			System.out.println(name);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果：
小明
小白
小明白