黑马程序员 java学习笔记 Day4:集合
来源:互联网 发布:mac ppt动画顺序调整 编辑:程序博客网 时间:2024/06/06 16:28
-----------android培训、java培训、java学习型技术博客、期待与您交流!------------
集合框架
学习之前先了解一下大致的示意图
这就是集合框架的构成。由于数据结构的不同,有不同的集合,也叫容器。下面是集合类的简单介绍。
1、为什么出现集合类?
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
2、数组和集合类同是容器,有何不同?
数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。数组中可以存储基本数据类型,集合只能存储对象。
3、集合类的特点
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
Collection
Collection是集合框架中的常用接口。其下有两个子接口:List(列表),Set(集)。
所属关系:
Collection
|--List//元素是有序的,元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的,元素不可以重复。
1、Collection接口中的常见操作
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数,集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注:集合中存储的都是对象的引用(地址)。
2、迭代
1、概述
迭代是取出集合中元素的一种方式。
对于集合的元素取出这个动作:
当不足以用一个函数来描述,需要用多个功能来体现,所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部,这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同,所以取出的动作细节也不一样。但是都具有共性内容: 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则(或者说都抽取出来一个规则)。该规则就是Iterator。通过一个对外提供的方法:iterator();,来获取集合的取出对象。
因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。
2、迭代的常见操作
hasNext();//有下一个元素,返回真
next();//取出下一个元素
remove();//移除
注:在迭代时循环中next调用一次,就要hasNext判断一次。
使用:
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器,用于取出集合中的元素。
第一种打印方式:
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}
第二种打印方式:
Iteratoriter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
3、迭代注意事项
- 迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。
- 迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。
- 迭代器的next方法返回值类型是Object,所以要记得类型转换。
第三讲 List
一、List
组成
List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
3、List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素,若省略位置参数,则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置,如果没有则返回-1
注:List集合判断元素是否相同,移除等操作,依据的是元素的equals方法。
4、ListIterator
1、概述
ListIterator是List集合特有的迭代器,是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时,只能用迭代器的方法操作元素。可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。如果想要其他的操作,如添加、修改等,就需要使用其子接口:ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
5、枚举Enumeration
枚举:
就是Vector特有的取出方式。Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法:
addElement(obj);//添加元素,相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
例:
- Vector v=new Vector();
- for(Enumeration e=v.elements();e.hasMoreElements();)
- {
- System.out.println(e.nextElements());
- }
6、LinkedList
LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
特有方法:
1、增
addFirst();
addLast();
2、获取
//获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后,出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素,但是不删除。如果集合中没有元素,会返回null。
peekFirst();
peekLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
示例:
- /*
- 使用LinkedList模拟一个堆栈或者队列数据结构。
- 堆栈:先进后出 如同一个杯子。
- 队列:先进先出 First in First out FIFO 如同一个水管。
- */
- import java.util.*;
- class LinkedListTest
- {
- public static void main(String[] args)
- {
- LinkedList l=new LinkedList();
- l.addFirst("java01");
- l.addFirst("java02");
- l.addFirst("java03");
- l.addFirst("java04");
- l.addFirst("java05");
- //堆栈输出
- // stack(l);
- //队列输出
- queue(l);
- }
- //堆栈
- public static void stack(LinkedList l)
- {
- while (!l.isEmpty())
- {
- sop(l.removeFirst());
- }
- }
- //队列
- public static void queue(LinkedList l)
- {
- while(!l.isEmpty())
- {
- sop(l.removeLast());
- }
- }
- //输出
- public static void sop(Object obj)
- {
- System.out.println(obj);
- }
- }
Set
1、概述
Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
|--HashSet:底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理:判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0。
Set集合的功能和Collection是一致的。
2、HasSet
HashSet:线程不安全,存取速度快。
可以通过元素的两个方法,hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
注意:HashSet对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
示例:
- /*
- 往hashSet集合中存入自定对象
- 姓名和年龄相同为同一个人,重复元素。去除重复元素
- 思路:1、对人描述,将人的一些属性等封装进对象
- 2、定义一个HashSet容器,存储人对象
- 3、取出
- */
- import java.util.*;
- //人描述
- class Person
- {
- private String name;
- private int age;
- Person(String name,int age)
- {
- this.name=name;
- this.age=age;
- }
- public String getName()
- {
- return name;
- }
- public int getAge()
- {
- return age;
- }
- public boolean equals(Object obj)
- {
- if(!(obj instanceof Person))
- return false;
- Person p=(Person)obj;
- return this.name.equals(p.name)&&this.age==p.age;
- }
- public int hashCode()
- {
- return this.name.hashCode()+this.age;
- }
- }
- class HashSetTest
- {
- public static void main(String[] args)
- {
- HashSet h=new HashSet();
- h.add(new Person("shenm",10));
- h.add(new Person("shenm2",6));
- h.add(new Person("shenm1",30));
- h.add(new Person("shenm0",10));
- h.add(new Person("shenm0",10));
- getOut(h);
- }
- //取出元素
- public static void getOut(HashSet h)
- {
- for (Iterator it=h.iterator(); it.hasNext(); )
- {
- Person p=(Person)it.next();
- sop(p.getName()+"..."+p.getAge());
- }
- }
- //打印
- public static void sop(Object obj)
- {
- System.out.println(obj);
- }
- }
3、TreeSet
1、特点
a、底层的数据结构为二叉树结构(红黑树结构)
b)可对Set集合中的元素进行排序,是因为:TreeSet类实现了Comparable接口,该接口强制让增加到集合中的对象进行了比较,需要复写compareTo方法,才能让对象按指定需求(如人的年龄大小比较等)进行排序,并加入集合。
java中的很多类都具备比较性,其实就是实现了Comparable接口。
注意:排序时,当主要条件相同时,按次要条件排序。
二叉树示意图
c、保证数据的唯一性的依据:通过compareTo方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同。相等时则不会存入。
2、Tree排序的两种方式
1)第一种排序方式:自然排序
让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
示例:
- import java.util.*;
- //学生类
- class Student implements Comparable
- {
- private String name;
- private int age;
- Student(String name,int age)
- {
- this.name=name;
- this.age=age;
- }
- public String getName()
- {
- return name;
- }
- public int getAge()
- {
- return age;
- }
- //复写hashCode以便HashSet集合调用
- public int hashCode()
- {
- return name.hashCode()+age;
- }
- //复写equals以便HashSet集合和集合中一些比较方法调用
- public boolean equals(Object obj)
- {
- if(!(obj instanceof Student))
- throw new RuntimeException();
- Student s = (Student)obj;
- return this.name.equals(s.name)&&this.age==s.age;
- }
- //复写compareTo以便TreeSet集合调用
- public int compareTo(Object obj)
- {
- Student s=(Student)obj;
- if(this.age==s.age)
- return this.name.compareTo(s.name);
- return this.age-s.age;
- //return new Integer(this.age).compareTo(new Integer(s.age));
- }
- }
- class TreeSetTest
- {
- public static void main(String[] args)
- {
- TreeSet<Student> t=new TreeSet<Student>();
- t.add(new Student("wo1",12));
- t.add(new Student("wosj",2));
- t.add(new Student("wo1sdj",12));
- t.add(new Student("wo6sd",12));
- t.add(new Student("wo",22));
- for (Iterator<Student> it=t.iterator(); it.hasNext(); )
- {
- Student s=it.next();
- System.out.println(s.getName()+"....."+s.getAge());
- }
- }
- }
2)第二种方式:比较器
当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法。
当两种排序都存在时,以比较器为主。
示例:
- /*
- 需求:
- 往TreeSet集合中存储自定义对象学生。
- 想按照学生的年龄进行排序。
- */
- import java.util.*;
- //学生类
- class Student implements Comparable
- {
- private String name;
- private int age;
- Student(String name,int age)
- {
- this.name=name;
- this.age=age;
- }
- public String getName()
- {
- return name;
- }
- public int getAge()
- {
- return age;
- }
- //复写hashCode以便HashSet集合调用
- public int hashCode()
- {
- return name.hashCode()+age;
- }
- //复写equals以便HashSet集合和集合中一些比较方法调用
- public boolean equals(Object obj)
- {
- if(!(obj instanceof Student))
- throw new RuntimeException();
- Student s = (Student)obj;
- return this.name.equals(s.name)&&this.age==s.age;
- }
- //复写compareTo以便TreeSet集合调用
- public int compareTo(Object obj)
- {
- Student s=(Student)obj;
- if(this.age==s.age)
- return this.name.compareTo(s.name);
- return this.age-s.age;
- //return new Integer(this.age).compareTo(new Integer(s.age));
- }
- }
- class TreeSetTest
- {
- public static void main(String[] args)
- {
- TreeSet<Student> t=new TreeSet<Student>(new LenCompare());
- t.add(new Student("wo1",12));
- t.add(new Student("wosj",2));
- t.add(new Student("wo1sdj",12));
- t.add(new Student("wo6sd",12));
- t.add(new Student("wo",22));
- for (Iterator<Student> it=t.iterator(); it.hasNext(); )
- {
- Student s=it.next();
- System.out.println(s.getName()+"....."+s.getAge());
- }
- }
- }
- //定义一个比较器,以姓名长度为主要比较
- class LenCompare implements Comparator<Student>
- {
- public int compare(Student s1,Student s2)
- {
- int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));
- if (num==0)
- {
- return new Integer(s1.getAge()).compareTo(s2.getAge());
- }
- return num;
- }
- }
Map集合
1、概述
1、简述:
Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)
2、特点:
1)该集合存储键值对,一对一对往里存
2)要保证键的唯一性。
2、Map集合的子类
Map
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。JDK1.0,效率低。
|--HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
3、Map集合的常用方法
1、添加
Vput(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。
voidputAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值,返回一个Collection集合
还有两个取出方法,接下来会逐个讲解:
Set<Map.Entry<K,V>>entrySet();
Set<K> keySet();
注:HashMap集合可以通过get()方法的返回值来判断一个键是否存在,通过返回null来判断。
4、Map集合的两种取出方式
Map集合的取出原理:将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
2、Set<Map.Entry<K,V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry
其实,Entry也是一个接口,它是Map接口中的一个内部接口。
|--List//元素是有序的
几个面试常见问题:
1.Q:ArrayList和Vector有什么区别?HashMap和HashTable有什么区别?A:Vector和HashTable是线程同步的(synchronized)。性能上,ArrayList和HashMap分别比Vector和Hashtable要好。
2.Q:大致讲解java集合的体系结构
A:List、Set、Map是这个集合体系中最主要的三个接口。
其中List和Set继承自Collection接口。
Set不允许元素重复。HashSet和TreeSet是两个主要的实现类。
List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。
Map也属于集合系统,但和Collection接口不同。Map是key对value的映射集合,其中key列就是一个集合。key不能重复,但是value可以重复。HashMap、TreeMap和Hashtable是三个主要的实现类。
SortedSet和SortedMap接口对元素按指定规则排序,SortedMap是对key列进行排序。
3.Q:Comparable和Comparator区别
A:调用java.util.Collections.sort(List list)方法来进行排序的时候,List内的Object都必须实现了Comparable接口。
java.util.Collections.sort(List list,Comparator c),可以临时声明一个Comparator 来实现排序。
Collections.sort(imageList, new Comparator() {
public int compare(Object a, Object b) {
int orderA = Integer.parseInt( ( (Image) a).getSequence());
int orderB = Integer.parseInt( ( (Image) b).getSequence());
return orderA - orderB;
}
});
如果需要改变排列顺序
改成return orderb - orderA 即可。
- 黑马程序员 java学习笔记 Day4:集合
- 黑马程序员-java集合 学习笔记
- 黑马程序员java学习笔记,集合
- 黑马程序员-java基础-集合学习笔记
- 黑马程序员------java学习笔记之集合
- 黑马程序员---java学习笔记之集合
- 黑马程序员-java学习笔记-集合框架
- java学习笔记day4
- 黑马程序员-学习笔记-集合
- “黑马程序员”-java集合笔记
- 黑马程序员---- Java学习笔记:1.异常 2.集合
- 黑马程序员--Java学习笔记之集合框架
- 黑马程序员---java学习笔记之map集合
- 黑马程序员---java学习笔记之集合工具类
- 黑马程序员——学习笔记08.Java集合
- JAVA集合框架 黑马程序员学习笔记(11)
- 黑马程序员 Java基础学习笔记 集合类
- 黑马程序员 JAVA学习笔记 ——集合框架
- 前端不为人知的一面--前端冷知识集锦
- android关于uses-permission权限列表
- 将 Django 应用程序部署到生产服务器
- 测试oracle连接池最大连接数
- 80x86汇编学习笔记
- 黑马程序员 java学习笔记 Day4:集合
- PowerDesingner--java代码生成类图
- RMAN备份与恢复—对数据库进行完全介质恢复
- git 常用命令使用实践总结-wish
- 在widgetoneIDE环境下使用HTML5和jQueryMobile控件编写UI界面-九宫格
- 微信公众号开发系列-开发环境要求和准备工作
- hadoop 学习笔记:mapreduce框架详解
- Objective-C Runtime 运行时之一:类与对象
- Java程序员笔试面试之Java基础