Collection接口
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）通用的一些方法，这些方法可以用于操作所有的单列集合
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Collection.html
常用方法：
boolean add(E e) //确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c) //将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear() //移除此 collection 中的所有元素（可选操作）。
boolean remove(Object o) //从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c) //移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean isEmpty() //如果此 collection 不包含元素，则返回 true。
boolean contains(Object o) //如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c) //如果此 collection 包含指定 collection 中的所有元素，则返回 true。
Iterator<E> iterator() //返回在此 collection 的元素上进行迭代的迭代器。
int size() //返回此 collection 中的元素数。
List接口
在线API文档
List接口简介:
List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性的方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合中还有一个特点就是元素的有序，即元素的存入顺序和取出顺序一致。
ArrayList类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/ArrayList.html
构造方法
ArrayList() //构造一个初始容量为 10 的空列表。
ArrayList(Collection<? extends E> c) //构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList(int initialCapacity) //构造一个具有指定初始容量的空列表。
常用方法
boolean add(E e) //将指定的元素添加到此列表的尾部。
void clear() //移除此列表中的所有元素。
boolean contains(Object o) //如果此列表中包含指定的元素，则返回 true。
int indexOf(Object o) //返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
int lastIndexOf(Object o) //返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E remove(int index) //移除此列表中指定位置上的元素。
int size() //返回此列表中的元素数。
实例
/**
* ArrayList集合（比较常用）
*/
public static void test1(){
ArrayList<String> list = new ArrayList<String>();
list.add("lingdu");
list.add("小明");
list.add("小华");
//查看集合大小
System.out.println("集合大小：" + list.size());
System.out.println("\n修改***************************");
//修改
list.set(2, "小平");
System.out.println(list.get(2));
System.out.println("\n删除***************************");
//删除 （删除元素1 ->Lingdu,此时 元素2->小明 会向上移动一位变成元素1）
list.remove(0);
System.out.println(list.get(0));
System.out.println("\n遍历集合***************************");
//循环输出
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = (String)it.next();
System.out.println(str);
}
System.out.println("\n**********\n");
//集合与集合之间的操作
List<String> grilList = new ArrayList<String>();
grilList.add("小明");
grilList.add("小平");
//返回元素中是否包涵 Lingdu
System.out.println("list集合中是否包涵：lingdu -->" + list.contains("Lingdu"));
//如果列表包含指定的元素，则返回 true。
System.out.println("list集合中是否包涵：grilList集合的数据 -->" + list.contains(grilList));
//从列表中移除指定 collection 中包含的其所有元素
System.out.println("删除list集合中包涵grilList集合的所有元素：" + list.removeAll(grilList));
//创建迭代器
Iterator<String> it1 = list.iterator();
System.out.println("----------------");
while(it1.hasNext()){
String str1 = (String)it1.next();
System.out.println(str1);
}
//清空集合
list.clear();
System.out.println("清空之后集合的大小是：" + list.size());
}
LinkedList类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/LinkedList.html
构造函数
LinkedList() //构造一个空列表。
LinkedList(Collection<? extends E> c) //构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
pollFirst() //获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
实例
/**
* 使用LinkedList实现队列的效果
*/
public static void test2(){
LinkedList<Person> list = new LinkedList<Person>();
Person p1 = new Person(18,"小明");
Person p2 = new Person(22,"小华");
Person p3 = new Person(21,"小王");
list.add(p1);
list.add(p2);
list.add(p3);
Person p = null;
while((p = (Person)list.pollLast()) != null){
System.out.println(p.name);
}
}
/**
* 测试类
* @author LingDu
*/
class Person{
int age;
String name;
public Person(int age,String name){
this.age = age;
this.name = name;
}
public Person(){}
}
Stack类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Stack.html
构造方法
Stack() //创建一个空堆栈。
常用方法
boolean empty() //测试堆栈是否为空。
E peek() //查看堆栈顶部的对象，但不从堆栈中移除它。
E pop() //移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item) //把项压入堆栈顶部。
int search(Object o) //返回对象在堆栈中的位置，以 1 为基数。
实例
/**
* 使用Stack堆栈实现后进先出的效果
*/
public static void test3(){
Stack<Person> stack = new Stack<Person>();
Person p1 = new Person(18,"小明");
Person p2 = new Person(22,"小华");
Person p3 = new Person(21,"小王");
stack.add(p1);
stack.add(p2);
stack.add(p3);
Person p = null;
//如果集合不为空
while(stack.size() != 0){
p = stack.pop();
System.out.println(p.name);
}
}
Set接口
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Set.html
Set接口简介
Set接口和List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中的元素无序，并且都会与某种规则保证存入的元素不出现重复。
Set接口不能加入重复元素，但是可以排序
HashSet类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/HashSet.html
构造方法
HashSet() //构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
HashSet(Collection<? extends E> c) //构造一个包含指定 collection 中的元素的新 set。
常用方法
boolean add(E e) //如果此 set 中尚未包含指定元素，则添加指定元素。
void clear() //从此 set 中移除所有元素。
boolean isEmpty() //如果此 set 不包含任何元素，则返回 true。
boolean remove(Object o) //如果指定元素存在于此 set 中，则将其移除。
int size() //返回此 set 中的元素的数量（set 的容量）。
实例
/**
* HashSet 类
* 特点：不能有重复
*/
public static void test4(){
//使用HashSet测试，将相同的数据存入集合
HashSet<String> set = new HashSet<String>();
set.add("零度");
set.add("小明");
set.add("小华");
set.add("零度");
//输出HashSet集合长度，如果长度为3，说明已经集合中不能有重复的数据
System.out.println(set.size());
//使用ArrayList测试，将相同的数据存入集合
ArrayList<String> list = new ArrayList<String>();
list.add("零度");
list.add("小明");
list.add("小华");
list.add("零度");
//输出ArrayList集合长度，该集合可以存入重复的数据
System.out.println(list.size());
}
TreeSet类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/TreeSet.html
构造方法
TreeSet() //构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection<? extends E> c) //构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
常用方法
boolean add(E e) //将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
int size() //返回 set 中的元素数（set 的容量）。
对数字进行排序
/**
* TreeSet
* 可以按自然顺序进行排序
*/
public static void test5(){
TreeSet<Integer> set = new TreeSet<Integer>();
set.add(10);
set.add(8);
set.add(3);
set.add(7);
set.add(2);
for (Iterator<Integer> iterator = set.iterator(); iterator.hasNext();) {
Integer integer = (Integer) iterator.next();
System.out.println(integer);
}
}
对字母进行排序
/**
* TreeSet
* 对字母进行排序
*/
public static void test6(){
TreeSet<String> set = new TreeSet<String>();
set.add("w");
set.add("f");
set.add("g");
set.add("z");
for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
String i = (String) iterator.next();
System.out.println(i);
}
}
对汉字进行排序
/**
* TreeSet
* 对汉字进行排序
*/
public static void test6(){
TreeSet<String> set = new TreeSet<String>();
set.add("玛");
set.add("王");
set.add("玝");
set.add("玜");
for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
String i = (String) iterator.next();
System.out.println(i);
}
}
对自定义对象的排序
/**
* 使用TreeSet类比较自定义对象
* 有几个朋友，按朋友年龄排序
*/
public static void test7(){
//实例化TreeSet类并且实现Comparator接口，重写compare方法
TreeSet<Friend> set = new TreeSet<Friend>(new Comparator<Friend>() {
int returnNum = 0;
/**
* 通过年龄进行排序
*/
@Override
public int compare(Friend o1, Friend o2) {
int o1Age = o1.age;
int o2Age = o2.age;
if(o1Age > o2Age){
returnNum = 1;
}else if(o1Age == o2Age){
returnNum = 0;
}else if(o1Age < o2Age){
returnNum = -1;
}
return returnNum;
}
});
set.add(new Friend("lingdu",22,0));
set.add(new Friend("xiaohua",25,1));
set.add(new Friend("xiaoping",18,2));
set.add(new Friend("xiaowang",20,3));
for (Iterator<Friend> iterator = set.iterator(); iterator.hasNext();) {
Friend friend = (Friend) iterator.next();
System.out.println(friend.name);
}
}
Map接口
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Map.html
Map接口简介
Map接口储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。最常见的Map实现类是HashMap，他的储存方式是哈希表，优点是查询指定元素效率高。
Map接口提供了将键映射到集合的对象,一个映射不能包含重复的键.
每个键最多只能映射到一个值.Map接口中同样提供了集合的常用方法,如clear()方法,isEmpty()方法,Size()方法等.
HashMap类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/HashMap.html
类型参数：
- K - 此映射所维护的键的类型
- V - 所映射值的类型
构造方法
HashMap() //构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
HashMap(Map<? extends K,? extends V> m) //构造一个映射关系与指定 Map 相同的新 HashMap。
常用方法
v put(K key, V value) //在此映射中关联指定值与指定键。
v get(Object key) //返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
void clear() //从此映射中移除所有映射关系。
boolean isEmpty() //如果此映射不包含键-值映射关系，则返回 true。
int Set<K>keySet() //返回此映射中所包含的键的 Set 视图。
Collection<V> values() //返回此映射所包含的值的 Collection 视图。
v entrySet() //返回此映射所包含的映射关系的 Set 视图。
size() //返回此映射中的键-值映射关系数。
实例
/**
* hashMap的用法
* K - 此映射所维护的键的类型
* V - 所映射值的类型
*/
public static void test8(){
HashMap<String, String> map = new HashMap<String, String>();
map.put("lingdu", "123");
map.put("shaojie", "888");
//String str = map.get("lingdu");
//System.out.println(str);
//遍历这个map的三种方式：
System.out.println("\n1：使用keySet()方法拿到key值-----------------");
//先用第一个方法：KeySet()
Set<String> keySet = map.keySet();
for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext();) {
String key = (String) iterator.next();
System.out.println(map.get(key));
}
System.out.println("\n2：使用values()方法拿到value值-----------------");
//用第二种方法：获取values()
Collection<String> coll = map.values();
for (Iterator<String> iterator = coll.iterator(); iterator.hasNext();) {
String values = (String) iterator.next();
System.out.println(values);
}
System.out.println("\n2：使用entrySet()方法拿到所有的key值跟value值-----------------");
//第三那种方法：同时把key和value都取出来
//一个map里包含了多个entry对象，一个entry又包含了一个key和一个value对象
Set<Entry<String, String>> set2 =map.entrySet();
for (Iterator<Entry<String, String>> iterator = set2.iterator(); iterator.hasNext();) {
Entry<String, String> entry = (Entry<String, String>) iterator.next();
System.out.println(entry.getKey() + "=" + entry.getValue());
}
}
TreeMap类
在线API文档
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/TreeMap.html
构造方法
TreeMap() //使用键的自然顺序构造一个新的、空的树映射。
TreeMap(Comparator<? super K> comparator) //构造一个新的、空的树映射，该映射根据给定比较器进行排序。
TreeMap(Map<? extends K,? extends V> m) //构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。
常用方法
V put(K key, V value) //将指定值与此映射中的指定键进行关联。
V get(Object key) //返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。
Set<K> keySet() //返回此映射包含的键的 Set 视图。
Collection<V> values() //返回此映射包含的值的 Collection 视图。
自然排序
/**
* TreeMap可以自然排序
*/
public static void test9(){
TreeMap<String, String> map = new TreeMap<String, String>();
map.put("0000002", "lingdu");
map.put("0000001", "xiaorui");
map.put("0000003", "jony");
//对key值进行排序
Set<String> set = map.keySet();
for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
String string = (String) iterator.next();
System.out.println(string + "------>" + map.get(string));
}
}
对自定义对象进行排序
/**
* 自定义对象排序
*/
public static void test10(){
//实现Comparator<E>接口，重写compare方法
TreeMap<String, Friend> map = new TreeMap<String, Friend>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//compareTo()方法 ---比较两个值，如果前者大于后者，返回1，等于返回0，小于返回-1
return o1.compareTo(o2);
}
});
map.put("4127000002", new Friend("lingdd",22,0));
map.put("4127000001", new Friend("xiaohua",25,1));
map.put("4127000003", new Friend("xiaoming",21,-1));
//拿到所有的values值
Collection<Friend> coll = map.values();
//遍历集合
for (Iterator<Friend> iterator = coll.iterator(); iterator.hasNext();) {
Friend friend = (Friend) iterator.next();
System.out.println(friend.name);
}
}
测试类
/**
* 测试类
* @author LingDu
*/
class Person{
int age;
String name;
public Person(int age,String name){
this.age = age;
this.name = name;
}
public Person(){}
}
/**
* 测试类
* @author LingDu
*/
class Friend{
int age;
String name;
int position;
public Friend(String name,int age,int position){
this.age = age;
this.name = name;
this.position = position;
}
}
4896
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
