黑马程序员——java基础-集合

　------- android培训、java培训、期待与您交流！ ----------

第一节：集合的概述

一、集合的简述：

1、集合的由来：

我们学习的是Java -->面向对象 -->操作很多对象 -->存储 -->容器(数组和StringBuffer) -->数组而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用

2、集合特点：

(1)、用于存储对象的容器。

(2)、集合的长度是可变的。

(3)、集合中不可以存储基本数据类型值。

3、集合和数组的区别：

(1)、长度区别

数组固定

集合可变

(2)、内容区别

数组可以是基本类型，也可以是引用类型

集合只能是引用类型

(3)、元素内容

数组只能存储同一种类型

集合可以存储不同类型(其实集合一般存储的也是同一种类型)

二、集合的继承体系结构

由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，

我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

第二节：Collection

一、Collection的功能的简述：

1、添加：

boolean add(Object obj): 添加一个元素

boolean addAll(Collection coll): 添加一个集合

2、删除：

boolean remove(object obj): 移除一个元素

boolean removeAll(Collection coll); 移除一个集合

void clear(); 清空

3、判断：

boolean contains(object obj): 是否包含一个元素

boolean containsAll(Colllection coll); 是否包含一个集合

boolean isEmpty():判断集合中是否有元素。

4、获取：

int size(): 集合的长度

Iterator iterator():取出元素的方式：迭代器。

迭代器：

(1)、该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。所以该迭代器对象是在容器中进行内部实现的。

(2)、对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可， 也就是iterator方法。

(3)、Iterator接口就是对所有的Collection容器进行元素取出的公共接口。把它可以想象成抓娃娃游戏机中的夹子！

5、其他：

boolean retainAll(Collection coll);取交集。

Object[] toArray():将集合转成数组。

第三节：List

一、简述：

1、有序的 collection（也称为序列）。

2、此接口的用户可以对列表中每个元素的插入位置进行精确地控制。

3、用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

4、与 set 不同，列表通常允许重复的元素。

二、List:特有的常见方法：

1、添加 ：

void add(index,element); 根据角标添加元素

void add(index,collection); 根据角标添加集合

2、删除；

Object remove(index): 根据角标删除集合的元素

3、修改：

Object set(index,element); 根据角标替换元素

4、获取：

Object get(index); 根据角标获取元素

int indexOf(object); 根据元素获取第一次角标，否则返回-1

int lastIndexOf(object); 获取最后出现元素的角标

List subList(form,to);获取部分对象元素

注：有一个共性特点就是都可以操作角标

5、其他

ListIterator listIterator();获取特有的迭代器

迭代器：

(1)、并发修改异常

(1).1:出现的现象

迭代器遍历集合，集合修改集合元素

(1).2:原因

迭代器是依赖于集合的，而集合的改变迭代器并不知道。

(1).3:解决方案

(1).3.1:迭代器遍历，迭代器修改(ListIterator)

元素添加在刚才迭代的位置

(1).3.2:集合遍历，集合修改(size()和get())

元素添加在集合的末尾

(2)、ListIterator是List集合特有的迭代器，它是Iterator的子接口。

(3)、ListIterator的常用方法

void add(obj);增加

void set(obj);修改为obj

boolean hasPrevious();判断前面有没有元素

Object previous();取前一个元素

三、List子类的特点

1、ArrayList:

底层数据结构是数组，查询快，增删慢

线程不安全，效率高

2、Vector:

底层数据结构是数组，查询快，增删慢

线程安全，效率低

3、LinkedList:

底层数据结构是链表，查询慢，增删快

线程不安全，效率高

四、集合ArrayList

1、此集合的没有特有的功能需要学习，因为它的功能与List一样。

2、案例

(1) ArrayList存储字符串并遍历，并保证元素的唯一性

