1.集合框架
集合的作用:面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式.
集合的特点:集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象.
集合和数组的区别:数组虽然也可以存储对象，但长度是固定的；集合长度是可变的,数组中可以存储基本数据类型，也可以存储对象,集合只能存储对象;数组存储的多个元素是同一种数据类型,集合可以存储多种引用类型的元素.
集合框架
2.Collection接口
Collection接口的有两个子接口:List和Set,List元素有序,元素可以重复,Set元素无序,元素要求唯一.
Collection接口的功能：
1:添加元素
boolean add(Object obj):添加单个元素
boolean addAll(Collection c):添加多个元素
2:判断元素
boolean contains(Object obj):判断元素是否存在
boolean containsAll(Collection c):判断一个集合的元素是否包含在当前集合中
boolean isEmpty():判断集合是否为空
3:删除元素
void clear():移除所有元素
boolean remove(Object o):移除单个元素,有一个删除，就返回true
boolean removeAll(Collection c):移除多个元素
4:获取元素
Iterator iterator():返回集合上的一个迭代器
5:交集
boolean retainAll(Collection c):交集
6:集合元素个数
int size():元素个数
7:把集合转成数组
Object[] toArray()
迭代器Iterator
迭代就是取出集合中元素的一种方式.
迭代器的方法:
boolean hasNext()判断是否还有元素可以迭代
next()返回迭代的下一个元素,获取的元素默认为Object类
注意:1.迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)
2.迭代器的next()方法是自动向下取元素，要避免出现NoSuchElementException
3.迭代器的next方法返回值类型是Object，所以要记得类型转换
3.List
List接口的功能
1：添加元素
void add(int index, Object element):在指定位置添加指定元素
2：获取元素
Object get(int index):根据指定索引获取元素
3：列表迭代器
ListIterator listIterator()
4：删除元素
Object remove(int index):返回并删除指定位置的元素
5：修改元素
Object set(int index, Object element):修改指定位置的元素
List特有的迭代器
列表迭代器ListIterator的方法：
void add(E e) 将指定的元素插入列表（可选操作）。
boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
int nextIndex() 返回对 next 的后续调用所返回元素的索引。
E previous() 返回列表中的前一个元素。
int previousIndex() 返回对 previous 的后续调用所返回元素的索引。
void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
注意:ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素.
实现List的类
ArrayList底层数据结构是数组，查询快，增删慢;线程不安全，效率高.
Vector底层数据结构是数组，查询快，增删慢;线程安全，效率低.
LinkedList底层数据结构是链表，查询慢，增删快;线程不安全，效率高。
问题:开发中如何选择使用哪个类?
先看程序是否是否考虑线程安全问题,如果考虑,使用Vector;如果不考虑,如果是查询多，增删少，用ArrayList;如果是查询少，增删多，用LinkedList.
ArrayList
底层数据结构是数组,查询快增删慢,线程不安全
/*
* 已知Person类,具有姓名年龄属性,用ArrayList存储对象并遍历
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 创建元素对象
Person p1 = new Person("刘备", 55);
Person p2 = new Person("关羽", 50);
Person p3 = new Person("张飞", 35);
// 添加元素
array.add(p1);
array.add(p2);
array.add(p3);
// 遍历
Iterator it = array.iterator();
while (it.hasNext()) {
Person p = (Person) it.next();
System.out.println(p.getName() + "***" + p.getAge());
}
}
}Vector
底层数据结构是数组，所以也具有查询快增删慢的特性,但它线程是同步的，故线程安全,但效率较低,使用中一般被ArrayList所取代.
Vector的特有方法
1.添加元素
void addElement(Object obj) JDK1.2 后改为了add(Object obj)
2.获取元素
Object elementAt(int index) JDK1.2后就改为了get(int index)
3.遍历元素
Enumeration elements() JDK1.2后就改为Iterator iterator()
boolean hasMoreElements() JDK1.2后就改为boolean hasNext()
Object nextElement() JDK1.2后就改为了 Object next()
练习:使用Vector存储元素并遍历
public class VectorDemo {
public static void main(String[] args) {
// 创建集合对象
Vector v = new Vector();
// 添加元素
v.addElement("hello");
v.addElement("world");
v.addElement("java");
// 遍历
Enumeration en = v.elements();
while (en.hasMoreElements()) {
String s = (String) en.nextElement();
System.out.println(s);
}
}
}LinkedList
底层数据结构是链表,查询慢增删快,线程不安全
LinkedList的特有方法：
1.添加元素
void addFirst(Object obj)
void addLast(Object obj)
2.删除元素
Object removeFirst()获取首个元素并删除
Object removeLast()
3.获取元素
Object getFirst()
Object getLast()
public class LinkedListDemo {
public static void main(String[] args) {
// 创建集合对象
LinkedList link = new LinkedList();
// 添加元素
link.add("hello");
link.add("world");
// 特殊添加方法
link.addFirst("itcast");
// 和add方法一样
link.addLast("over");
link.add("java");
// 获取元素
System.out.println("getFirst:" + link.getFirst());
System.out.println("getLast:" + link.getLast());
// 遍历
Iterator it = link.iterator();
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}
}
} 4.Set
Set接口里面存放的是元素是无序唯一的，可以包含null.Set集合是无序的,因此只能用迭代器获取元素.Set的子类包括HashSet和TreeSet
HashSet
底层数据结构是哈希表，哈希表结构的数据都是无序的
保证元素唯一性的原理：通过复写hashCode和equals方法排除相同的元素,集合首先会根据hashCode方法去判断哈希值是否相同，如果不同，则认为是不同的元素，就添加到集合中;如果相同，就会运行equals方法，如果返回值是true，说明该元素在集合中存在，就不添加,如果返回值是false，直接添加元素.
复写hashCode和equals的方法
public class Person {
private String name;
private int age;
private boolean sex;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
return this.name.hashCode() + this.age * 17;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Person)) {
return false;
}
Person p = (Person) obj;
return this.name.equals(p.name) && this.age == p.age;
}TreeSet
底层数据结构是二叉树，二叉树结构都是有序的
TreeSet集合保证元素唯一性的原理是：
1.定义元素类实现Compareble接口，覆盖compareTo方法
2.让集合具备比较性,即定义一个类，实现Comparator接口，覆盖compare方法。
方案1：让自定义对象实现Comparable接口
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Person p) {
int num = p.age - this.age;
//年龄相同的时比较姓名是否相同
int num2 = (num == 0) ? this.name.compareTo(p.name) : num;
return num2;
}
}方案2：让集合具备比较性,TreeSet接受实现Comparator接口的子类对象
public class MyComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
// 按照年龄从小到大的顺序比较
int num = p1.getAge() - p2.getAge();
int num2 = (num == 0) ? p1.getName().compareTo(p2.getName()) : num;
return num2;
}
}5.Map
Map<K,V>:Map存储的是键值对形式的元素,它的每一个元素，都是由键和值两个元素组成,键是不能有重复的，值是可以重复的,每一个键唯一指向一个值.
Collection和Map有什么区别？
Collection：存储的元素就是单一元素,使用add方法
Map：存储的元素是成对出现的,使用put方法,Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素,而且Map集合中键要保证唯一性
Map接口的功能
1.添加功能：
V put(K key, V value)
与add的区别:put--如果key已经存在，则新存入的值覆盖原来的值，并把原来的值作为方法的返回值；add--如果该元素已经存在，则不能存入集合，方法返回值为false，如果不存在，则存入集合，方法返回值为true.
2.判断功能：
boolean containsKey(Object key) 判断是否包含某个键
boolean containsValue(Object value) 判断是否包含某个值
boolean isEmpty() 判断是否为空集合
3.删除功能：
void clear()
V remove(Object key)
4. 获取功能：
Set<Map.Entry<K,V>> entrySet() 获取键值对关系的集合
Set<K> keySet() 获取键的集合
V get(Object key) 根据键获取值
Collection<V> values() 值得集合,值是可以重复的
5.长度：
int size()
实现Map的类
Hashtable：底层数据结构是哈希表,不可以存入null键null值,线程安全,效率低.
HashMap：底层数据结构是哈希表,允许存入null键null值,线程不安全,效率高.
TreeMap：底层数据结构是二叉树,线程不安全.
Map集合元素的获取方式
方式1：
A:先获取键的集合
B:遍历键的集合,获取每一个键
C:根据键获取值
方式2：
A:先获取键值对关系的集合
B:遍历键值对关系的集合获取每个键值对的关系
C:通过键值对关系获取键值
public class MapDemo3 {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 添加元素
map.put("杨过", "小龙女");
map.put("郭靖", "黄蓉");
map.put("牛郎", "织女");
map.put("后羿", "嫦娥");
// 方式1
// 先获取所有丈夫的集合。keySet
Set<String> keySet = map.keySet();
Iterator<String> keyIt = keySet.iterator();
while (keyIt.hasNext()) {
// 获取键
String key = keyIt.next();
// 获取值
String value = map.get(key);
System.out.println(key + "***" + value);
}
System.out.println("***********************************");
// 方式2
// 先获取键值关系的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
// 遍历键值关系
for (Map.Entry<String, String> me : entrySet) {
// 通过键值关系获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "***" + value);
}
}
}HashMap
底层数据结构是哈希表,可以存入null键null值,线程不安全,效率高.
练习:使用HashMap存储Student元素,并遍历,要求键是Student类型：表示学生对象(name,age);值是String类型：表示学号.同名同年龄为同一人,为避免加入相同元素,需要复写hashCode和equals方法
public class HashMapDemo {
public static void main(String[] args) {
// 创建集合对象
HashMap<Student, String> hs = new HashMap<Student, String>();
// 创建元素对象
Student s1 = new Student("张嘉译", 50);
Student s2 = new Student("刘嘉玲", 45);
Student s3 = new Student("乐嘉", 40);
Student s4 = new Student("刘嘉玲", 45);
// 添加元素
hs.put(s1, "yl001");
hs.put(s2, "yl002");
hs.put(s3, "yl003");
hs.put(s4, "yl004");
// 遍历获取
Set<Student> set = hs.keySet();
for (Student key : set) {
String value = hs.get(key);
System.out.println(key.getName() + "***" + key.getAge() + "***"
+ value);
}
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
return this.name.hashCode() + this.age * 13;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Student)) {
return false;
}
Student s = (Student) obj;
return this.name.equals(s.name) && this.age == s.age;
}
}TreeMap
底层数据结构是二叉树,线程不安全.底层是二叉树,当定义的键值对要求有序时,使用TreeMap.
/*
*需求：按照学生的年龄从大到小排序。
*/
public class TreeMapDemo {
public static void main(String[] args) {
// 创建集合对象
TreeMap<Student, String> hs = new TreeMap<Student, String>(
new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s2.getAge() - s1.getAge();
int num2 = (num == 0) ? s1.getName().compareTo(
s2.getName()) : num;
return num2;
}
});
// 创建元素对象
Student s1 = new Student("张嘉译", 50);
Student s2 = new Student("刘嘉玲", 45);
Student s3 = new Student("乐嘉", 40);
Student s4 = new Student("刘嘉玲", 45);
// 添加元素
hs.put(s1, "yl001");
hs.put(s2, "yl002");
hs.put(s3, "yl003");
hs.put(s4, "yl004");
// 遍历
Set<Student> set = hs.keySet();
for (Student key : set) {
String value = hs.get(key);
System.out.println(key.getName() + "***" + key.getAge() + "***"
+ value);
}
}
}学习感悟
个人感觉集合框架是很重要的,内容和方法也很多.但只要掌握他们的区别,使用时就会很得心应手.先确定集合元素是单个对象还是键值对,再确定元素是否有序,最后再确定是否要求线程安全.这样就可以准确选取需要使用的集合类型了.另外,当使用底层结构是哈希值表的集合类型时需要重写hashCode和equals的方法，底层结构是二叉树时需要实现集合或对象的比较性.
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
