从”JAVA“而终 12：java集合框架API讲解
来源：互联网 发布：疯狂的美工装修助 编辑：程序博客网 时间：2024/05/22 15:25
Ø Java平台提供了一个全新的集合框架。“集合框架”主要由一组用来操作对象的接口组成。不同接口描述一组不同数据类型。它们都封装在java.util包中
个各类的特点以及选取的依据：可根据它们是否有序、存取速度、是否允许重复、是否线程安全、是否需要存入键值对。
下面是各个类的特点：
先来看鼻祖的两个类：Collection（接口） 和 Map。
Collection：Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
Collection接口的方法：
正如你所看到的，它是一个接口，而List和Set（接口）都实现了它；所以上图的方法，在set和list中都肯定会有。
List类
先看List的构造方法：如何创建一个List对象
List() 创建新的滚动列表。
List(int rows) 创建一个用指定可视行数初始化的新滚动列表。
List(int rows, boolean multipleMode)创建一个初始化为显示指定行数的新滚动列表。
List的方法：
voidadd(String item)向滚动列表的末尾添加指定的项。
voidadd(String item, int index)向滚动列表中索引指示的位置添加指定的项。
voidaddActionListener(ActionListener l)添加指定的动作侦听器以从此列表接收动作事件。
voidaddItem(String item)已过时。 由
add(String) 取代。voidaddItem(String item, int index)已过时。 由
add(String, int) 取代。voidaddItemListener(ItemListener l)添加指定的项侦听器以接收此列表的项事件。
voidaddNotify() 创建列表的同位体。
booleanallowsMultipleSelections()已过时。 从 JDK version 1.1 开始，由
isMultipleMode() 取代。voidclear() 已过时。 从 JDK version 1.1 开始，由
removeAll() 取代。intcountItems() 已过时。 从 JDK version 1.1 开始，由
getItemCount() 取代。voiddelItem(int position)已过时。 由
remove(String) 和 remove(int) 取代。voiddelItems(int start, int end)已过时。 从 JDK version 1.1 开始，后来不再公开使用。只希望作为包私有方法时保留此方法。
voiddeselect(int index)取消选择指定索引处的项。
AccessibleContextgetAccessibleContext()获取与此
List 关联的 AccessibleContext。ActionListener[]getActionListeners()返回已在此列表上注册的所有动作侦听器的数组。
StringgetItem(int index)获取与指定索引关联的项。
intgetItemCount() 获取列表中的项数。
ItemListener[]getItemListeners()返回已在此列表上注册的所有项侦听器的数组。
String[]getItems() 获取列表中的项。
<T extends EventListener>
T[]getListeners(Class<T> listenerType)返回目前已在此
List 上注册为 FooListener 的所有对象的数组。DimensiongetMinimumSize()确定此滚动列表的最小大小。
DimensiongetMinimumSize(int rows)获取具有指定行数的列表的最少维数。
DimensiongetPreferredSize()获取此滚动列表的首选大小。
DimensiongetPreferredSize(int rows)获取具有指定行数的列表的首选维数。
intgetRows() 获取此列表中的可视行数。
intgetSelectedIndex()获取列表中选中项的索引。
int[]getSelectedIndexes()获取列表中选中的索引。
StringgetSelectedItem()获取此滚动列表中选中的项。
String[]getSelectedItems()获取此滚动列表中选中的项。
Object[]getSelectedObjects()获取对象数组中此滚动列表的选中项。
intgetVisibleIndex()获取上次由
makeVisible 方法使其可视的项的索引。booleanisIndexSelected(int index)确定是否已选中此滚动列表中的指定项。
booleanisMultipleMode()确定此列表是否允许进行多项选择。
booleanisSelected(int index)已过时。 从 JDK version 1.1 开始，由
isIndexSelected(int) 取代。voidmakeVisible(int index)使指定索引处的项可视。
DimensionminimumSize() 已过时。 从 JDK version 1.1 开始，由
getMinimumSize() 取代。DimensionminimumSize(int rows)已过时。 从 JDK version 1.1 开始，由
getMinimumSize(int) 取代。protectedStringparamString() 返回表示此滚动列表状态的参数字符串。
DimensionpreferredSize() 已过时。 从 JDK version 1.1 开始，由
getPreferredSize() 取代。DimensionpreferredSize(int rows)已过时。 从 JDK version 1.1 开始，由
getPreferredSize(int) 取代。protected voidprocessActionEvent(ActionEvent e)处理发生在此列表上的动作事件，方法是将这些事件指派给所有已注册的
ActionListener 对象。protected voidprocessEvent(AWTEvent e)此滚动列表的进程事件。
protected voidprocessItemEvent(ItemEvent e)处理发生在此列表上的项事件，方法是将这些事件指派给所有已注册的
ItemListener 对象。voidremove(int position)从此滚动列表中移除指定位置处的项。
voidremove(String item)从列表中移除项的第一次出现。
voidremoveActionListener(ActionListener l)移除指定的动作侦听器，以便不再从此列表接收动作事件。
voidremoveAll() 从此列表中移除所有项。
voidremoveItemListener(ItemListener l)移除指定的项侦听器，以便不再从此列表接收项事件。
voidremoveNotify() 移除此列表的同位体。
voidreplaceItem(String newValue, int index)使用新字符串替换滚动列表中指定索引处的项。
voidselect(int index)选择滚动列表中指定索引处的项。
voidsetMultipleMode(boolean b)设置确定此列表是否允许进行多项选择的标志。
voidsetMultipleSelections(boolean b)已过时。 从 JDK version 1.1 开始，由
setMultipleMode(boolean) 取代。由集合整体图可以看出LinkedList和ArrayList分别为List的两个子类，我们再来看看LinkedList和ArrayList的用法和区别：LinkedList：
构造器：
LinkedList() 构造一个空列表。
LinkedList(Collection<? extendsE> c) 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。方法：
booleanadd(E e)将指定元素添加到此列表的结尾。
voidadd(int index, E element) 在此列表中指定的位置插入指定的元素。
booleanaddAll(Collection<? extendsE> c) 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
booleanaddAll(int index, Collection<? extends E> c)将指定 collection 中的所有元素从指定位置开始插入此列表。
voidaddFirst(E e)将指定元素插入此列表的开头。
voidaddLast(E e)将指定元素添加到此列表的结尾。
voidclear() 从此列表中移除所有元素。
Objectclone() 返回此 LinkedList 的浅表副本。
booleancontains(Object o)如果此列表包含指定元素，则返回 true。
Iterator<E>descendingIterator()返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
Eelement() 获取但不移除此列表的头（第一个元素）。
Eget(int index) 返回此列表中指定位置处的元素。
EgetFirst() 返回此列表的第一个元素。
EgetLast() 返回此列表的最后一个元素。
intindexOf(Object o)返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
intlastIndexOf(Object o)返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
ListIterator<E>listIterator(int index)返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
booleanoffer(E e)将指定元素添加到此列表的末尾（最后一个元素）。
booleanofferFirst(E e)在此列表的开头插入指定的元素。
booleanofferLast(E e)在此列表末尾插入指定的元素。
Epeek() 获取但不移除此列表的头（第一个元素）。
EpeekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
EpeekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
Epoll() 获取并移除此列表的头（第一个元素）
EpollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
EpollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
Epop() 从此列表所表示的堆栈处弹出一个元素。
voidpush(E e)将元素推入此列表所表示的堆栈。
Eremove() 获取并移除此列表的头（第一个元素）。
Eremove(int index)移除此列表中指定位置处的元素。
booleanremove(Object o)从此列表中移除首次出现的指定元素（如果存在）。
EremoveFirst() 移除并返回此列表的第一个元素。
booleanremoveFirstOccurrence(Object o)从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
EremoveLast() 移除并返回此列表的最后一个元素。
booleanremoveLastOccurrence(Object o)从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
Eset(int index, E element) 将此列表中指定位置的元素替换为指定的元素。
intsize() 返回此列表的元素数。
Object[]toArray() 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
<T> T[]toArray(T[] a) 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。Arraylist：
ArrayList() 构造一个初始容量为 10 的空列表。
ArrayList(Collection<? extendsE> c) 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
booleanadd(E e)将指定的元素添加到此列表的尾部。
voidadd(int index, E element) 将指定的元素插入此列表中的指定位置。
booleanaddAll(Collection<? extendsE> c) 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
booleanaddAll(int index, Collection<? extends E> c)从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
voidclear() 移除此列表中的所有元素。
Objectclone() 返回此 ArrayList 实例的浅表副本。
booleancontains(Object o)如果此列表中包含指定的元素，则返回 true。
voidensureCapacity(int minCapacity)如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
Eget(int index) 返回此列表中指定位置上的元素。
intindexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
booleanisEmpty() 如果此列表中没有元素，则返回 true
intlastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
Eremove(int index)移除此列表中指定位置上的元素。
booleanremove(Object o)移除此列表中首次出现的指定元素（如果存在）。
protected voidremoveRange(int fromIndex, int toIndex)移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
Eset(int index, E element) 用指定的元素替代此列表中指定位置上的元素。
intsize() 返回此列表中的元素数。
Object[]toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[]toArray(T[] a) 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
voidtrimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。
我们再来看Set（接口）：
booleanadd(E e)如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
booleanaddAll(Collection<? extendsE> c) 如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
voidclear() 移除此 set 中的所有元素（可选操作）。
booleancontains(Object o)如果 set 包含指定的元素，则返回 true。
booleancontainsAll(Collection<?> c)如果此 set 包含指定 collection 的所有元素，则返回 true。
booleanequals(Object o)比较指定对象与此 set 的相等性。
inthashCode() 返回 set 的哈希码值。
booleanisEmpty() 如果 set 不包含元素，则返回 true。
Iterator<E>iterator() 返回在此 set 中的元素上进行迭代的迭代器。
booleanremove(Object o)如果 set 中存在指定的元素，则将其移除（可选操作）。
booleanremoveAll(Collection<?> c)移除 set 中那些包含在指定 collection 中的元素（可选操作）。
booleanretainAll(Collection<?> c)仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
intsize() 返回 set 中的元素数（其容量）。
Object[]toArray() 返回一个包含 set 中所有元素的数组。
<T> T[]toArray(T[] a) 返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。
它的两个实现类：HashSet TreeSet：
HashSet:
HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
HashSet(Collection<? extendsE> c) 构造一个包含指定 collection 中的元素的新 set。
HashSet(int initialCapacity)构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
HashSet(int initialCapacity, float loadFactor)构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。
boole an
add(E e)如果此 set 中尚未包含指定元素，则添加指定元素。
voidclear() 从此 set 中移除所有元素。
Objectclone() 返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
booleancontains(Object o)如果此 set 包含指定元素，则返回 true。
booleanisEmpty() 如果此 set 不包含任何元素，则返回 true。
Iterator<E>iterator() 返回对此 set 中元素进行迭代的迭代器。
booleanremove(Object o)如果指定元素存在于此 set 中，则将其移除。
intsize() 返回此 set 中的元素的数量（set 的容量）。
TreeSet:
TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection<? extendsE> c) 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator<? superE> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
TreeSet(SortedSet<E> s)构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。
booleanadd(E e)将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
booleanaddAll(Collection<? extendsE> c) 将指定 collection 中的所有元素添加到此 set 中。
Eceiling(E e)返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回
null。voidclear() 移除此 set 中的所有元素。
Objectclone() 返回
TreeSet 实例的浅表副本。Comparator<? superE>comparator() 返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回null。
booleancontains(Object o)如果此 set 包含指定的元素，则返回
true。Iterator<E>descendingIterator()返回在此 set 元素上按降序进行迭代的迭代器。
NavigableSet<E>descendingSet() 返回此 set 中所包含元素的逆序视图。
Efirst() 返回此 set 中当前第一个（最低）元素。
Efloor(E e)返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回
null。SortedSet<E>headSet(E toElement)返回此 set 的部分视图，其元素严格小于 toElement。
NavigableSet<E>headSet(E toElement, boolean inclusive)返回此 set 的部分视图，其元素小于（或等于，如果
inclusive 为 true）toElement。Ehigher(E e)返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回
null。booleanisEmpty() 如果此 set 不包含任何元素，则返回
true。Iterator<E>iterator() 返回在此 set 中的元素上按升序进行迭代的迭代器。
Elast() 返回此 set 中当前最后一个（最高）元素。
Elower(E e)返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回
null。EpollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回
null。EpollLast() 获取并移除最后一个（最高）元素；如果此 set 为空，则返回
null。booleanremove(Object o)将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
intsize() 返回 set 中的元素数（set 的容量）。
NavigableSet<E>subSet(E fromElement, boolean fromInclusive,E toElement, boolean toInclusive)返回此 set 的部分视图，其元素范围从
fromElement 到 toElement。SortedSet<E>subSet(E fromElement,E toElement) 返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
SortedSet<E>tailSet(E fromElement)返回此 set 的部分视图，其元素大于等于 fromElement。
NavigableSet<E>tailSet(E fromElement, boolean inclusive)返回此 set 的部分视图，其元素大于（或等于，如果
inclusive 为 true）fromElement。核心接口
Ø Java集合框架的核心接口有两种：Collection（聚集）和Map(映射)
Ø Collection 接口是一组允许重复的对象。
Ø Set 中的数据对象没有顺序且不可以重复。接口
Ø List中的数据对象有顺序且可以重复。接口
Ø Map接口是一组成对的键－值对象，即所持有的是key-value pairs。Map中不能有重复的key。拥有自己的内部排列机制。不能有重复的键
Collection
Ø 类 java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用算法
Ø void sort(List l) 对List容器内的元素排序
Ø void shuffle(List l) 对List容器内的对象进行随机排列
Ø void reverse(List l) 对List容器内的对象进行逆续排列
Ø void fill(List l, Object o)
Ø 用一个特定的对象重写整个List容器
Ø void copy(List dest,List src)
Ø 将src List容器内容拷贝到dest List容器
Ø int binarySearch(List l, Object o)
Ø 对于顺序的List容器，采用折半查找的方法查找特定对象
例题：
List l1 = new LinkedList();
List l2 = new LinkedList();
for(int i=0; i<=9; i++) { l1.add("a"+i); }
System.out.println(l1);
Collections.shuffle(l1); //随机排列
System.out.println(l1);
Collections.reverse(l1); //逆续
System.out.println(l1);
Collections.sort(l1); //排序
System.out.println(l1);
System.out.println(Collections.binarySearch(l1,“a5”)); //折半查找
List
Ø List接口是Collection的子接口，实现List接口的容器类中的元素是有顺序的，而且可以重复
Ø List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
Ø List 接口中所定义的方法：
Ø Object get(int index);
Ø Object set(int index, Object element);
Ø void add(int index, Object element);
Ø Object remove(int index);
Ø int indexOf(Object o);
Ø int lastIndexOf(Object o);
————————————————————————————————————————————————————————————————————————————————————————————————————————————
List接口的实体类——LinkList类
Ø 第一步，确定存储方式
1、LinkedList类是List接口的一个具体实现类
2、LinkedList 类用于创建链表数据结构
3、插入或者删除元素时，它提供更好的性能
Ø 创建一个类Stack，代表堆栈（其特点为：后进先出），添加方法add(Object obj)、以及get()，添加main方法进行验证，要求：
Ø 使用LinkedList实现堆栈
Ø 在向LinkedList中添加时，使用addLast方法
Ø 在从LinkedList中取出时，使用removeLast方法
import java.util.*;
public class MyStack {
/**
* List的实现类LinkedList
* LinkedList存储时按照后进先出的原则
*/
private LinkedList<Object> stack=new LinkedList<Object>();
/**
* 把对象存入LinkedList的第一个位置
*/
public void push(Object o)
{
stack.addFirst(o);
}
/**
* @param args
* 把第一个位置的对象进行删除
*/
public Object pop()
{
return stack.removeFirst();
}
/**
* 取得LinkedList的第一个元素
*/
public Object peek()
{
return stack.getFirst();
}
public static void main(String[] args) {
MyStack m=new MyStack();
m.push("wangwu");
m.push("zhangsan");
m.push("lisi");
System.out.println("现在箩筐顶部的元素是："+m.peek());
m.pop();
System.out.println("现在箩筐顶部的元素是："+m.peek());
}
}
ArrayList类
import java.util.ArrayList;
public class TestArrayList {
/**
* List接口的第二个实现类，按照先进先出
*/
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
for (int i=0;i<list.size();i++)
{
String temp=list.get(i);
System.out.println(temp);
}
}
}
——————————————————————————————————————————————————————————————————————————————————————————————————
import java.util.ArrayList;
class Student
{
public String name;
public int num;
public String address;
public Student(String name,int num,String address)
{
this.name=name;
this.num=num;
this.address=address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
public class Arrayzuoye {
/**
* 利用ArrayList来存储一个小学生类，学生类有学号，姓名，住址三个属相，实例化出一个学生“张三”。并且进行遍历取出
* 集合中不是真正存入某个对象， 而是保存的是对象的引用
*/
public static void main(String[] args) {
ArrayList<Student> list=new ArrayList<Student>();
Student s=new Student("张三",1000000,"中国");
//把张三这个对象存入ArryList中
list.add(s);
//s.setName("李四");
System.out.println(list.get(0).name);
}
}
Ø ArrayList类封装了一个动态再分配的Object[]数组。
Ø 集合框架中保存的都是对象的引用， 不是对象的备份。这一点尤其重要
————————————————————————————————————————————————————————————————————————————————————————————————————————————————
111111111111111111111111111——News类
import java.util.Date;
public class News {
private int id;
private String title;
private String creater;
private Date date;
public News(int id,String title,String creater,Date date)
{
this.id=id;
this.title=title;
this.creater=creater;
this.date=date;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getCreater() {
return creater;
}
public void setCreater(String creater) {
this.creater = creater;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
}
22222222222222222222222222——
import java.util.ArrayList;
import java.util.Date;
public class TestNews {
/**
* @param args
*/
public static void main(String[] args) {
News new1=new News(1,"car","管理员",new Date());
News new2=new News(2,"newz","管理员",new Date());
ArrayList<News> list=new ArrayList<News>(); //
list.add(new1);
list.add(new2);
System.out.println(list.size());
for(int i=0;i<list.size();i++)
{
//News n=(News)list.get(i);
//System.out.println(n.getTitle());
System.out.println(list.get(i).getTitle());
}
}
}
——————————————————————————————————————————————————————————————————————————————————————————————————————————
List接口的实体类ArrayList做删除
import java.util.ArrayList;
public class DelteArrays {
/**
* @param args
*/
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
String value="";
System.out.println(list.size());
for(int i=0;i<list.size();i++)
{
System.out.println(list.get(i));
}
for(int i=0;i<list.size();i++)
{
value=list.get(i);
if("3".equals(value))
{
list.remove(i);
}
}
System.out.println(list.size());
for(int i=0;i<list.size();i++)
{
System.out.println("使用传统遍历方式后"+"现在的值"+list.get(i));
}
}
Iterator接口
Ø 所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
Ø Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。
Ø Iterator接口定义了如下方法：
Ø boolean hasNext(); //判断游标右边是否有元素
Ø Object next(); //返回游标右边的元素并将游标移动到下一个位置
Ø void remove(); //删除游标左面的元素，在执行完next之后该
//操作只能执行一次
————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
import java.util.ArrayList;
import java.util.Iterator;
public class DeleteByIterator {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("3");
list.add("3");
list.add("3");
list.add("4");
String value="";
Iterator<String> it=list.iterator(); //对容器list的内容进行遍历while(it.hasNext()) //游标在第一个元素的左边,判断下一个元素是否存在
{
value=it.next();
if("3".equals(value))
{
it.remove();
}
}
for(int i=0;i<list.size();i++)
{
System.out.println("现在的值"+list.get(i));
}
}
}
——————————————————————————————————————————————————————————————————————————————————————————————————————————————
import java.util.HashSet;
import java.util.Iterator;
public class TestSet1 {
public static void main(String[] args) {
HashSet<String> set=new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
for(Iterator<String> iter=set.iterator();iter.hasNext();)
{
System.out.println(iter.next());
}
}
}
——————————————————————————————————————————————————————————————————————————————————————————————————
Set接口
Set 接口继承 Collection 接口，它不允许集合中存在重复项, 而且它不象List按照加入列表的顺序存储元素，它有自己的排列法则。
Ø Set 接口是Collection的子接口，Set接口没有提供额外的方法，但实现 Set 接口的容器类中的元素是没有有顺序的，而且不可以重复
Ø Set 容器可以与数学中“集合”的概念相对应
Ø J2SDK API中 所提供的 Set 容器类有 HashSet，TreeSet 等
import java.util.HashSet;
import java.util.Iterator;
public class TestSet1 {
public static void main(String[] args) {
HashSet<String> set=new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
for(Iterator<String> iter=set.iterator();iter.hasNext();)
{
System.out.println(iter.next());
}
}
}
HashSet类
Ø 用HashSet过滤自定义类。一般认为如果学号一致，就应该是同一个人。本例的过滤规则就是同学号的学生将保留一个。
11111111111111111111111111111111111111——Student类
import java.util.HashSet;
import java.util.Iterator;
class Student
{
private String num;
private String name;
Student(String num,String name)
{
this.num=num;
this.name=name;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return "学号是"+num+"姓名是"+name;
}
public int hashCode() {
return this.getNum().hashCode();
}
public boolean equals(Object obj) {
Student stu=(Student) obj;
if(this.getNum()==stu.getNum()){
return true;
}
return false;
}
}
public class TestStudent {
public static void main(String[] args) {
HashSet<Student> set=new HashSet<Student>();
Student s1=new Student("13","李四");
Student s2=new Student("12","张三");
Student s3=new Student("12","w");
Student s4=new Student("11","f");
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
//问题1：如何打印出来就是姓名+学号这种形式呢？
//问题2：set中存储的对象如果hashCode一致，就认为是一个对象
//只要对象学号的hasCode一致，set进行自动过滤
//iter.next()进行对象实例化时，会自动调用类中隐藏的方法
for(Iterator<Student> iter=set.iterator();iter.hasNext();)
{
System.out.println(iter.next());
}
}
}
LinkedHashSet的用法
LinkedHashSet是HashSet的子类，用法和HashSet一致。
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetTest {
/**
* 存储有序对象先进先出
*/
public static void main(String[] args) {
LinkedHashSet<String> set=new LinkedHashSet<String>();
set.add("1");
set.add("2");
set.add("3");
set.add("4");
for(Iterator<String> iter=set.iterator();iter.hasNext();)
System.out.println(iter.next());
}
}
Map接口
Ø Map接口不是Collection接口的继承。Map接口用于维护键/值对(key/value pairs)。
该接口描述了从不重复的键到值的映射。
Ø 实现Map接口的类用来存储键－值 对。
Ø Map 接口的实现类有HashMap（查找速度最快）和TreeMap等,HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序 。
Ø Map类中存储的键－值对通过键来标识，所以键值不能重复
Map 接口方法
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
Ø 第一步，确定存储方式
1、Map接口用于维护“键-值对”的关联性，可以通过键查找值
2、HashMap是Map接口的一个具体实现类
————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
import java.util.HashMap;
import java.util.Iterator;
public class MapTest {
/**
* @param args
*/
public static void main(String[] args) {
HashMap<String,String> map=new HashMap<String,String>();
map.put("001","aaaaaaaaaa");
map.put("002","bbbbbbbbbbbb");
map.put("003","cccccccccccccc");
System.out.println(map.get("001"));
//先把HashMap转换成Set接口，再通过接口的相应方法遍历
for(Iterator<String> iter=map.keySet().iterator();iter.hasNext();)
{
String key=(String)iter.next();
System.out.println(key+""+map.get(key));
}
//如果说map里面包含001的键值
if(map.containsKey("001")){
System.out.println("有此键值");
}else{
System.out.println("无此键值");
}
}
}
——————————————————————————————————————————————————————————————————————
package i;
import java.util.HashMap;
import java.util.Iterator;
public class Student {
private String name;
private String className;
public Student(String name,String className)
{
this.name=name;
this.className=className;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String toString() {
// TODO Auto-generated method stub
return this.className;
}
public static void main(String arge[])
{
Student s1=new Student("rose","c1");
Student s2=new Student("jack","c2");
HashMap<Student, String> hm=new HashMap<Student, String>();
hm.put(s1, "rose");
hm.put(s2, "jack");
for(Iterator<Student> iter=hm.keySet().iterator();iter.hasNext();)
{
Student s=(Student)iter.next();
System.out.println(s+""+hm.get(s));
}
}
}
package j;
import i.Student;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
class Book {
private String title;
public Book(String title)
{
this.title=title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String toString() {
// TODO Auto-generated method stub
return this.getTitle();
}
}
public class BookTest{
public static void main(String argc[])
{
Book book1=new Book("呼啸山庄");
Book book2=new Book("简爱");
Map hs=new HashMap();
hs.put("001", book1);
hs.put("002", book2);
for(Iterator iter=hs.keySet().iterator();iter.hasNext();)
{
String b=(String)iter.next();
System.out.println(b+""+hs.get(b));
}
}
}
总结：
Ø Java的集合框架分别派生自Collection和Map接口。
Ø Collection有两个常用子接口List和Set，分别表示有序可重复，无序不可重复的集合。
- 从”JAVA“而终 12：java集合框架API讲解
- 从”JAVA“而终 18：java Jdbc编程（ResultSet）集合讲解
- 从”JAVA“而终 21：Html讲解
- 从”JAVA“而终 22：CSS讲解
- 从”JAVA“而终 23：JQuery讲解
- 从”JAVA“而终 25：Servlet讲解
- 从”JAVA“而终 27：Ajax讲解
- java集合框架讲解
- 从”JAVA“而终 8：java循环判断语句讲解
- 从”JAVA“而终 19：java 反射（Reflect）讲解
- java集合框架的讲解
- java集合框架的讲解
- java集合框架的讲解
- java集合框架的讲解
- 从”JAVA“而终 26：JSP详细讲解
- 从”JAVA“而终 24：BOM以及DOM讲解
- java集合框架（1）-从api角度分析集合框架的结构
- java常用集合框架简单讲解
- (设计模式)简单工厂模式之通过配置文件动态创建实现类
- ReactionCocoa 登陆界面
- 初学者编了个象棋程序，工程完成度百分之九十五，跟大家分享下，希望下一步能做个图形界面，欢迎交流
- HDU 3068 最长回文 Manacher
- 解决eclipse快捷键冲突问题和修改eclipse快捷键
- 从”JAVA“而终 12：java集合框架API讲解
- hadoop技术原理
- Android入门---ImageView(图像视图)
- 分治法之合并排序（C实现）
- log4j.properties文件的配置不起作用
- (java)3sum
- UITableview reloadData 无效
- 9.5 编辑类
- Android 通过WiFi连接adb