//用list集合添加字符串 要保证元素的唯一性
/*
由于字符串中的equals来自object它只比较两个元素的地址值 没有比较两个元素。
1、创建一个list集合对象 添加元素 要有重复的元素
2、在创建一个新的集合对象 用迭代器进行对老的集合中的元素进行遍历 并且存储到新的集合当中去，在存储的过程当中如果遇到重复的就不存储了。
3、再把老集合清空
4、在把新集合中的元素添加到老集合当中去
5、清空老集合
6、再打印集合查看元素

*/
import java.util.*;
class Demo
{
public static void main(String[] args)
{
//创建一个ArrayList类的对象
ArrayList<String>list=new ArrayList<String>();
//添加元素
list.add("a");
list.add("abc");
list.add("a");
//把数据传入函数中，并返回一个集合
ArrayList<String>lis=getList(list);
//打印集合中的元素
System.out.println(lis);
}
public static ArrayList<String>getList(ArrayList<String> list)
{
//在创建一个集合
ArrayList<String>list1=new ArrayList<String>();
//对集合中的元素进行遍历
for (String str:list)
{
//如果list1集合中不包含这个元素，就添加这个集合到list1集合当中去
if (!list1.contains(str))
{
list1.add(str);
}
}
//把list集合清空
list.clear();
//把list1集合中的元素全部添加到list集合中
list.addAll(list1);
//把list1集合进行清空
list1.clear();
//返回list集合
return list;
}
}

(2) ArrayList存储自定义对象并遍历，并保证元素的唯一性

//在list集合当中添加自定义对象并且保证元素的唯一性
/*
思路：
1、写一个学生类 有姓名 年龄属性并覆盖toString方法和equals方法(保证元素的唯一性)
2、在main方法中创建学生类对象 并添加元素
3、看是否有重复元素

*/
import java.util.*;
class Demo1
{

public static void main(String[] args)
{
//创建一个ArrayList类的对象
ArrayList<Student>list=new ArrayList<Student>();
//往集合中添加元素
list.add(new Student("张三",23));
list.add(new Student("小三",3));
list.add(new Student("大三",13));
list.add(new Student("中三",23));
list.add(new Student("张三",23));
//把集合传入到一个函数当中去，并把返回的机会赋值给list
list=equals1(list);
//打印list集合中的元素
System.out.println(list);
}
public static ArrayList<Student>equals1(ArrayList<Student>list)
{
//在创建一个集合
ArrayList<Student>lis=new ArrayList<Student>();
//对集合中的元素进行遍历
for(Student st:list)
{
//如果list1集合中不包含这个元素，就添加这个集合到list1集合当中去
if (!(lis.contains(st)))
{
lis.add(st);
}

}
//把list集合清空
list.clear();
//把lis集合中的元素全部添加到list集合中
list.addAll(lis);
//lis集合清空
lis.clear();
return list;
}

}
//定义一个学生类
class Student
{
//私有学生类的属性
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;
}
//覆盖Object中的equals方法
public boolean equals(Object obj)
{
if (this==obj)
return true;
//如果不是学生类就抛出异常
if (!(obj instanceof Student))
{
throw new RuntimeException("类型转换异常");
}
//进行强转
Student stu=(Student)obj;
//进行比较如果是name与age都相同的话，就是同一个人
return this.name.equals(stu.name)&&this.age==stu.age;
}
//覆盖Object中的toString方法
public String toString()
{
return "name="+name+"......age="+age;
}
}

五、集合Vector

1、特有的功能：

(1) 添加

void addElement(E obj)-->add()

(2) 获取

public E elementAt(int index)-->
get()

public Enumeration<E> elements()--> iterator()

2、枚举 Enumeration

(1)、它是Vector特有的获取方法，

(2)、枚举与迭代器的功能是一样的，由于它和方法的名称过长，就被迭代器代替了。

六、集合 LinkedList

1、特有的功能

(1) 添加

addFirst()

addLast()

jdk1.6

offerFirst();

offetLast();

(2) 删除

removeFirst()获取并移除，如果链表为空，抛出NoSuchElementException.

removeLast()

jdk1.6

pollFirst();获取并移除，如果链表为空，返回null.

pollLast();

(3) 获取

getFirst()获取但不移除，如果链表为空，抛出NoSuchElementException.

getLast()

jdk1.6

peekFirst();获取但不移除，如果链表为空，返回null.

peekLast():

2、两种数据结构

(1)堆栈：先进后出 First In Last Out FILO

(2)队列：先进先出 First In First Out FIFO

