java基础——集合框架

第一讲、集合框架的概述






为什么出现集合类：数据多了用对象存，而对象多了就要用集合存，集合就是存储对象最常用的

一种方式。

数组和集合：数组虽然也可以存放对象，但是数组是固定的，在程序运行时我们无法确定要产生多少个对象，

而集合是可变长度的，但是集合也只能存放对象，而数组可以存放基本数据类型。

集合类特点：长度可变，只能存放对象，可以存放不同类型对象。

代码演示Collection共性方法：

import java.util.*;
/*
add方法的参数类型是Object，以便于接受任意类型对象
集合中存储的都是对象的引用（地址）。
*/
class  CollectionDemo
{
public static void main(String[] args)
{
//创建一个集合容器，使用collection接口的子类ArrayList
ArrayList al=new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//打印集合
sop(al);
//取出元素1
Iterator it = al.iterator();
while(it.hasNext()){
sop(it.next());
}
//取出元素2
for(Iterator it = al.iterator;it.hasNext();)
{
sop(it.next());
}
//删除元素
al.remove("java02");
//al.clear();//清空集合
sop(al);
//获取个数，集合长度
sop("size="+al.size());
//判断元素
sop("java03是否存在:"+al.contains("java03"));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

第二讲 List集合Set集合

List特有方法：凡是可以用角标操作元素的方法都是list特有方法。

增：add(index,element) addAll(index,Collection);

删除：remove(index);

改：set(index,element)

查：get(index) subList(from,to) listIterator();

代码演示:

import java.util.*;
class ListDemo{
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String [] args){
ArrayList al = new ArrayList();
//添加元素
al.add("listAdd01");
al.add("listAdd02");
al.add("listAdd03");
sop("原集合： "+al);
al.add(1,"java005");
sop(al);
//删除指定位置元素
al.remove(3);
sop(al);
//修改
al.set(2,"java008");
//查
sop("获取到: "+al.get(1););
//获取所有元素
for(int x=0;x<al.size();x++){
sop("al["+x+"]="+al.get(x));
}
Iterator it = al.iterator();
while(it.hasNext()){
sop(it.next());
}
}
}

List集合特有的迭代器，ListIterator是Iterator的子接口，

在迭代的时候，不可以使用集合对象的方法来操作元素，（如添加删除等）

这样会发生并发访问异常，

Iterator功能有限只能进行简单的判断删除操作，想要使用其他功能就

只能使用ListIterator来添加修改等,

ListIterator li = new ListIterator();
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("java008"))
//li.add("java0011");
li.set("java00000");
}
sop(al);

LinkedList:特有方法getFirst();getLast();removeFirst();removeLast();addFirst();addLast();

代码演示：

import java.util.*;
class LinkedListDemo
{
public static void main(String [] args){
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.removeFirst());
sop(link.getLast());
sop(link.getFirst());
sop(link.size());
while(!link.isEmpty()){
sop(link.removeFirst());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}

JDK1.6出现了替代方法：boolean offer(E e) offerFirst(E e) offerLast(E e) peek() peekFirst() peekLast() poll() pollFirst()

pollLast()

LinkedList的这些方法可以实现模拟堆栈和队列结构。

LinkedList和ArrayList都是线程不安全的，所谓线程不安全就是指可以并发访问。也就是不同步的，（没有加同步）

下面演示ArrayList相关操作。

代码演示去除ArrayList集合的重复元素：

import java.util.*;
class ArrayListTest
{
public static void main(String [] args){
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop(al);
al = singleElement(al);
sop(al);
}
public static void singleElement(ArrayList al){
//定义一个临时容器。
ArrayList newal = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newal.contains(obj))
newal.add(obj);
}
return newal;
}
public static void sop(Object obj){
System.out.println(obj);
}
}

接下来介绍Set集合：元素是无序的，不允许存在重复元素，取出元素的顺序如存入的不一定一样，

Set集合的方法与Collection一致，不做过多演示，下面介绍子类对象HashSet和TreeSet

HashSet：底层是哈希表。通过元素的两个方法：HashCode 和equals完成的。如果哈希值相同就判断equals

，如果哈希值不同则不会调用equals。（保证唯一性）

对于判断元素是否存在，或者删除等操作，依赖的方法也是HashCode和equals方法。

TreeSet：底层是二叉树。

代码实例：

