Collection 类结构:
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection简介:
Collection接口:继承它的接口类有List和SetList特点:元素有放入顺序,元素可重复
Set 特点:元素无放入顺序,元素不可重复(注意:元素虽然无放入顺序,但是元素在set中的位置是有该元素的HashCode决定的,其位置其实是固定的)
(1)List简介:
List是有序的,List类能定位索引到每个元素位置,List集合中允许有相同元素而不覆盖。
List接口有三个实现类:LinkedList,ArrayList,Vector ,Set接口有两个实现类:HashSet(底层由HashMap实现),LinkedHashSet
ArrayList:
ArrayList它允许所有元素,包括null。ArrayList没有同步。依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组,当元素超过10,那么ArrayList底层会新生成一个数组,然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中, 当新数组无法容纳增加的元素,重复该过程,ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,因为操作之后后续元素需要移动。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
ArrayList基础常用:
void ListTest(){
List<String> list = new ArrayList<String>();
// 向列表的尾部追加指定的元素
list.add("lmx");
// 在列表的指定位置插入指定元素
list.add(1, "lmx");
// 追加指定 collection 中的所有元素到此列表的结尾
list.addAll(new ArrayList<String>());
// 从列表中移除所有元素
list.clear();
// 如果列表包含指定的元素,则返回true
list.contains("lmx");
// 如果列表包含指定 collection 的所有元素,则返回 true
list.containsAll(new ArrayList<Object>());
// 比较指定的对象与列表是否相等
list.equals(new ArrayList<Object>());
// 返回列表中指定位置的元素
list.get(0);
// 返回列表的哈希码值
//a.hashCode()==b.hashCode() &&a.equals(b)。
list.hashCode();
// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.indexOf("lmx");
// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.lastIndexOf("lmx");
// 如果列表不包含元素,则返回 true
list.isEmpty();
// 移除列表中指定位置的元素
list.remove(0);
// 移除列表中出现的首个指定元素
list.remove("lmx");
// 从列表中移除指定 collection 中包含的所有元素
list.removeAll(new ArrayList<Object>());
// 用指定元素替换列表中指定位置的元素
list.set(0, "lmx");
// 返回列表中的元素数
list.size();
// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
list.subList(1, 2);
// 返回以正确顺序包含列表中的所有元素的数组
list.toArray();
// 返回以正确顺序包含列表中所有元素的数组
list.toArray(new String[] { "l", "m" });
}
void ListIteratorTests(){
List<String> list = new ArrayList<String>();
list.add("lmx");
list.add("xml");
// 遍历一
Iterator<String> ite1 = list.iterator();
while (ite1.hasNext()) {
String str = ite1.next();
System.out.println(str);
}
// 遍历二
for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {
String str = ite2.next();
System.out.println(str);
}
// 遍历三
for(String s : list){
System.out.println(s);
}
}
Vector:
Vector特点与ArrayList相同, 不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都一般使用ArrayList 代替。
Vector基础常用:
void VectorTest(){
Vector v = new Vector();
v.add("lmx");
v.add("hello");
v.add("world");
// Vector转换为枚举
Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
Stack:
stack特点:栈结构
stack基础常用:
void StackTest() {
Stack stack = new Stack();
// 向栈里面压一个整数
stack.push(new Integer(100));
stack.push("lmx");
stack.push(new Double(99.99));
// 遍历
Enumeration items = stack.elements();
while (items.hasMoreElements()) {
System.out.print(items.nextElement() + " ");
}
System.out.println();
// 出栈 先进后出
while (stack.size() != 0) {
System.out.print(stack.pop() + " ");
}
}
LinkedList:
LinkedList特点: LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的, 因此有很好的插入和删除性能,但随机访问元素的性能很差,
插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好
private static void printList(List link) {
System.out.println("正序链表中的元素");
// 的到链表的迭代器,位置指向链头
ListIterator li = link.listIterator();
// 判断迭代器中是否有下一个元素
while (li.hasNext()) {
// 返回下个元素
System.out.print(li.next() + " ");
}
System.out.println();
}
private static void printReversedList(List link) {
System.out.println("逆向链表中的元素");
// 的到链表的迭代器,位置指向link.size()结尾
ListIterator li = link.listIterator(link.size());
// 判断迭代器中是否有前一个元素
while (li.hasPrevious()) {
// 返回前一个元素
System.out.print(li.previous() + " ");
}
}
public static void main(String[] args) {
List link = new LinkedList();
link.add(100);
link.add("lmx");
link.add(9.9);
link.add("jqy");
link.add(520);
printList(link);
printReversedList(link);
}
List<Map>:
void ListMap(){
Map<Integer, String> map1 = new HashMap<Integer, String>();
map1.put(new Integer(1), "lmx");
map1.put(new Integer(2), "jqy");
Map<Integer, String> map2 = new HashMap<Integer, String>();
map2.put(new Integer(3), "zcm");
map2.put(new Integer(4), "zl");
List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();
list.add(map1);
list.add(map2);
// 遍历一
Iterator<Map<Integer, String>> ite1 = list.iterator();
while (ite1.hasNext()) {
Map<Integer, String> m = ite1.next();
System.out.println(m);
}
// 遍历二
for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2
.hasNext();) {
Map<Integer, String> m = ite2.next();
System.out.println(m);
}
// 遍历三:
for (Map<Integer, String> m : list) {
System.out.println(m);
}
}
(1)Sst简介:
不包含重复元素,最多包含一个null,元素没有顺序
HashSet:
package com.collection;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetTest {
void RunHashSet() {
HashSet hs = new HashSet();
// 添加第一个元素
hs.add(new String("lmx"));
// 创建一个ArrayList对象,添加多个个元素
ArrayList list = new ArrayList();
list.add("one");
list.add("two");
// 把ArrayList对象添加到HashSet中
hs.addAll(list);
// 在HashSet中添加一个元素
hs.add("three");
// 添加一个null元素
hs.add(null);
// 通过转换成数组遍历的结果
this.toForeachList2(hs);
// 通过得到Iterator遍历的结果
hs.remove("one");
// "删除one元素之后
this.toForeachList1(hs);
System.out.println("HashSet中元素的个数为:" + hs.size());
if (hs.isEmpty()) {
System.out.println("HashSet是空的");
} else {
System.out.println("HashSet不是空的");
}
System.out.println("清空所有的元素:");
hs.clear();
if (hs.isEmpty()) {
System.out.println("HashSet是空的");
} else {
System.out.println("HashSet不是空的");
}
}
/*
* 得到Iterator,然后遍历输出
*/
public void toForeachList1(HashSet hs) {
Iterator i = hs.iterator();
while (i.hasNext()) {
String temp = (String) i.next();
System.out.println(temp);
}
}
/*
* 转换成数组,遍历并输出HashSet中的元素
*/
public void toForeachList2(HashSet hs) {
Object o[] = hs.toArray();
for (int i = 0; i < o.length; i++) {
System.out.println((String) o[i]);
}
}
public static void main(String[] args) {
new HashSetTest().RunHashSet();
}
}
/*输出结果
null
two
one
three
lmx
null
two
three
lmx
HashSet中元素的个数为:4
HashSet不是空的
清空所有的元素:
HashSet是空的*/
LinkedHashSet:
几个set的比较
- HashSet:哈希表是通过使用称为散列法的机制来存储信息的,元素并没有以某种特定顺序来存放;
- LinkedHashSet:以元素插入的顺序来维护集合的链接表,允许以插入的顺序在集合中迭代;
- TreeSet:提供一个使用树结构存储Set接口的实现,对象以升序顺序存储,访问和遍历的时间很快。
Collections:
操作Collection类的工具类,类中方法都是静态的
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionTest {
public void RunCollection() {
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
list1.add("C");
list1.add("5");
List<String> list2 = new ArrayList<String>();
list1.add("1");
list1.add("2");
list2.add("3");
/**
* copy 将所有元素从一个列表复制到另一个列表
*/
Collections.copy(list1, list2);
System.out.print("结果:");
for (String string : list1) {
System.out.print(string);
}
System.out.println("");
// 输出:A B C 1 2 3
/**
* disjoint 如果两个指定collection中没有相同的元素,则返回 true
*/
boolean istrue = Collections.disjoint(list1, list2);
System.out.print("结果:" + istrue);
System.out.println("");
// 输出:true
List<bean> list3 = new ArrayList<bean>();
bean b = new bean();
b.setId("10");
b.setName("lmx");
b.setPw("123456");
list3.add(b);
bean b2 = new bean();
b2.setId("10");
b2.setName("lmx123");
b2.setPw("123456123");
/**
* fill 使用指定元素替换指定列表中的所有元素
*/
Collections.fill(list3, b2);
for (bean bean : list3) {
System.out.println(bean.getName());
}
System.out.println("");
// 输出:lmx123
/**
* frequency 返回指定 collection 中等于指定对象的元素数
*/
int cnt = Collections.frequency(list3, b);
System.out.println(cnt);
System.out.println("");
// 输出:1 //需全等,对象是同一对象才返回
/**
* indexOfSubList 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1
*/
int cnt1 = Collections.indexOfSubList(list1, list2);
System.out.print(cnt1);
System.out.println("");
// 输出:2 list1 为ABC,list2为 C
/**
* max 根据元素的自然顺序,返回给定 collection 的最大元素
*/
String maxValue = Collections.max(list1);
System.out.print(maxValue);
System.out.println("");
// 输出:C ASCII大小比较
/**
* min 根据元素的自然顺序,返回给定 collection 的最大元素
*/
String minValue = Collections.min(list1);
System.out.print(minValue);
System.out.println("");
// 输出:A ASCII大小比较
/**
* replaceAll 使用另一个值替换列表中出现的所有某一指定值
*/
Collections.replaceAll(list1, "5", "6");
for (String string : list1) {
System.out.println(string);
}
System.out.println("");
// 输出:ABC612 5被替换成6
/**
* reverse 反转指定列表中元素的顺序
*/
Collections.reverse(list1);
for (String string : list1) {
System.out.println(string);
}
System.out.println("");
// 输出:216CBA
/**
* shuffle 使用默认随机源随机更改指定列表的序列
*/
Collections.shuffle(list1);
for (String string : list1) {
System.out.println(string);
}
System.out.println("");
// 输出:62BCA1 随机刷出
/**
* sort 根据元素的自然顺序对指定列表按升序进行排序
*/
Collections.sort(list1);
for (String string : list1) {
System.out.println(string);
}
System.out.println("");
// 输出:125ABC ASCII升序
/**
* swap 在指定列表的指定位置处交换元素
*/
Collections.swap(list1, 1, 2);
for (String string : list1) {
System.out.println(string);
}
System.out.println("");
// 输出:ACB512 1位置和2换
}
public static void main(String[] args) {
new CollectionTest().RunCollection();
}
}
class bean {
String id;
String name;
String pw;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPw() {
return pw;
}
public void setPw(String pw) {
this.pw = pw;
}
}
还在编写中···
总结不好多多担待,文章只单纯个人总结,如不好勿喷,技术有限,有错漏麻烦指正提出。本人QQ:373965070