(3)用LinkedList来模拟一个堆栈或者队列数据结构。

代码体现

//自定义一个队列的结构
/*
思路：
1 先定义一个类 在构造函数当中创建一个List对象
2 在定义一个添加元素的方法
3 在定义一个一下获取元素的方法

*/
import java.util.*;
class Demo2
{
public static void main(String[] args)
{
//创建队列类的元素
Queu<String> q=new Queu<String>();
//并添加元素
q.add("张三");
q.add("王五");
q.add("李四");
q.add("周七");
q.add("赵八");
//获取元素
q.get();

}
}
//自定一个队列类
class Queu<String>
{
//把创建LinkedList集合的对象进行私有
private LinkedList<String> list=list=new LinkedList<String>();
//进行添加元素
public void add(String str)
{
//用的是list对象的进行添加元素
list.addLast(str);

}
//获取元素
public void get()
{
//对集合中元素进行遍历并删除
while (!list.isEmpty())
{
//并打印被删除的元素
System.out.println(list.removeFirst());
}

}
}

3、在集合中常见的数据结构

(1)ArrayXxx:底层数据结构是数组，查询快，增删慢

(2)LinkedXxx:底层数据结构是链表，查询慢，增删快

(3)HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()

(4)TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

第四节：Set

一、简述：

1、不包含重复元素的集合，不保证顺序。

2、而且方法和Collection一致。

3、Set集合取出元素的方式只有一种：迭代器。

二、Set子类的特点

1、HashSet集合

(1)底层数据结构是哈希表(是一个元素为链表的数组)

(2)哈希表底层依赖两个方法：hashCode()和equals()

执行顺序：

首先比较哈希值是否相同

相同：继续执行equals()方法

返回true：元素重复了，不添加

返回false：直接把元素添加到集合

不同：就直接把元素添加到集合

(3)如何保证元素唯一性的呢?

由hashCode()和equals()保证的

(4)开发的时候，代码非常的简单，自动生成即可。

(5)HashSet存储字符串并遍历，并且保证元素的唯一。

//保证hashSet集合的元素唯一
/*
思路：
1 定义一个hashset集合的对象 并添加元素
2 进行对集合遍历 看是否有重复元素
string类型已经覆盖了hashcode方法了和equals方法了

*/
import java.util.*;
class Demo3
{
public static void main(String[] args)
{
//创建HashSet集合对象
HashSet<String>hs=new HashSet<String>();
//往集合中添加元素
hs.add("a");
hs.add("ab");
hs.add("ab");
hs.add("abc");
//并对集合中的元素进行遍历
for (String s:hs )
{
//打印集合中的元素
System.out.println(s);
}

}
}

(6)HashSet存储自定义对象并遍历。并保证元素的唯一性。

//自定义一个类用hashset集合去存储要保证元素的唯一性
/*
1、自定义一个类有姓名 年龄 属性 并且要覆盖hashcode方法和equals方法
2、创建hashset集合的对象 并添加元素
3、取出元素看是否有重复

*/
import java.util.*;
class Demo4
{
public static void main(String[] args)
{
//创建HashSet集合对象
HashSet<Student>hs=new HashSet<Student>();
//往集合中添加元素
hs.add(new Student("张三",34));
hs.add(new Student("周七",13));
hs.add(new Student("李四",12));
hs.add(new Student("李四",12));
hs.add(new Student("赵六",54));
hs.add(new Student("王五",21));
//并对集合中的元素进行遍历
for (Student st:hs)
{
//打印集合中的元素
System.out.println(st);
}

}
}
//定义一个学生类
class Student
{
//私有学生类的属性
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;
}
//覆盖Object中的hashCode方法
public int hashCode()
{
return name.hashCode()+age;
}
//覆盖Object中的equals方法
public boolean equals(Object obj)
{
if (this==obj)
return true;
//如果不是学生类就抛出异常
if (!(obj instanceof Student))
{
throw new RuntimeException("类型转换异常");
}
//进行强转
Student stu=(Student)obj;
//进行比较如果是name与age都相同的话，就是同一个人
return this.name.equals(stu.name)&&this.age==stu.age;

}
//覆盖Object中的toString方法
public String toString()
{

return "name="+name+"age="+age;
}
}