import java.util.*;
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("a1",11));
hs.add(new Person("a3",13));
hs.add(new Person("a4",14));
Iterator it = hs.iterator();
while (it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"****"+p.getAge());
}
}
}//创建一个Person类
class Person
{
private String name;
private int age;
Person(String name,int age){
this.name = name;
this.age= age;
}
public int hashCode(){//为了尽量保证哈希值唯一性，age乘以一个数。
return name.hashCode()+age*37;
}//复写equals方法
public boolean equals(Object obj){
if(!obj instanceof Person)
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;
}
}

下面介绍TreeSet：可以对set集合的元素进行排序（自然顺序ascii），

排序时，当主要条件相同时，一定要判断一下次要条件，底层是二叉树，

保证元素唯一的方法是compareTo和return 0。

TreeSet实现排序的第一种方法：让元素自身具有比较性，元素需要实现Comparable

接口，覆盖compareTo方法。即自然排序或默认顺序。

TreeSet实现排序的第二种方法：当元素自身不具备比较性，或者具备的比较性不是所需要的

这时就需要让集合自身具备比较性。

当两种排序都存在时，以比较器为主，

定义一个比较器方法步骤：1.定义一个类实现Comparator接口，覆盖compare方法。(compareTo是Comparable的方法)

代码演示第一种排序方法：

