java集合.docx
《java集合.docx》由会员分享，可在线阅读，更多相关《java集合.docx（22页珍藏版）》请在冰点文库上搜索。
java集合
Collection
|--List:
元素是有序的，元素可以重复。
因为该集合体系有索引。
|--ArrayList:
底层的数据结构使用的是数组结构。
特点：
查询速度很快。
但是增删稍慢。
线程不同步。
|--LinkedList:
底层使用的链表数据结构。
特点：
增删速度很快，查询稍慢。
线程不同步。
|--Vector:
底层是数组数据结构。
线程同步。
被ArrayList替代了。
因为效率低。
|--Set：
元素是无序，元素不可以重复。
、
1，添加
add（e）;
addAll（collection）;
2，删除
remove（e）;
removeAll（collection）;
clear（）;
3，判断。
contains（e）;
isEmpty（）;
4，获取
iterator（）;
size（）;
5，获取交集。
retainAll（）;
6，集合变数组。
toArray（）;
7,查
get（index）:
subList（from,to）;
listIterator（）;
intindexOf（obj）:
获取指定元素的位置。
ListIteratorlistIterator（）;
1，add方法的参数类型是Object。
以便于接收任意类型对象。
2，集合中存储的都是对象的引用（地址）
迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator（）方法获取该内部类的对象。
在迭代时循环中next调用一次，就要hasNext判断一次。
Iteratorit=al.iterator（）;
while（it.hasNext（））
{
sop（it.next（）+"...."+it.next（））;
}
LinkedList:
特有方法：
addFirst（）;
addLast（）;
getFirst（）;
getLast（）;
获取元素，但不删除元素。
如果集合中没有元素，会出现NoSuchElementException
removeFirst（）;
removeLast（）;
获取元素，但是元素被删除。
如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst（）;
offerLast（）;
peekFirst（）;
peekLast（）;
获取元素，但不删除元素。
如果集合中没有元素，会返回null。
pollFirst（）;
pollLast（）;
获取元素，但是元素被删除。
如果集合中没有元素，会返回null。
|--Set：
元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
、
|--HashSet:
底层数据结构是哈希表。
是线程不安全的。
不同步。
HashSet是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
Set集合的功能和Collection是一致的。
枚举就是Vector特有的取出方式。
其实枚举和迭代是一样的。
classVectorDemo
{
publicstaticvoidmain（String[]args）
{
Vectorv=newVector（）;
v.add（"chrp01"）;
v.add（"chrp02"）;
v.add（"chrp03"）;
v.add（"chrp04"）;
Enumerationen=v.elements（）;
while（en.hasMoreElements（））
{
System.out.println（en.nextElement（））;
}
}
}
Set:
无序，不可以重复元素。
|--HashSet：
数据结构是哈希表。
线程是非同步的。
保证元素唯一性的原理：
判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：
可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return0.
TreeSet排序的第一种方式：
让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
排序时，当主要条件相同时，一定判断一下次要条件。
按照字符串长度排序。
使用比较器。
class TreeSetTest
{
publicstaticvoidmain（String[]args）
{
TreeSetts=newTreeSet（newStrLenComparator（））;
ts.add（"abcd"）;
ts.add（"cc"）;
ts.add（"cba"）;
ts.add（"aaa"）;
ts.add（"z"）;
ts.add（"hahaha"）;
Iteratorit=ts.iterator（）;
while（it.hasNext（））
{
System.out.println（it.next（））;
}
}
}
classStrLenComparatorimplementsComparator
{
publicintcompare（Objecto1,Objecto2）
{
Strings1=（String）o1;
Strings2=（String）o2;
intnum=newInteger（s1.length（））.compareTo（newInteger（s2.length（）））;
if（num==0）
pareTo（s2）;
returnnum;
}
}
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
泛型格式：
通过<>来定义要操作的引用数据类型。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
classGenericDemo
{
publicstaticvoidmain（String[]args）
{
ArrayListal=newArrayList（）;
al.add（"abc01"）;
al.add（"abc0991"）;
al.add（"abc014"）;
Iteratorit=al.iterator（）;
while（it.hasNext（））
{
Strings=it.next（）;
System.out.println（s+":
"+s.length（））;
}
}
}
?
通配符。
也可以理解为占位符。
泛型的限定；
？
extendsE:
可以接收E类型或者E的子类型。
上限。
？
superE:
可以接收E类型或者E的父类型。
下限
publicstaticvoidprintColl（Collection
extendsPerson>al）
{
Iterator
extendsPerson>it=al.iterator（）;
while（it.hasNext（））
{
System.out.println（it.next（）.getName（））;
}
}
将字符串中的数值进行排序。
使用TreeSet完成。
因为TreeSet自身具备排序功能。
classTreeSetTest
{
publicstaticvoidmain（String[]args）
{
ArrayListal=newArrayList（）;
Stringstr="90-70182454";
String[]arr=str.split（""）;
TreeSetts=newTreeSet（）;
for（intx=0;x {
ts.add（Integer.parseInt（arr[x]））;//
}
System.out.println（ts）;
}
}
Map集合：
该集合存储键值对。
一对一对往里存。
而且要保证键的唯一性。
1，添加。
put（Kkey,Vvalue）
putAll（Map
extendsK,?
extendsV>m）
2，删除。
clear（）
remove（Objectkey）
3，判断。
containsValue（Objectvalue）
containsKey（Objectkey）
isEmpty（）
4，获取。
get（Objectkey）
size（）
values（）
entrySet（）
keySet（）
Map
|--Hashtable:
底层是哈希表数据结构，不可以存入null键null值。
该集合是线程同步的。
jdk1.0.效率低。
|--HashMap：
底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。
将hashtable替代，jdk1.2.效率高。
|--TreeMap：
底层是二叉树数据结构。
线程不同步。
可以用于给map集合中的键进行排序。
Set底层就是使用了Map集合。
importjava.util.*;
class MapDemo
{
publicstaticvoidmain（String[]args）
{
Mapmap=newHashMap（）;
//添加元素，如果出现添加时，相同的键。
那么后添加的值会覆盖原有键对应值。
//并put方法会返回被覆盖的值。
System.out.println（"put:
"+map.put（"01","zhangsan1"））;
System.out.println（"put:
"+map.put（"01","wnagwu"））;
map.put（"02","zhangsan2"）;
map.put（"03","zhangsan3"）;
System.out.println（"containsKey:
"+map.containsKey（"022"））;
System.out.println（"get:
"+map.get（"023"））;
map.put（"04",null）;
System.out.println（"get:
"+map.get（"04"））;
//可以通过get方法的返回值来判断一个键是否存在。
通过返回null来判断。
//获取map集合中所有的值。
Collectioncoll=map.values（）;
System.out.println（coll）;
System.out.println（map）;
}
}
map集合的两种取出方式：
1，SetkeySet：
将map中所有的键存入到Set集合。
因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。
获取每一个键对应的值。
Map集合的取出原理：
将map集合转成set集合。
在通过迭代器取出。
2，Set>entrySet：
将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：
Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部，
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
对学生对象的年龄进行升序排序。
importjava.util.*;
classStuNameComparatorimplementsComparator
{
publicintcompare（Students1,Students2）
{
intnum=s1.getName（）.compareTo（s2.getName（））;
if（num==0）
returnnewInteger（s1.getAge（））.compareTo（newInteger（s2.getAge（）））;
returnnum;
}
}
class MapTest2
{
publicstaticvoidmain（String[]args）
{
TreeMaptm=newTreeMap（newStuNameComparator（））;
tm.put（newStudent（"blisi3",23）,"nanjing"）;
tm.put（newStudent（"lisi1",21）,"beijing"）;
tm.put（newStudent（"alisi4",24）,"wuhan"）;
tm.put（newStudent（"lisi1",21）,"tianjin"）;
tm.put（newStudent（"lisi2",22）,"shanghai"）;
Set>entrySet=tm.entrySet（）;
Iterator>it=entrySet.iterator（）;
while（it.hasNext（））
{
Map.Entryme=it.next（）;
Studentstu=me.getKey（）;
Stringaddr=me.getValue（）;
System.out.println（stu+":
:
:
"+addr）;
}
}
}
集合框架的工具类。
Collections:
集合框架的工具类。
里面定义的都是静态方法。
Collections和Collection的区别是：
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：
对元素都有定义索引。
有序的。
可以重复元素。
Set：
不可以重复元素。
无序。
Collections是集合框架中的一个工具类。
该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。
因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
集合变数组。
Collection接口中的toArray方法。
importjava.util.*;
class CollectionToArray
{
publicstaticvoidmain（String[]args）
{
ArrayListal=newArrayList（）;
al.add（"abc1"）;
al.add（"abc2"）;
al.add（"abc3"）;
//1,指定类型的数组的长度：
//当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。
//长度为集合的size。
// 当指定类型的数组长度大于了集合的size，就不会新创建了数组。
而是使用传递进//来的数组。
// 所以创建一个刚刚好的数组最优。
// 2,为什么要将集合变数组？
// 为了限定对元素的操作。
不需要进行增删了。
String[]arr=al.toArray（n
升级会员 