2、TreeSet集合

(1)底层数据结构是红黑树(是一个自平衡的二叉树)

(2)保证元素的排序方式

(2).1自然排序(元素具备比较性)

让元素所属的类实现Comparable接口 覆盖CompareTo()方法

(2).2比较器排序(集合具备比较性)

让集合构造方法接收Comparator的实现类对象 覆盖Compare()方法

代码体现

1、对TreeSet集合进行遍历，并保证元素的唯一性

//创建TreeSet集合对象，并添加元素并保证元素的唯一性(String 类型)
/*
思路：
1、创建TreeSet集合对象并添加元素
2、取出集合中的元素

*/
import java.util.*;
class Demo5
{
public static void main(String[] args)
{
//创建TreeSet集合对象
TreeSet<String>set=new TreeSet<String>();
//并添加元素
set.add("a");
set.add("ab");
set.add("ac");
set.add("ab");
//用迭代器进行对集合中的元素遍历
for (Iterator<String>irr=set.iterator();irr.hasNext() ; )
{
//打印集合中的元素
System.out.println(irr.next());
}

}

}

2、TreeSet集合存储自定义对象并遍历，并保证元素的唯一性

//自定义一个类并创建TreeSet集合对象添加元素并保证元素的唯一性
/*
思路：
1、 自定义一个类实现Comparable接口 覆盖compareTo方法 并定义自己姓名年龄属性
2、创建集合Treeset对象 添加元素
3、取出元素看看元素是否唯一
4、有时比较的并不是我们想要的结果 这时我们自己可以自定义一个比较器Comparator接口覆盖compare方法
*/
import java.util.*;
class Demo6
{
public static void main(String[] args)
{
//创建TreeSet集合对象的同时也传入一个比较器的对象
TreeSet<Student> set=new TreeSet<Student>(new MyComparator());
//往集合中添加元素
set.add(new Student("张三",23));
set.add(new Student("王五",13));
set.add(new Student("赵六",3));
set.add(new Student("赵六",3));
set.add(new Student("李四",93));
//用迭代器进行对集合中的元素遍历
for (Iterator<Student>irr=set.iterator();irr.hasNext() ; )
{
//打印集合中的元素
System.out.println(irr.next());
}

}
}
//自定义一个学生类并实现了Comparable接口
class Student implements Comparable<Student>
{
//私有学生类的属性
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;
}
//覆盖接口中的CompareTo方法
public int compareTo(Student stu)
{
//看看name是否相同
int temp=this.name.compareTo(stu.name);
//当name和age相同时为同一个人
return temp==0?this.age-stu.age:temp;
}
//覆盖Object中的toString方法
public String toString()
{
return "name="+name+".....age="+age;
}
}
//自定义一个比较器类并实现了Comparator接口
class MyComparator implements Comparator<Student>
{
//覆盖compare方法
public int compare(Student s,Student s1)
{
int temp=s1.getName().compareTo(s.getName());
//当name和age都相同为同一人
return temp==0?s.getAge()-s1.getAge():temp;
}
}

第五节 Map集合

一、简述：

1、将键映射到值的对象

2、一个映射不能包含重复的键

3、每个键最多只能映射到一个值

二、Map接口和Collection接口的不同

1、Map是双列的,Collection是单列的

2、Map的键唯一,Collection的子体系Set是唯一的

3、Map集合的数据结构值针对键有效，跟值无关

4、Collection集合的数据结构是针对元素有效

三、Map接口常见的功能

1、 添加功能

(1) V put(K key,V value);添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

(2) v oidputAll(Map <? extends K,? extends V> m);添加一个集合

2、 删除功能

(1) void clear();清空

(2) V remove(Object key);删除指定键值对

3、判断功能

(1) boolean containsKey(Object key);判断键是否存在

(2) boolean containsValue(Object value)判断值是否存在

(3) boolean isEmpty();判断是否为空

4、获取功能

(1)V get(Object key);通过键获取对应的值

(2)Collection<V>value();获取Map集合中所以得值，返回一个Collection集合

5、长度功能

(1) int size();获取集合的长度

