伙伴们,这篇我们介绍集合类,继续来起。
一、概述
1、由来
/**
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
*/
2、与数组的区别
<span style="font-size:14px;">/**
数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。数组中可以存储基本数据类型,集合只能存储对象。
*/</span>
3、特点
/**
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
*/
二、集合体系
1、集合体系图
集合体系图,如下:
三、Collection类
1、简述
/**
Collection接口有两个子接口:List(列表) ,Set(集)。
(1)、List:可存放重复元素,元素存取是有序的。
(2)、Set:不可以存放重复元素,元素存取是无序的。
*/
2、共性方法
/**
(1)添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
(2)删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
(3)判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
(4)获取个数,集合长度
size();
(5)取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注:集合中存储的都是对象的引用(地址)。
*/
3、示例
class CollectionDemo
{
public static void main(String[] args)
{
method_get();
}
public static void method_get()
{
ArrayList al = new ArrayList();
//1,添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
/*
Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素。
while(it.hasNext())
{
sop(it.next());
}
*/
for(Iterator it = al.iterator(); it.hasNext() ; )
{
sop(it.next());
}
}
public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java03");
al2.add("java04");
al2.add("java05");
al2.add("java06");
//al1.retainAll(al2);//去交集,al1中只会保留和al2中相同的元素。
al1.removeAll(al2);
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void base_method()
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1、添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
//打印原集合。
sop("原集合:"+al);
//3、删除元素。
//al.remove("java02");
//al.clear();//清空集合。
//4、判断元素。
sop("java03是否存在:"+al.contains("java03"));
sop("集合是否为空?"+al.isEmpty());
//2、获取个数。集合长度。
sop("size:"+al.size());
//打印改变后的集合。
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/**
示例中出现了迭代iterator,下面为大家介绍一下。
迭代是取出集合中元素的一种方式。
因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。
用法:
第1种表达方式:
for(Iterator iter = iterator();iter.hasNext();)
{
System.out.println(iter.next());
}
第2种表达方式:
Iterator iter = l.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
迭代器的注意事项:
迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object,所以要记得类型转换。
*/
四、List集合
1、定义
/**
Collection
|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快;但是增删稍慢,线程不同步。
|--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢;线程不同步。
|--Vector:底层是数组数据结构。线程同步,被ArrayList替代了;因为效率低。
*/
2、List迭代器介绍
/**
(1) List集合特有的迭代器。ListIterator是Iterator的子接口。
(2)在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以,在迭代器时,只能用迭代器的放过操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。
(3)该接口只能通过List集合的listIterator方法获取。
*/
3、List的特有方法
/**
(1)增
add(index,element);
addAll(index,Collection);
(2)删
remove(index);
(3)改
set(index,element);
(4)查
get(index):
subList(from,to);
listIterator();
int indexOf(obj)://获取指定元素的位置。
ListIterator listIterator();<span style="font-size:14px;"> </span>
示例:import java.util.*;
class ListDemo// List迭代器示例
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method()
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合是:"+al);
//在指定位置添加元素。
al.add(1,"java09");
//删除指定位置的元素。
//al.remove(2);
//修改元素。
//al.set(2,"java007");
//通过角标获取元素。
sop("get(1):"+al.get(1));
sop(al);
//获取所有元素。
for(int x=0; x<al.size(); x++)
{
System.out.println("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while(it.hasNext())
{
sop("next:"+it.next());
}
//通过indexOf获取对象的位置。
sop("index="+al.indexOf("java02"));
List sub = al.subList(1,3);
sop("sub="+sub);
}
public static void main(String[] args)
{
//演示列表迭代器。
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop(al);
ListIterator li = al.listIterator();
//sop("hasPrevious():"+li.hasPrevious());
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
}
while(li.hasPrevious())
{
sop("pre::"+li.previous());
}
//sop("hasNext():"+li.hasNext());
//sop("hasPrevious():"+li.hasPrevious());
sop(al);
/*
//在迭代过程中,准备添加或者删除元素。
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java02"))
//al.add("java008");
it.remove();//将java02的引用从集合中删除了。
sop("obj="+obj);
}
sop(al);
}
}<span style="font-size:18px;">
</span>
4、LinkedList的特有方法
/**
LinkedList:特有方法:
addFirst();
addLast();
getFirst();
getLast();
获取元素,但不删除元素;如果集合中没有元素,会出现NoSuchElementException。
removeFirst();
removeLast();
获取元素,但是元素被删除;如果集合中没有元素,会出现NoSuchElementException。
*/
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
*/
示例:class LinkedListDemo // LinkedList练习
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
//sop(link);
// sop(link.getFirst());
// sop(link.getFirst());
//sop(link.getLast());
//sop(link.removeFirst());
//sop(link.removeFirst());
//sop("size="+link.size());
while(!link.isEmpty())
{
sop(link.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、思考
/**
HashSet:线程不安全,存取速度快。
它是如何保证元素唯一性的呢?
TreeSet: 线程不安全,可以对Set集合中的元素进行排序。
它的排序是如何进行的呢?
*/
3、HashSet集合
(1)特点
底层数据结构时哈希表,且元素取出方式只有迭代器方法。(2)如何保证集合元素的唯一性
/**
HashSet是如何保证元素唯一性的呢?
通过元素的两个方法,hashCode和equals来完成。
a、如果元素的HashCode值相同,才会判断equals是否为true。
b、如果元素的hashcode值不同,不会调用equals。
注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。
*/
(3)示例
示例1:class HashSetDemo//HashSet示例练习
{
public static void sop(Object obj)//封装一个打印函数
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
sop(hs.add("java01"));
sop(hs.add("java01"));
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
Iterator it = hs.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
练习:
import java.util.*;
/**
需求:
往hashSet集合中存入自定对象姓名和年龄相同为同一个人,重复元素。
*/
class HashSetTest
{
public static void sop(Object obj)//定义打印
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person("a1",11));//增加集合元素
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
Iterator it = hs.iterator();//迭代取出
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()//1、判断hashCode是否相同
{
System.out.println(this.name+"....hashCode");
return name.hashCode()+age*37;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person))//2、如果相同,再用equals方法
return false;
Person p = (Person)obj;
System.out.println(this.name+"...equals.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
分享到这里,那么再分享一个小知识点,关于哈希表。
<span style="font-size:14px;">/**
(1)、哈希表是按照哈希值的大小进行排列的,如果两个哈希值不同,则大的值放后面;如果两个哈希值相同,则再用equals方法比较两个元素的对象是否相同,如果不同,则将第二个值顺延,两个值串起来,放在同一个位置上。
(2)、取值时是按照哈希值取出来的。
(3)、哈希值的取值方式:哈希值存入哈希表中,哈希表也称散列表。散列表是存放记录的数组。具体来说,散列表是根据散列函数H(Key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集(区间)上,并以关键字在地址集中的“象”,作为这条记录在表中的存储位置,这种表表称为散列表,这一映象过程就称为散列造表或散列,所存储位置称为散列地址(这是百度百科上的内容)。我的理解是:存入的对象的地址是通过提取其信息摘要,通过散列函数计算而获得的一个关键码(Key)即哈希值,然后将这个值存入哈希表,而哈希表的存值方式是按照哈希值的大小顺序存储的,并且在这个哈希表中有自己的索引,但是哈希表的取值方式并不是按照索引的方式取出的。取出方式是按照哈希表中特有的算法取出的哈希值(注意,现在说的是哈希值,不是元素的取出),这些算法有直接寻址法、折叠法、平方取中法以及其他的一些方法等等。具体是按哪种算法查找的,我并不太清楚,所以,取出的哈希值可能就不是按照哈希值的大小顺序取出的了。
*/</span>
4、TreeSet集合
/**
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第1种方式:让元素自身具备比较性。
元素需要实现Comparable接口,覆盖compareTo方法。
也种方式也成为元素的自然顺序,或者叫做默认顺序。
TreeSet的第2种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
*/
到了这里,那么就来个练习吧,伙伴们,来咯。。示例1(让元素自身具备比较性):
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());
}
}
}
这种这种方式排序称为:自然排序
特点:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
/*
需求:
往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;
}
}
说明: 这种排序方式是:定义容器自身拥有比较,当元素自身不具备比较性时,或者具备的比较性不是所需要的;这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法;当两种排序都存在时,以比较器为主。
5、泛型
/**
泛型
(1)、JDK1.5版本以后出现新特性。用于解决安全问题,是一个类型安全机制。
(2)好处
a、将运行时期出现问题ClassCastException,转移到了编译时期;方便于程序员解决问题,让运行时问题减少,安全。
b、避免了强制转换麻烦
泛型格式:通过<>来定义要操作的引用数据类型。
在使用java提供的对象时,什么时候写泛 型呢?
通常在集合框架中很常见,只要见到<>就要定义泛型。
c、具体使用方式:<> 就是用来接收类型的;当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
*/
六、Map集合
1、概述
/**
(1)简述
Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)
(2)特点
1)该集合存储键值对,一对一对往里存
2)要保证键的唯一性。
*/
2、Map集合子类
/**
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值;该集合是线程同步的。jdk1.0.效率低。
|--HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的;将hashtable替代,jdk1.2.效率高。
|--TreeMap:底层是二叉树数据结构,线程不同步;可以用于给map集合中的键进行排序。
*/
3、常用方法
/**
1、添加
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
2、删除
clear()
remove(Object key)
3、判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4、获取
get(Object key)
size()
values()
entrySet()
keySet()
*/
4、常用方法演示
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素,添加元素,如果出现添加时,相同的键。那么后添加的值会覆盖原有键对应值。
//并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("remove:"+map.remove("02"));
System.out.println("get:"+map.get("023"));
map.put("04",null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
//获取map集合中所有的值。
Collection<String> coll = map.values();
System.out.println(coll);
System.out.println(map);
}
}
5、Map集合取出方式
<pre name="code" class="java">/**
Map集合的取出原理:将Map集合转成Set集合。再通过迭代器取出。
Set<K> keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器,所以可以通过迭代方式取出所以键的值;再通过get方法,获取每一个键对应的值。
*/
第一种取出方式
import java.util.*;
class KeySetDemo
{
public static void main(String[] args)
{
//创建Map集合,并添加元素
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(2,"zhangsan");
map.put(6,"lisi");
map.put(3,"wangwu");
map.put(4,"heihei");
map.put(5,"xixi");
//获取map集合中的所有键的Set集合
Set<Integer> keySet = map.keySet();
//有了Set集合就可以获取其迭代器,取值
Iterator<Integer> it = keySet.iterator();
while (it.hasNext())
{
Integer i = it.next();
String s = map.get(i);
System.out.println(i + " = " + s);
}
}
}
/**
思路:
将Map集合中的所有键存入到Set集合中,因为Set集合具备迭代器,所以可以用迭代方式取出所有的键,再根据get方法获取每一个键对应的值。
简洁表达式:Map集合---->Set集合 ---->迭代器取出。
*/
第二种取出方式:class HashMapTest
{
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");
entryset(hm);
}
//entrySet取出方式
public static void entryset(HashMap<Student,String> hm)
{
Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me=it.next();
Student s=me.getKey();
String addr=me.getValue();
System.out.println(s+":::"+addr);
}
}
}
/**
说明:
Map是一个接口,其实,Entry也是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:
a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
原理:
将Map集合中的映射关系存入到了Set集合中,而这个映射关系的数据类型是Map.Entry,在通过迭代器将映射关系存入到Map.Entry集合中,并通过其中的getKey()和getValue()放取出键值。
*/
6、Map集合应用
/**
需求:对学生对象的年龄进行升序排序。
思路:学生对象和故籍数据是以键值对形式存在的,所以要使用可以排序的Map集合,TreeMap。
*/
import java.util.*;
class StuNameComparator implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num = s1.getName().compareTo(s2.getName());
if(num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
return num;
}
}
class MapTest
{
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
tm.put(new Student("blisi3",23),"nanjing");
tm.put(new Student("lisi1",21),"beijing");
tm.put(new Student("alisi4",24),"wuhan");
tm.put(new Student("lisi1",21),"tianjin");
tm.put(new Student("lisi2",22),"shanghai");
Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me = it.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+":::"+addr);
}
}
}
7、Map集合图片说明
第一张图片说明:keySet()map集合取出方式<pre name="code" class="java"><pre name="code" class="java">/**
1、Set<K> keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
2、Set<Map.Entry<K,V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry其实,Entry也是一个接口,它是Map接口中的一个内部接口。
*/
伙伴们,还满意吗,集合呀,集合,这篇到这里了,下篇我们再见。