目录
一、引入集合的原因:
二、集合概述
三、Collection接口
四、iterator迭代器接口
五、Collection的子接口
1.List接口
(1).ArrayList
(2).LinkedList
(3).Vector
2.Set接口
(2)LInkedHashSet
(3)TreeSet
2.Map接口
(1).HashMap
(2).LinkedHashMap
(3)TreeMap
(4)HashTable
(5)Properties
六、Collections工具类
七、练习
一、引入集合的原因:
集合、数组都是对数据存储的实现,简称JAVA容器,在之前的学习中我们一直使用数组,数组的特点:
1.一旦初始化,其长度便就确定了;
2.数组只能操作指定类型的数组即我们使用时定义的数组;
3.数组所能提供的方法非常有限,对于删除、插入元素不太方便;
4.数组的元素是有序的、可重复的,对于无序、不可重复的需求难以实现。
二、集合概述
JAVA集合可分为Collection和Map两种体系:
Collection接口:单列数据,定义了存取一组对象方法的集合
List:元素有序、可重复的集合(动态数组)
Set:元素无序、不可重复的集合(类似于数学中的集合)
Map接口:双列数据,保存具有映射关系“Key—Value”的集合(类似于数学中的函数法f(x))
Collection接口是Set、List、Queue的父接口,该接口中定义的方法,既可以操作Set集合,也可以操作ListheQueue集合。
三、Collection接口
Collection的接口方法有:
1
、添加
add(Object obj)
addAll(Collection coll)
2
、获取有效元素的个数
int size()
3
、清空集合
void clear()
4
、是否是空集合
boolean isEmpty()
5
、是否包含某个元素
boolean contains(Object obj)
:
是通过元素的
equals
方法来判断是否
是同一个对象
boolean containsAll(Collection c)
:
也是调用元素的
equals
方法来比
较的。拿两个集合的元素挨个比较。
6、删除
boolean remove(Object obj)
:
通过元素的
equals
方法判断是否是
要删除的那个元素。只会删除找到的第一个元素
boolean removeAll(Collection coll)
:
取当前集合的差集
7
、取两个集合的交集
boolean retainAll(Collection c)
:
把交集的结果存在当前集合中,不
影响
c
8
、集合是否相等
boolean equals(Object obj)
9
、转成对象数组
Object[] toArray()
10
、获取集合对象的哈希值
hashCode()
11
、遍历
iterator()
:
返回迭代器对象,用于集合遍历
四、iterator迭代器接口
iterator对象称为迭代器,主要用于遍历Collection集合中的元素。
Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象,则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合 的第一个元素之前。
五、Collection的子接口
1.List接口
鉴于Java数组存储元素的局限性,我们常用List代替数组
List存储的特点是无序、可重复的,且每个元素都有与之对应的顺序索引。
List的常用实现类有:ArrayList、LinkList、Vector。
List
除了从
Collection
集合继承的方法外,
List
集合里添加了一些根据索引来
操作集合元素的方法。
void add(int index, Object ele):
在
index
位置插入
ele
元素
boolean addAll(int index, Collection eles):
从
index
位置开始将
eles
中
的所有元素添加进来
Object get(int index):
获取指定
index
位置的元素
int indexOf(Object obj):
返回
obj
在集合中首次出现的位置
int lastIndexOf(Object obj):
返回
obj
在当前集合中末次出现的位置
Object remove(int index):
移除指定
index
位置的元素,并返回此元素
Object set(int index, Object ele):
设置指定
index
位置的元素为
ele
List subList(int fromIndex, int toIndex):
返回从
fromIndex
到
toIndex
位置的子集合
(1).ArrayList
ArrayList是List的主要实现类,本质上是对象引用了一个变长的数组。
(2).LinkedList
对于频繁进行插入和删除的操作,常采用LinkedList类。效率较高。
新增方法:
void addFirst(Object obj)
void addLast(Object obj)
Object getFirst()
Object getLast()
Object removeFirst()
Object removeLast()
LinkedList
:
双向链表
,内部没有声明数组,而是定义了
Node
类型的
first
和
last
,
用于记录首末元素。同时,定义内部类
Node
,作为
LinkedList
中保存数据的基
本结构。
Node
除了保存数据,还定义了两个变量:
prev
变量记录前一个元素的位置
next
变量记录下一个元素的位置
(3).Vector
Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList
相同,区别之处在于
Vector
是线程安全的。
在各种
list
中,最好把
ArrayList
作为缺省选择。当插入、删除频繁时,使用LinkedList
;
Vector
总是比
ArrayList
慢,所以尽量避免使用。
新增方法:
void addElement(Object obj)
void insertElementAt(Object obj,int index)
void setElementAt(Object obj,int index)
void removeElement(Object obj)
void removeAllElements()
2.Set接口
Set接口也是Collection的子接口,但Set接口并没有提供额外的方法。
Set集合中的元素是无序、不可重复的。当添加Set集合中已有的元素时,就会添加失败。
在判断元素相等时,使用的是equles()。
(1)HashSet
HashSet是Set接口的典型实现类,HashSet是按照Hash方法存储元素的,具有较好的存取、查找和删除性能。
HashSet存储元素的特点:
不是线程安全的,可以存放null,不能保证元素的排列顺序。
HashSet
集合判断两个元素相等的标准
:
两个对象通过
hashCode()
方法比较相
等,并且两个对象的
equals()
方法返回值也相等。
对于存放在
Set
容器中的对象,
对应的类一定要重写
equals()
和
hashCode(Object
obj)
方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。
(2)LInkedHashSet
LinkedHanhSet是HashSet的子类,
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置, 但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能。
LinkedHashSet
不允许集合元素重复。
(3)TreeSet
TreeSet
是
SortedSet
接口的实现类,
TreeSet
可以确保集合元素处于排序状态。
TreeSet
底层使用
红黑树
结构存储数据
新增的方法如下:
(
了解
)
Comparator comparator()
Object first()
Object last()
Object lower(Object e)
Object higher(Object e)
SortedSet subSet(fromElement, toElement)
SortedSet headSet(toElement)
SortedSet tailSet(fromElement)
TreeSet
两种排序方法:
自然排序
和
定制排序
。默认情况下,
TreeSet
采用自然排序
练习:在
List
内去除重复数字值,要求尽量简单
@Test
/**
* 练习:在List内去除重复数字值,要求尽量简单
*/
public void test1(){
LinkedList<Object> list= new LinkedList<>();
list.add("123");
list.add(12);
list.add('i');
list.add(12);
LinkedList<Object> list1=new LinkedList<>();
list1= (LinkedList<Object>) delete(list);
System.out.println(list1);
}
public Collection delete(LinkedList list){
HashSet set = new HashSet();
set.addAll(list);
return new LinkedList(set);
}
2.Map接口
Map接口是双列数据集合,用于保存具有映射关系的数据:Key-Value;
Map
中的
key
和
value
都可以是任何引用类型的数据
Map
中的
key
用
Set
来存放,
不允许重复
,即同一个
Map
对象所对应 的类,须重写hashCode()
和
equals()
方法
常用
String
类作为
Map
的“键”
key
和
value
之间存在单向一对一关系,即通过指定的
key
总能找到 唯一的、确定的 value
Map
接口的常用实现类:
HashMap
、
TreeMap
、
LinkedHashMap
和
Properties
。其中,
HashMap
是
Map
接口使用频率最高的实现类
添加、删除、修改操作:
Object put(Object key,Object value)
:将指定
key-value
添加到
(
或修改
)
当前
map
对象中
void putAll(Map m):
将
m
中的所有
key-value
对存放到当前
map
中
Object remove(Object key)
:移除指定
key
的
key-value
对,并返回
value
void clear()
:清空当前
map
中的所有数据
元素查询的操作:
Object get(Object key)
:获取指定
key
对应的
value
boolean containsKey(Object key)
:是否包含指定的
key
boolean containsValue(Object value)
:是否包含指定的
value
int size()
:返回
map
中
key-value
对的个数
boolean isEmpty()
:判断当前
map
是否为空
boolean equals(Object obj)
:判断当前
map
和参数对象
obj
是否相等
元视图操作的方法:
Set keySet()
:返回所有
key
构成的
Set
集合
Collection values()
:返回所有
value
构成的
Collection
集合
Set entrySet()
:返回所有
key-value
对构成的
Set
集合
(1).HashMap
HashMap
是
Map
接口
使用频率最高
的实现类。
允许使用
null
键和
null
值,与
HashSet
一样,不保证映射的顺序。
所有的
key
构成的集合是
Set:
无序的、不可重复的。所以,
key
所在的类要重写:equals()和
hashCode()
所有的
value
构成的集合是
Collection:
无序的、可以重复的。所以,
value
所在的类要重写equals()
一个
key-value
构成一个
entry
所有的
entry
构成的集合是
Set:
无序的、不可重复的
HashMap
判断两个
key
相等的标准
是:两个
key
通过
equals()
方法返回
true,
hashCode 值也相等。
HashMap
判断两个
value
相等的标准
是:两个
value
通过
equals()
方法返回
true
。
(2).LinkedHashMap
LinkedHashMap
是
HashMap
的子类
在
HashMap
存储结构的基础上,使用了一对双向链表来记录添加元素的顺序
与
LinkedHashSet
类似,
LinkedHashMap
可以维护
Map
的迭代顺序:迭代顺序与 Key-Value
对的插入顺序一致
(3)TreeMap
TreeMap
存储
Key-Value
对时,需要根据
key-value
对进行排序。
TreeMap
可以保证所有的
Key-Value
对处于
有序
状态。
TreeSet
底层使用
红黑树
结构存储数据
TreeMap
的
Key
的排序:
自然排序
:
TreeMap
的所有的
Key
必须实现
Comparable
接口,而且所有
的
Key
应该是同一个类的对象,否则将会抛出
ClasssCastException
定制排序
:创建
TreeMap
时,传入一个
Comparator
对象,该对象负责对
TreeMap
中的所有
key
进行排序。此时不需要
Map
的
Key
实现
Comparable
接口
TreeMap
判断
两个
key
相等的标准
:两个
key
通过
compareTo()
方法或
者
compare()
方法返回
0
。
(4)HashTable
Hashtable
是个古老的
Map
实现类,
JDK1.0
就提供了。不同于
HashMap
,
Hashtable
是线程安全的。
Hashtable
实现原理和
HashMap
相同,功能相同。底层都使用哈希表结构,查询
速度快,很多情况下可以互用。
与
HashMap
不同,
Hashtable
不允许使用
null
作为
key
和
value
与
HashMap
一样,
Hashtable
也不能保证其中
Key-Value
对的顺序
Hashtable
判断两个
key
相等、两个
value
相等的标准,与
HashMap
一致。
(5)Properties
Properties
类是
Hashtable
的子类,该对象用于处理属性文件
由于属性文件里的
key
、
value
都是字符串类型,所以
Properties
里的
key
和
value
都是字符串类型
存取数据时,建议使用
setProperty(String key,String value)
方法和
getProperty(String key)
方法
Properties
pros
=
new
Properties();
pros
.load(
new
FileInputStream(
"jdbc.properties"
));
String
user
=
pros
.getProperty(
"user"
);
System.
out
.println(
user
);
六、Collections工具类
Collections
是一个操作
Set
、
List
和
Map
等集合的工具类
Collections
中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
排序操作
:
(均为
static
方法)
reverse(List)
:
反转
List
中元素的顺序
shuffle(List)
:
对
List
集合元素进行随机排序
sort(List)
:
根据元素的自然顺序对指定
List
集合元素按升序排序
sort(List
,
Comparator)
:
根据指定的
Comparator
产生的顺序对
List
集合元素进行排序
swap(List
,
int
,
int)
:
将指定
list
集合中的
i
处元素和
j
处元素进行交换
Collections
是一个操作
Set
、
List
和
Map
等集合的工具类
Collections
中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,
还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
排序操作
:
(均为
static
方法)
reverse(List)
:
反转
List
中元素的顺序
shuffle(List)
:
对
List
集合元素进行随机排序
sort(List)
:
根据元素的自然顺序对指定
List
集合元素按升序排序
sort(List
,
Comparator)
:
根据指定的
Comparator
产生的顺序对
List
集合元素进行排序
swap(List
,
int
,
int)
:
将指定
list
集合中的
i
处元素和
j
处元素进行交换
七、练习
1.
请从键盘随机输入
10
个整数保存到
List
中,并按倒序、从大到小的顺序显示出来
@Test
/**
* 1.请从键盘随机输入10个整数保存到List中,并按倒序、从大
* 到小的顺序显示出来
*/
public void test2(){
Scanner sc = new Scanner(System.in);
System.out.println("请输入10个整数:");
List list = new ArrayList();
for (int j = 0; j < 10; j++) {
int i = sc.nextInt();
list.add(i);
}
System.out.println("按照倒序的顺序显式:");
Iterator iterator = list.iterator();
Collections.reverse(list);//
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("按照从大到小输出");
Iterator iterator1=list.iterator();
Collections.sort(list);
Collections.reverse(list);
while(iterator1.hasNext()){
System.out.println(iterator.next());
}
}
2.
请把学生名与考试分数录入到集合中,并按分数显示前三名成绩学员的名字。
class Student implements Comparable<Student>{
private int score;
private String name;
public Student(int score, String name) {
this.score = score;
this.name = name;
}
public Student() {
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"score=" + score +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(Student o) {
if(this.getScore ()>o.getScore ()){
return 1;
}else if(this.getScore ()==o.getScore ()){
return 0;
}else{
return -1;
}
}
}
public class StudentsTest {
public static void main(String[] args) {
Student s1 = new Student (90, "琼文");
Student s2 = new Student (89, "莫兰");
Student s3= new Student (98, "泽文");
Student s4 = new Student (76, "宇华");
TreeSet<Student> set = new TreeSet<> ( );
set.add (s1);
set.add(s2);
set.add(s3);
set.add(s4);
Iterator<Student> iterator = set.iterator ( );
int i=0;
while(i<3&&iterator.hasNext ()){
System.out.println (iterator.next ( ).getName ());
i++;
}
}
}