JAVA中的集合
JAVA中集合，是java中的基础概念，今天接着跟讲课准备课件的机会，重新整理一下关于JAVA中的集合的概念。
集合的概念
- java中的集合类是用来存放对象的
- 集合相当于一个容器，里面包容着一组对象--容器类
- 其中的每个对象作为集合的一个元素出现
- java API提供的集合类位于java.util包中
java中集合和数组的比较
- 数组也是容器，它是定长，访问较快，但是数组不会自动扩充
- 数组可以包含基本数据类型或者是引用类型的对象，而集合中只能包含引用类型的对象
为了容纳一组对象，最适宜的选择应当是数组。而且假如容纳的是一系列基本数据类型，更是必须采用数组。当我们编写程序 时，通常并不能确切地知道最终需要多少个对象。有些时候甚至 想用更复杂的方式来保存对象。为解决这个问题，Java提供了集合框架。
集合的特点：
- 用于存储对象的容器。
- 集合长度是可变的
- 集合中不可以存储基本数据类型值，只能存储对象
集合的学习目标
（1）集合本身是一个存储的容器
（2）必须使用集合存储对象
（3）遍历集合,取出对象
（4）集合体系中有很多的集合，每个集合都有自己的特性，要知道每个集合有什么特点。
集合类型主要有3种：set(集）、list(列表）和map(映射)。
JAVA中的集合框架
集合容器因为内部的数据结构不同，有多种具体容器。 不断的向上抽取，就形成了集合框架。
Collection接口
我们先来看集合体系中最顶层的接口 Collection接口
Collection是层次结构中的根接口，Collection表示一组对象，这些对象也称为Collection中的元素，一些collection允许有重复的元素，如List，而有一些是不允许有重复元素 ，一些事有序的，一些是无序的，List派系的集合就是有序的，而Set接口集合里面的是无序的。
我们先学习他们共性的东西，Collection接口
Collection的功能由它实现类决定
- 1. List允许重复,有序(先添加在前,后添加的元素位置在后)
- 2. Set不允许重复,无序(跟添加的先后无关，只跟元素本身的hashCode值)
Collection接口中的方法，这些方法是集合中所有实现类必须拥有的方法 Collection接口中的方法都是抽象方法，所以使用Collection接口的实现类 例如：ArrayList implements List List extends Collection 方法的执行,都是实现的重写
- add(); 向集合添加数据
- toArray();集合中的元素,转成一个数组中的元素, 集合转成数组
- clear(); 清空集合中的所有的元素
- remove(); boolean remove(Object o)移除集合中指定的元素
- contains(Object obj); 判断对象是否是存在集合中，对象存在返回true size();
我们通过一个简单的例子来演示一下方法的具体的使用
//toArray()方法和clear()方法
private static void function() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("def");
coll.add("ghi");
coll.add("gkl");
coll.add("mno");
Object[] objs = coll.toArray();
for(int i = 0 ; i < objs.length ; i++){
System.out.println(objs[i]);
}
}
* void clear() 清空集合中的所有元素
public static void function(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("bcd");
System.out.println(coll);
coll.clear();
System.out.println(coll);
}
private static void function() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("def");
coll.add("ghi");
coll.add("gkl");
coll.add("mno");
Object[] objs = coll.toArray();
for(int i = 0 ; i < objs.length ; i++){
System.out.println(objs[i]);
}
}
* void clear() 清空集合中的所有元素
public static void function(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("bcd");
System.out.println(coll);
coll.clear();
System.out.println(coll);
}
Iterator迭代器
在Java中，有很多的数据容器，对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。使用迭代器我们可以很方便的对集合的元素进行遍历，一次取出集合中的元素。
我们通过查看API可以发现，Iterator中定义了三个方法
我们通过一个例子来演示Iteraror的使用方法
public class IteratorDemo {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//迭代器,对集合ArrayList中的元素进行取出
//调用集合的方法iterator()获取出,Iterator接口的实现类的对象
Iterator<String> it = coll.iterator();
//接口实现类对象,调用方法hasNext()判断集合中是否有元素
boolean b = it.hasNext();
System.out.println(b);
//接口的实现类对象,调用方法next()取出集合中的元素
String s = it.next();
System.out.println(s);
//迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}在Iterator中主要是使用一个面向接口编程的思想
Iterator 是一个接口，我们要找他的实现类。Collection中定义了一个方法Iterator iterator()方法，在使用的时候ArrayList会重写方法iterator()返回了Iterator接口的实现类的对象。使用ArrayList集合的对象， Iterator it = array.iterator(),运行结果就是Iterator接口的实现类的对象。it是接口的实现类对象,调用方法 hasNext 和 next 集合元素迭代
增强for循环
这里介绍的增强for循环也是一种遍历集合的方式
jdk1.5出现的新特性---->增强for循环 ，JDK1.5版本后,出现新的接口 java.lang.Iterable，Collection开是继承Iterable，Iterable作用,实现增强for循环
增强for循环的作用：
简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历。)
增强for循环的适用范围： 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。
增强for循环的格式： for(数据类型 变量名 :数组或集合) { //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素}
我们也通过一个例子，来具体的演示一下
* 实现for循环,遍历数组
public static void function(){
int[] arr = {4,2,9,0};
for(int i : arr){
System.out.println(i);
}
System.out.println(arr[0]);
}
public static void function_2(){
ArrayList<Person> array = new ArrayList<Person>();
array.add(new Person("a",20));
array.add(new Person("b",10));
for(Person p : array){
System.out.println(p); 打印P就是打印P中的toString()方法，如果没有tostring 就是直接打印的是地址
}
}- 好处: 代码少了,方便对容器遍历 弊端: 没有索引,不能操作容器里面的元素，因为东数组是需要索引的，所以不能用折半查找，排序就不行了
List接口
我们通过集合体系框架图可以发现，List是Collection下的接口，和Collection是继承关系。List下主要有两个实现类，ArrayList、和LinkedList
List接口中的抽象方法,有一部分方法和他的父接口Collection是一样
List接口的自己特有的方法, 带有索引的功能
- add(int index,E) 将元素插入到列表的指定索引上
- E remove(int index) 移除指定索引上的元素,返回被删除之前的元 素
- E set(int index, E) 修改指定索引上的元素,返回被修改之前的元素
我们通过一个案例来具体的演示一下List的使用方式。
指定索引添加元素
public static void function(){
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
list.add(1, "zzu");
System.out.println(list);
}
移除索引上的元素
public static void function_1(){
List<Double> list = new ArrayList<Double>();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d = list.remove(0);
System.out.println(d);
System.out.println(list);
}
修改索引上的元素
public static void function_2(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i = list.set(0, 5);
System.out.println(i);
System.out.println(list);
}Set（集）接口
Set是最简单的集合，集合中的对象不按照特定的方式排序，并且没有重复的对象。
Set接口主要有两个实现类：HashSet和TreeSet。
Set集合是没有索引的，set集合取出元素的方式可以采用：迭代器、增强for循环。
- Set集合中存放的是对象，并且没有重复对象。
- Set接口的实现类，HashSet（哈希表）
- 特点：无序集合,存储和取出的顺序不同,没有索引,不存储重复元素
- 代码：代码的编写上,和ArrayList完全一致
hashSet
HashSet类按照哈希算法来存取集合中的对象， 具有很好的存取和查找性能。
底层数据结构：哈希表
■当向集合中加入一个对象时，HashSet会调用 对象的hashCode()方法来获得哈希码，然后根据哈希码进一步计算出对象在集合中的位置。
底层原理：
我们通过一个简单的例子来演示一下使用方法
public class HashSetDemo {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("cn");
set.add("zzu");
set.add("java");
set.add("java");
set.add("computer");
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("======================");
for(String s : set){
System.out.println(s);
}
}
}
HashSet不能存放重复元素
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add(new String("abc"));
set.add(new String("abc"));
set.add(new String("bbc"));
set.add(new String("bbc"));
System.out.println(set);
}
Map(键值对映射)
Map(映射集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。
Map集合中，元素是成对存在的，每个元素都由健与值两部分组成，通过健可以找到所对应的值。
向Map集合中加入元素时，必须提供一对键对象和值对象。
Map中常用的集合为HashMap集合，LinkedHashMap集合
- 使用Map接口的实现类 HashMap V put(K,V) K 作为键的对象, V作为值的对象，返回值为V
public static void function(){
//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
System.out.println(map);
}使用Map接口的实现类 HashMap V get(K) ，如果集合中没有这个键,返回null
public static void function(){
//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
System.out.println(map);
}Map集合的遍历
Map集合的遍历：利用键获取值，Map接口中定义方法keySet，取出所有的键,存储到Set集合
- 1.调用map集合的方法keySet,所有的键存储到Set集合中， Map集合不能直接遍历，必须借助一个第三方的集 合Set，先存储健
- 2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
- 3. 调用map集合方法get,通过键获取到值 程序演示
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("a", 11);
map.put("b", 12);
map.put("c", 13);
map.put("d", 14);
//1. 调用map集合的方法keySet,所有的键存储到Set集合中
Set<String> set = map.keySet();
//2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
Iterator<String> it = set.iterator();
while(it.hasNext()){
//it.next返回是Set集合元素,也就是Map中的键
//3. 调用map集合方法get,通过键获取到值
String key = it.next();
Integer value = map.get(key);
System.out.println(key+"...."+value);
}
使用增强for循环进行遍历，增强for不能遍历Map 但是可以遍历set集合，取值
System.out.println("=======================");
for(String key : map.keySet()){
Integer value = map.get(key);
System.out.println(key+"...."+value);
}
}Entry键值对对象
在Map类设计的时候，提供了一个嵌套接口：Entry。
Entry将健值对的对应关系封装成了对象，即键值对对象，这样我们在遍历Map集合时，就可以从每一个健值对Entry对象中获取对应的健与对应的值。
Map集合获取方式--entrySet方法,键值对映射关系获取
实现步骤:
- 1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合 Set<Entry <K,V> >
- 2. 迭代Set集合
- 3. 获取出的Set集合的元素,是映射关系对象
- 4. 通过映射关系对象方法 getKet, getValue获取键值对
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "cde");
//1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
Set<Map.Entry <Integer,String> > set = map.entrySet();
//2. 迭代Set集合
Iterator<Map.Entry <Integer,String> > it = set.iterator();
while(it.hasNext()){
// 3. 获取出的Set集合的元素,是映射关系对象
Map.Entry<Integer, String> entry = it.next();
//4. 通过映射关系对象方法 getKet, getValue获取键值对
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"...."+value);
}
System.out.println("=========================");
for(Map.Entry<Integer, String> entry : map.entrySet()){
System.out.println(entry.getKey()+"..."+entry.getValue());
}
}
本文主要是简单的介绍一下集合中部分的方法的使用，以及一些实现类的使用。是对平时学习集合这一章节的总结，如有写错欢迎大家批评指正。