//演示存储学生对象,按照学生年龄进行排序。
import java.util.*;
class TreeSetTest
{
public static void main(String [] args){
TreeSet ts = new TreeSet();
ts.add(new Student("lisi01",11));
ts.add(new Student("lisi02",12));
ts.add(new Student("lisi03",13));
ts.add(new Student("lisi04",14));
ts.add(new Student("lisi05",15));
Iterator it = ts.iterator();
while(it.hasNext()){
Student stu = (Student)it.next();
System.out.println(stu.getName()+"**********"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生类具有比较性
{//不实现该接口就会抛出类型转换异常classCastException
private String name;
private int age;
Student(){
this.name = name;
this.age = age;
}
//需要覆盖比较方法compareTo
public int compareTo(Object obj){
if(!(obj instanceof Student))
throw new RuntimeException("不是学生类对象");
Student s = (Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
{//如果年龄相同，则比较名字
return this.name.compareTo(s.name);
}
return -1;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}

代码演示第二种排序:

import java.util.*;
class TreeSetDemo
{
public static void main(String[] args){
TreeSet ts = new TreeSet(new MyCompare());//使集合初始化时就具有比较性
ts.add(new Student("lisi01",11));
ts.add(new Student("lisi02",12));
ts.add(new Student("lisi03",13));
ts.add(new Student("lisi04",14));
ts.add(new Student("lisi05",15));
Iterator it = ts.iterator();
while(it.hasNext()){
Student stu = (Student)it.next();
System.out.println(stu.getName()+"**********"+stu.getAge());
}
}
}//按照姓名排序
class MyCompare implements Comparator
{//需要复写compare方法
public int compare(Object o1,Object o2){
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if(num==0){//因为Integer类实现了Compaable接口，所以Integer对象具有比较性。
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
//			if(s1.getAge()>s2.getAge())
//				return 1;
//			if(s1.getAge()==s2.getAge())
//				return 0;
//			return -1;
}
return num;
}
}

第三讲 Map集合

Map集合：存放的是键值对，一对一对存放，而且保证键的唯一性，包括

三个子类：HashTable HashMap TreeMap

添加：put(K key,V value) putAll() 删除：clear() remove(Object Key)

判断：containsValue(Object value) containsKey(Object key) isEmpty()

获取：get(Object key) size() value() entrySet() keySet()

Map 其实Set集合底层使用的就是Map集合

|——HashTable底层是哈希值数据结构，不可以有null键和值，是线程同步的。

|——HashMap底层是哈希值数据结构，允许使用null键和值，是线程不同步的。

|——TreeMap底层是二叉树，可以用于给Map集合中的键进行 排序，线程不同步。

HashMap和HashTable的区别：null和同步不同步。

代码演示Map共性方法：

import java.util.*;
class MapDemo
{
public static void main(String [] args){
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan01");//添加
map.put("02","zhangsan02");
map.put("03","zhangsan03");
System.out.println("containsKey: "+map.containsKey("02"));
//System.out.println("remove: "+map.remove("02"));
//System.out.println("get: "+map.get("03"));
map.put(null,"haha");
System.out.println("get: "+map.get(null));
//获取
Collection <String>coll = map.value();
System.out.println(coll);
System.out.println(map);
}
}

Map集合所有的元素获取：entrySet和keySet

keySet:将map中所有的键存放到Set集合，因为Set集合具备迭代器。然后可以通过迭代获取所有键，

再通过get方法获取所有的值，

代码演示keySet:

import java.util.*;
class MapDemo
{
public static void main(String [] args){
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan01");//添加
map.put("02","zhangsan02");
map.put("03","zhangsan03");
//现获取map集合的所有键的Set集合，keySet();
Set<String>keySet = map.keySet();
//获取其迭代器
Iterator<String> it = keySet.iterator();
while(it.hasNext()){
String key = it.next();//取得所有的键
String value = map.get(key);//取得值
System.out.println("key: "+key+"value: "+value);
}
}

第二种获取方法：entrySet,将map集合中的映射关系存放到Set集合，

而这个映射关系的数据类型就是：Map.Entry

Map.Entry也是一个接口，是Map接口中的一个内部接口。

代码演示：

import java.util.*;
class MapDemo
{
public static void main(String [] args){
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan01");//添加
map.put("02","zhangsan02");
map.put("03","zhangsan03");
//将map中的映射关系取出，出入到Set集合。
Set<Map.Entry<String,String>>entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println("key: "+key+"value: "+value);
}
}

综合示例演示：存储学生信息，并按照姓名排序。

package Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
HashMap<Student,String>hm = new HashMap<Student,String>();
hm.put(new Student("lisi",20),"beijign");
hm.put(new Student("lisi",20),"tianjin");
hm.put(new Student("wangwu",50),"shanghai");
hm.put(new Student("aliu",25),"taiyuan");
//第一种取出方式keySet
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext()){
Student stu = it.next();
String addr = hm.get(stu);
System.out.println(stu+"*******"+addr);
}
//第二种取出方式entrySet
Set<Map.Entry<Student, String>>entrySet = hm.entrySet();
Iterator<Map.Entry<Student, String>>it2=entrySet.iterator();
while(it2.hasNext()){
Map.Entry<Student, String> me = it2.next();
Student stu = me.getKey();
String addr2 = me.getValue();
System.out.println(stu+"############################"+addr2);
}
}
}
//要创建多个对象备用的时候需要做如下这些
/*实现(复写compareTo方法)  覆盖两个方法
* */
class Student implements Comparable<Student>{
private String name;
private int age;
Student(String name,int age){
this.name=name;
this.age=age;
}//复写compareTo方法，将name和age封装成Student对象传入
public int compareTo(Student s){
int num=new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public String toString(){
return name+"***"+age;
}
public int hashCode(){
return name.hashCode()+age*34;
}
public boolean equals(Object obj){
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
}

第四讲 工具类及其他

Collections:专门对结合进行操作的工具类，内部方法都是静态的，定义的排序方法sort需要进行泛型限定，

其泛型类型必须是Comparable的子类，代码示例：

//public static <T extends Comparable<? super T>>void sort(List<T> list){}

代码实例：

import java.util.*;
class CollectionsDemo
{
public static void main(String [] args){
List<String> list = new ArrayList<String>();
list.add("ada");
list.add("hfaf");
list.add("ddfas");
list.add("qas");
sop(list);
//Collections.sort(list);//默认排序
Collections.sort(list,new StrLenComparator());//默认排序
sop(list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}//自定义比较器
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2){
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}

Arrays:用于操作数组的工具类，里面都是静态方法。

asList:将数组转成集合。

如果数组中的元素都是对象，转换成集合时，数组中的元素直接变成集合中的元素。

如果数组中的元素是基本数据类型，那么会将数组作为集合中的元素存在，

代码演示：

import java.util.*;
class ArraysDemo
{
public static void main(String[] args){
String[] arr= {"dsad""acc""add"};
//将数组变成集合,可以使用集合的方法来操作数组。不可以使用集合的增删，
List<String>list=Arrays.asList(arr);
sop("contains: "+list.contains("acc"));
sop(list);
}
}

用增强for循环遍历HashMap:方法一

HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set<Integer> keySet = hm.keySet();
for(Integer i: keySet)
{
System.out.println(i+"***"+hm.get(i));
}
//方法二
//		Set<Map.Entry<Integer,String>>entrySet = hm.entrySet();
//		for(Map.Entry<Integer,String> me: entrySet)
for(Map.Entry<Integer,String> me:hm.entrySet())
{
System.out.println(me.getKey()+"*****"+me.getValue());
}

可变参数使用时注意：一定要定义在参数列表的最后面。

class ParaMethod
{
public static void main(String[] args){
show("haha",2,5,45,5);
}
public static void show(String str,int... arr){
System.out.println(arr.length);
}
}