黑马程序员--集合
来源:互联网 发布:手机棋牌游戏辅助软件 编辑:程序博客网 时间:2024/06/05 20:13
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;}@Overridepublic int hashCode() {return this.name.hashCode() + this.age * 17;}@Overridepublic 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;}@Overridepublic 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> {@Overridepublic 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// 先获取所有丈夫的集合。keySetSet<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;}@Overridepublic int hashCode() {return this.name.hashCode() + this.age * 13;}@Overridepublic 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>() {@Overridepublic 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的方法,底层结构是二叉树时需要实现集合或对象的比较性.
- 黑马程序员:集合类
- 黑马程序员 集合类
- 黑马程序员:集合框架
- 黑马程序员---集合
- 黑马程序员_java集合
- 黑马程序员_集合
- 黑马程序员 java 集合
- 黑马程序员-集合相关
- 黑马程序员,集合List
- 黑马程序员-List集合
- 黑马程序员_集合
- 黑马程序员-集合框架
- 黑马程序员-集合
- 黑马程序员-集合框架
- 黑马程序员-集合总结
- 黑马程序员-集合类
- 黑马程序员---集合,泛型
- 黑马程序员 集合学习
- 计算机网络(谢)——第三章读书笔记3.2
- Android 学习笔记(3) --linearlayout
- 计算机网络(谢)——第三章读书笔记3.4
- oracle经验分享1.0 最实用的初始化库语句
- java和javac命令
- 黑马程序员--集合
- 计算机网络(谢)——第三章读书笔记3.5
- poj 1065 Wooden Sticks(贪心算法)
- 计算机网络(谢)——第四章读书笔记4.2
- MyEclipse下安装插件(jigloo_464.zip为例)
- struts环境搭建
- 计算机网络(谢)——第三章读书笔记4.3
- Dirichlet分布
- 计算机网络(谢)——第三章读书笔记4.4