6、Map集合的遍历

(1)键找值 Set<K> keySet();

(1).1获取所有键的集合

(1).2遍历键的集合,得到每一个键

(1).3根据键到集合中去找值

(2)键值对对象找键和值 Set<Map.Entry<K,V>> entrySet();

(2).1获取所有的键值对对象的集合

(2).2遍历键值对对象的集合，获取每一个键值对对象

(2).3根据键值对对象去获取键和值

代码体现

//对Map集合中的元素进行存取
/*
思路;
1、创建Map集合的对象并添加元素
2、map集合中没有迭代器 有个方法可以获取Set到集合 keySet方法  第二个获取他们之间的关系
3、在用迭代器进行获取键 有了键在根据map集合中的方法获取到值

*/
import java.util.*;
class Demo7
{
public static void main(String[] args)
{
//创建TreeMap集合对象
TreeMap<String ,Integer>map=new TreeMap<String,Integer>();
//往集合中添加元素
map.put("张三",23);
map.put("王五",23);
map.put("周七",23);
//获取集合中的元素第一种方法
getElement(map);
//获取集合中的元素第二种方法
getElement1(map);

}
public static void getElement1(TreeMap<String,Integer>map)
{
//调用TreeSet集合中的方法返回一个集合中键和值之间的关系
Set<Map.Entry<String,Integer>> sett=map.entrySet();
//就用迭代器进行对集合中键和值的关系遍历
for (Iterator<Map.Entry<String,Integer>>irr=sett.iterator();irr.hasNext() ; )
{
//拿到每一个键和值的关系
Map.Entry<String,Integer> meo=irr.next();
//根据关系中的方法获取集合中的键
String ss=meo.getKey();
//然后再获取值
Integer in=meo.getValue();
//打印键和值
System.out.println("key="+ss+"........value="+in);
}

}

public static void getElement(TreeMap<String,Integer> map)
{
//调用TreeSet集合中的方法返回一个集合中键
Set<String>set=map.keySet();
//对集合中的键进行遍历
for (Iterator<String>irr=set.iterator();irr.hasNext() ; )
{
//获取集合中的一个键
String s=irr.next();
//在根据键去获取与之对应的值
System.out.println("key="+s+"......value="+map.get(s));
}

}
}

7、Map常用的子类特点：

|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。

|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。

|--HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。

|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。

8、代码体现

//自定义一个类 创建这个类的对象添加到map集合中去并获取添加的每个元素
/*
思路：
1 自定义一个类 有姓名 年龄
2 创建map集合对象并添加元素
3 在获取到集合中的元素

*/
import java.util.*;
class Demo8
{
public static void main(String[] args)
{
//创建TreeMap集合对象
TreeMap<Student,String>map=new TreeMap<Student,String>();
//往集合中添加元素
map.put(new Student("张三",23),"上海");
map.put(new Student("王五",13),"北京");
map.put(new Student("李四",3),"郑州");
map.put(new Student("周期",93),"南京");
//往函数中传入一个Map集合
getElement(map);

}
public static void getElement(TreeMap<Student,String>map)
{
//调用TreeSet集合中的方法返回一个集合中键和值之间的关系
Set<Map.Entry<Student,String>>set=map.entrySet();
//就用迭代器进行对集合中键和值的关系遍历
for (Iterator<Map.Entry<Student,String>>irr=set.iterator();irr.hasNext() ; )
{
//拿到每一个键和值的关系
Map.Entry<Student,String>en=irr.next();
//根据关系中的方法获取集合中的键
Student stu=en.getKey();
//然后再获取值
String s=en.getValue();
//打印键和值
System.out.println("key="+stu+"............value="+s);
}

}
}
//自定义一个学生类并实现了Comparable接口
class Student implements Comparable<Student>
{
//私有学生类的属性
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;
}
//覆盖接口中的CompareTo方法
public int compareTo(Student stu)
{
//name之间进行比较
int temp=this.name.compareTo(stu.name);
return temp==0?this.age-this.age:temp;
}
//覆盖Object中的toString方法
public String toString()
{

return "name="+name+"..........age="+age;
}

}

------- android培训、java培训、期待与您交流！ ----------