黑马程序员——java-集合框架
———–android培训、java培训、java学习型技术博客、期待与您交流！————
1
对象数组：就是数组里边存储的是一个一个的对象。
特点：数组一但定义，长度不能改变。
问题：在日常的开发中，用的比较多的是变化的。所以用数组存储就不是适合，针对此，java提供了新的容器——-集合
集合和数组的区别：
集合：
A 长度可以改变
B 只能存储引用类型
C 可以存储任意类型的数据
数组：
A 长度不可以改变
B 可以存储基本类型，也可以存储引用类型
C 只能存储统一种同一中类型的数据
2
Collection集合概述
Collection（接口）
Collection继承体系结构图：
Collection
|--List（接口）
|--ArrayList
|--Vector
|--LinkedList
|--Set（接口）
|--HashSet
|--TreeSet
Collection集合的功能概述：
A:添加功能
boolean add(Object e):往集合中添加一个元素。
boolean addAll(Collection c):往集合中添加一个集合的元素。
B:删除功能
void clear():移除集合中的所有元素。
boolean remove(Object o):移除集合中指定的一个元素。
boolean removeAll(Collection c):移除集合中指定的一个集合的元素。
C:判断功能
boolean contains(Object o):判断集合中是否包含指定的元素。
boolean containsAll(Collection c):判断集合中是否包含指定的一个集合的元素。
boolean isEmpty():判断集合是否为空。
D:迭代器 Iterator iterator()用于获取集合中的元素。
E:长度功能
int size():获取集合中元素的个数。
F:交集功能
boolean retainAll(Collection c)
例如：集合A交集合B————A.retainAll(B);
把集合A和集合B中相同的元素存放在集合A中，
如果集合A发生过改变，就返回true，否则返回false
G:转换为数组
Object[] toArray():把集合转换为数组。
Collection集合的迭代器（Iterator）
A:迭代器是集合的一种遍历方式。
B:迭代器的使用步骤
a:通过集合对象获取迭代器对象。
b:通过迭代器对象判断是否有元素。
c:通过迭代器对象获取元素，并移动到下一个位置。
C:每种具体的集合的迭代器的具体实现是在每个具体集合类中。
以内部类的方式实现的。
介绍一下Iterator（接口）
A 是一个接口
B 没有构造方法
成员方法：
--boolean hasNext()
如果仍有元素可以迭代，则返回 true
--Object next()返回迭代的下一个元素
public class Collection1
{
public static void main(String[] args)
{
//创建集合对象，这里用到了多态
Collection c=new ArrayList();
//向集合中添加元素
c.add("Hello");
c.add("java");
c.add("Hadoop");
//获得集合对象迭代器
Iterator it=c.iterator();
//遍历集合对象
while(it.hasNext())
{
System.out.println((String)it.next());
}//Object next()此方法返回的是一个Object类型的对象，要想得到String类型的数据，就需要强转
//需要说明的是：因为collection集合中只有得到集合元素的个数的方法，没有得到对应索引出的元素的方法，所以不能使用普通for循环来遍历Collecion集合
}
}3
List集合（接口）
（1）List和Set集合都是Collection集合的字接口他们的区别是：
List：该集合中的元素是有序的（存储和取出的顺序是一致的），可以重复
Set：该集合中的元素是无序的，元素唯一不可以重复
（2）没构造方法
重要的功能方法：
A:添加功能
boolean add(int index,Object) 在指定的位置添加元素。
B:删除功能
Objiect remove(int index) 删除指定索引位置的元素，并返回该元素。
C:修改功能
Objict set(int index,Object obj) 用指定的元素修改指定位置的元素，并把修改前的元素返回。
D:获取功能
Objict get(int index) 根据给定的索引，获取元素。
E:列表迭代器
有两种迭代器：
Iterator iterator()（这是继承Collection集合的迭代器）
ListIterator listIterator()（这是本身特有的）
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListIterator
{
public static void main(String[] args)
{
//创建集对象
List li=new ArrayList();
//向集合中添加数据
li.add("java");
li.add("android");
li.add("hello");
----------
方法一：获得collection的迭代器进行遍历
//获得迭代器（collection的）
Iterator it=li.iterator();
while(it.hasNext())
{
System.out.println((String)it.next());
}
----------
方法二：
//因为List集合本身有E get(int index)和int size()所以可以使用普通for循环
for (int i = 0; i < li.size(); i++)
{
String string=(String)li.get(i);
System.out.println(string);
}
----------
方法三：还可以使用ListIterator进行遍历（和Iterator一样）
}
}
（3）
ListIterator的使用：
A:可以逆向遍历，但是要先正向遍历，一般不用。
--方法：E previous()返回列表中的前一个元素
--方法：boolean hasPrevious()如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。（
public class ListIterator
{
public static void main(String[] args)
{
//创建集对象
List li=new ArrayList();
//向集合中添加数据
li.add("java");
li.add("android");
li.add("hello");
//获得迭代器（首先需要正向遍历，才能用逆向遍历）（而且正向遍历的时候必须用ListIterator迭代器，用其他的迭代器或者普通for循环是不行的）
ListIterator lit=li.listIterator();
while(lit.hasNext())
{
System.out.println((String)lit.next());
}
System.out.println("--------------");
//正向遍历结束后，才能逆向遍历
while(lit.hasPrevious())
{
String string=(String) lit.previous();
System.out.println(string);
}
System.out.println();
}
} B：并发修改异常的问题：
问题描述，在迭代器迭代的过程中，集合的元素是不能改变的，要是强制改变（向集合中添加元素），将出现并发修改异常
在迭代器迭代的过程中，是不能通过集合来修改集合
但是：有时候的我们的需要再迭代器迭代的时候修改集合中的数据
这时候，ListIterator迭代器有特殊的方法
--void add(E e)将指定的元素插入列表（可选操作
--void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素
处理这个问题有两种方法：
方法一：不用迭代器遍历集合，用集合本身来遍历集合
方法二：用ListIterator进行遍历
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
* 需求：遍历给定的集合，是是否有张三这个元素，有，就向集合中添加另外一个元素李四
*/
public class ListIterator2
{
public static void main(String[] args)
{
// 创建集合对象
List li = new ArrayList();
li.add("赵云");
li.add("关羽");
li.add("张三");
li.add("伍六一");
li.add("刘备");
// 用集合本身遍历
for (int i = 0; i < li.size(); i++)
{
String string = (String) li.get(i);
if ((string).equals("张三"))
;
{
li.add("李四");
}
}
System.out.println(li);
// 用迭代器实现
ListIterator listIterator = li.listIterator();
while (listIterator.hasNext())
{
String string = (String) listIterator.next();
if (string.equals("张三"))
{
listIterator.add("李四");
}
}
System.out.println(li);
}
}
需要：注意的是这两种方法都可以实现需求，但是得到的结果略有差别
用集合实现的：
结果是：添加的元素（李四），一定在集合末尾
用迭代器实现：
结果是：添加的元素（李四），在元素张三后边（紧挨着）
4
Lis接口的3个子类
（1） ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
(2) 我们到底使用谁呢?
看需求：
要安全吗?
要：Vector
不要：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
什么都不知道，就用ArrayList。
(3) ArrayList的特有功能及案例：
A:ArrayList存储字符串并遍历
B:ArrayList存储自定义对象并遍历
C:ArrayList存储字符串并遍历。要求去除重复值。
D:ArrayList存储自定义对象并遍历。要求去除重复值。
自定义对象：对象的成员变量值都相同，则为同一个对象。
package Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import com.itheima.Persion;
public class ArrayList1
{
/*
* 需求：ArrayList存储自定义对象并遍历。要求去除重复值。思路：从给定的集合中，依次拿到元素，和新集合中的元素比较，如果新集合中没有此元素，
* 就把此元素添加到新集合中，这样就去除了给定集合中的重复的元素
*/
public static void main(String[] args)
{
// 给定集合自己创建(在集合中添加Student对象)
Student P1 = new Student("赵云", 20);
Student P2 = new Student("伍六一", 22);
Student P3 = new Student("森马", 26);
Student P4 = new Student("中泰", 21);
Student P5 = new Student("赵云", 20);
// 创建集合，并向集合中添加元素
List oldArray = new ArrayList();
oldArray.add(P1);
oldArray.add(P2);
oldArray.add(P3);
oldArray.add(P4);
oldArray.add(P5);
// 创建新集合(存储旧集合的元素)
List newList = new ArrayList();
// 遍历旧集合
for (int i = 0; i < oldArray.size(); i++)
{
if (!newList.contains(oldArray.get(i)))
{
newList.add(oldArray.get(i));
}
}
// 遍历新集合
Iterator it = newList.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
package Collection;
public class Student
{
private String name;
private int age;
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
@Override//重写toString方法
public String toString()
{
return "Student [name=" + name + ", age=" + age + "]";
}
@Override//重写equals方法，如果不重写。测试类中contains方法用的是父类（Object）的equals方法，父类的此方法默认比较的是地址值
public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null)
{
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
（4）Vector（类）
构造方法---public Vector()构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
特有的方法：
添加元素：public void addElement(E obj)
遍历元素：
普通for循环
得到元素：public Object elementAt(int index)
得到元素的个数：public int size()
迭代器实现：
public Enumeration elements()
Enumeration（接口中的方法
--boolean hasMoreElements()测试此枚举是否包含更多的元素。
--Object nextElement()如果此枚举对至少还有一个可提供的元素，则返回此枚举的下一个元素。
package Collection;
import java.util.Enumeration;
import java.util.Vector;
public class VectorText
{
public static void main(String[] args)
{
// 创建Vector集合（）
Vector v = new Vector();
// 向集合中添加元素
v.addElement("zhansan");
v.addElement("lisi");
v.addElement("nihao");
// 遍历集合
// 方法一（普通for循环）
for (int i = 0; i < v.size(); i++)
{
System.out.println((String) v.elementAt(i));
}
System.out.println("----------");
// 方法二（用迭代器）
Enumeration e = v.elements();
while (e.hasMoreElements())
{
System.out.println(e.nextElement());
}
}
}
（5）
LinkedList的特有功能及案例：
A:特有功能
a:添加功能
void addFirst()
void addLast()
b:删除功能
object removeFirst()移除并返回此列表的第一个元素。
Object removeLast()移除并返回此列表的最后一个元素。
c:获取功能
object getFirst()--添加到集合开头
object getLast()--添加到集合末尾
B:LinkedList存储字符串并遍历
---普通for循环
使用int size()和public E get(int index)方法
---使用Iterator
boolean hasNext() 和E next() 方法
存在并发修改的错误
使用 ListIterator的boolean add(Object c);方法解决，
或者用集合自身的遍历
---增强for循环
C:LinkedList存储自定义对象并遍历
package Collection;
public class LinkedListText
{
/*
* 需求：请用LinkedList模拟栈数据结构的集合，并测试。 思路：题目的意思是需要自己定义一个集合类
* 该自定义的类中，可以有一个LinkedList类可以使用
*/
public static void main(String[] args)
{
//创建自己定义的集合对象
MyStack stack = new MyStack();
// 向集合中添加元素
stack.add("赵云");
stack.add("哈哈");
stack.add("朗天");
stack.add("袁郎");
while (!stack.isempty())
{
System.out.println(stack.get());
}
}
}
package Collection;
import java.util.LinkedList;
public class MyStack
{
private LinkedList linkdeList;
public MyStack()
{
linkdeList = new LinkedList();
}
public void add(Object e)
{
linkdeList.addFirst(e);
}
public Object get()
{
// return linkdeList.getFirst();//如用这个，将是死循环，并且只有一个元素
return linkdeList.removeFirst();// 删除第一个元素，并发返回这个元素
}
public boolean isempty()
{
return linkdeList.isEmpty();
}
}
———–android培训、java培训、java学习型技术博客、期待与您交流！————