伙伴们，这篇我们介绍集合类，继续来起。
一、概述
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接口中的一个内部接口。
*/ 伙伴们，还满意吗，集合呀，集合，这篇到这里了，下篇我们再见。
1000
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
