Java中集合类是用来存放对象的
集合相当于一个容器,里面包容着一组对象 —— 容器类
其中的每个对象作为集合的一个元素出现
Java API提供的集合类位于java.util包内
数组也是容器,它是定长的,访问较快,但是数组不会自动扩充
数组可以包含基本数据类型或引用类型的对象,而集合中只能包含引用类型的对象
Collection接口
Set接口和List接口的父类。
Set - 无序的集合;不允许重复(如 HashSet)
List - 有序的集合;允许重复(如 ArrayList、LinkedList)
Set接口
用来包含一组 无序无重复 的对象
Set有两种主要的集合实现类:
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
56
57
|
import
java
.
util
.
HashSet
;
import
java
.
util
.
Iterator
;
import
java
.
util
.
Set
;
/*
* Collection接口:Set - 无序的集合;不允许重复;List - 有序的集合;允许重复
*/
public
class
TestSet
{
/**
* @param args
*/
public
static
void
main
(
String
[
]
args
)
{
/*set 无序 不重复
* 无序 — 是指元素存入顺序和集合内存储的顺序不同
*/
/*
* 1. Set是“无序”的(利用hash算法存的 假无序,每次结果都一样)
* 即:程序存放的顺序和执行的set顺序无关
*
* 2. Set是不重复的。
*/
//采用哈希技术存储乱序
Set
s
=
new
HashSet
(
)
;
//存储是按照排序存储的 注意 S内的内容要格式统一,符合排序的原则
//Set s = new TreeSet();
s
.
add
(
"1"
)
;
s
.
add
(
"3"
)
;
s
.
add
(
"2"
)
;
//对格式不限制
//s.add(new Integer(4));
//自动去重
s
.
add
(
"3"
)
;
System
.
out
.
println
(
s
)
;
/*
* 遍历set类型的数据
*/
//迭代器Iterator
Iterator
it
=
s
.
iterator
(
)
;
while
(
it
.
hasNext
(
)
)
{
String
str
=
(
String
)
it
.
next
(
)
;
System
.
out
.
println
(
str
)
;
}
}
}
|
List接口
用来包含一组 有序有重复 的对象
List中的元素都对应一个整数型的序号,记载其在容器中的位置,可以根据序号存取容器中的元素
List有两种主要的集合实现类:ArrayList(线性表)和LinkedList(链式表)
ArrayList与LinkedList的比较:
存储结构:
ArrayList是线性顺序存储
LinkedList对象间彼此串连起来的一个链表
操作性能:
ArrayList适合随机查询的场合
LinkedList元素的插入和删除操作性高
从功能上:LinkedList要多一些
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
|
import
java
.
util
.
*
;
public
class
TestList
{
/**
* @param args
*/
public
static
void
main
(
String
[
]
args
)
{
/*
* 有序,可重复
*/
//线性表
List
list
=
new
ArrayList
(
)
;
//链表
// List list = new LinkedList();
list
.
add
(
"1"
)
;
list
.
add
(
"2"
)
;
list
.
add
(
"3"
)
;
list
.
add
(
"4"
)
;
list
.
add
(
"3"
)
;
System
.
out
.
println
(
list
)
;
/*
* 遍历list
*/
//方法一(推荐 效率高)
Iterator
it
=
list
.
iterator
(
)
;
while
(
it
.
hasNext
(
)
)
{
String
str
=
(
String
)
it
.
next
(
)
;
System
.
out
.
println
(
str
)
;
}
//方法二
for
(
int
i
=
0
;
i
<
list
.
size
(
)
;
i
++
)
{
String
str
=
(
String
)
list
.
get
(
i
)
;
System
.
out
.
println
(
str
)
;
}
/*
* linkedList用来实现队列和堆栈
*/
}
}
|
Map接口
HashMap与TreeMap的比较
HashMap与Hashtable的比较
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
import
java
.
util
.
*
;
public
class
TestMap
{
/*
* map 无序,key不能重复
* key部分是用set实现的
*/
public
static
void
main
(
String
[
]
args
)
{
//key部分是用set实现的 hash技术 无序
Map
m
=
new
HashMap
(
)
;
m
.
put
(
new
Integer
(
1000
)
,
"zs"
)
;
m
.
put
(
new
Integer
(
1001
)
,
"lisi"
)
;
m
.
put
(
new
Integer
(
1001
)
,
"zhaosi"
)
;
System
.
out
.
println
(
m
)
;
/*
* 使用场景1: 根据key找value
*/
String
str
=
(
String
)
m
.
get
(
new
Integer
(
1000
)
)
;
System
.
out
.
println
(
str
)
;
/*
* 使用场景2: 遍历map
* 找到所有的Key
* 利用iterator迭代器遍历
*/
Set
keys
=
m
.
keySet
(
)
;
Iterator
it
=
keys
.
iterator
(
)
;
while
(
it
.
hasNext
(
)
)
{
Integer
temp
=
(
Integer
)
it
.
next
(
)
;
System
.
out
.
println
(
temp
)
;
}
/*
* 使用场景3: 遍历map
* 找到所有value
*/
Collection
values
=
m
.
values
(
)
;
it
=
values
.
iterator
(
)
;
while
(
it
.
hasNext
(
)
)
{
String
temp
=
(
String
)
it
.
next
(
)
;
System
.
out
.
println
(
temp
)
;
}
/*
* 使用场景4: 遍历map
* 找到所有key-value对
*/
Set
s
=
m
.
entrySet
(
)
;
it
=
s
.
iterator
(
)
;
while
(
it
.
hasNext
(
)
)
{
Map
.
Entry
entry
=
(
Map
.
Entry
)
it
.
next
(
)
;
Integer
id
=
(
Integer
)
entry
.
getKey
(
)
;
String
name
=
(
String
)
entry
.
getValue
(
)
;
System
.
out
.
println
(
id
+
"----"
+
name
)
;
}
}
}
|
Iterator接口
迭代器,用来方便的实现对容器内的元素进行遍历操作。所有实现了Collection接口的集合类都有一个iterator( )方法,返回一个实现了Iterator接口的对象。Iterator对象实现了统一的一个用来遍历Collection中对象的方法。Iterator是为遍历而设计,能够从集合中取出元素和删除元素,但是没有添加元素的功能。Iterator的功能上比较简单,使用中,只能单向移动