Java集合篇

集合的类型以及方法

package testcollection;
impor java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
/*** @author dreamcoder
*1.CollectiJava集合框架
* 1.1集合是一种容器，可以动态把多个对象的引用放入容器中， 还可以保存具有映射关系的关联数组
2. on接口API
* 3.Iterator迭代器接口遍历集合
* 3.1两个重要的方法 hasNext()以及next()
* 3.2Java5提供了foreach循环迭代访问Collection
* 4.Collection接口
* 4.1 Collection子接口之一：Set接口
* 4.1.1 Set:元素无序，不可重复的集合
* HashSet LinkedHashSet TreeSet
* 4.1.2 List:元素有序，可重复的集合 —“动态数组”
* ArrayList LinkedList Vector
* 4.1.3 Queue接口
* 4.2 Collection子接口之二： List接口
* 4.2.1 ArrayList LinkedList Vector
* 5.Map接口
*5.1具有映射关系《key-value》的集合
* HashMap TreeMap Hashtable
* 6.Collections工具类
*

public class Person {
private String name;
private int 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;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return “Person [name=” + name + “, age=” + age + “]”;
}
}
public class TestCollection {
public static void main(String[] args) throws ClassCastException{
Collection coll = new ArrayList();
//1.collection add()方法
Person e1 = new Person(“Tom”,12);
Person e2 = new Person(“Jerry”,10);
Person e3 = new Person(“Marry”,11);
Person e4 = new Person(“Shrey”,9);
coll.add(e1);
coll.add(e2);
coll.add(e3);
coll.add(e4);
//2.isEmpty()方法
System.out.println(coll.isEmpty());
//3.Iterator 遍历集合
// Iterator it = coll.iterator();
// while(it.hasNext()) {
// Person p = (Person) it.next();
// System.out.println§;
// }
// //4.remove()方法
// Person p1 = new
Person(“Marry”,11);
// coll.remove(p1);
// //5.size()
// System.out.println(coll.size());
//List集合方法
List lst = new ArrayList();
Set set = new HashSet();
//1.Set可以用HashSet,LinkedHshSet、TreeSet实现
//1.1HashSet中hashCode()方法实现对象相等规则
//1.2LinkedSet()不允许集合重复
List lklist = new LinkedList();
//1.3TreeSet是Sorted接口的实现类，TreeSet可以确保元素集合处于排序状态
Comparator com = (Comparator) new Comparable(){
public int compareTo(Object o1,Object o2) throws ClassCastException{
if(o1 instanceof Person && o2 instanceof Person) {
Person p1 = (Person) o1;
Person p2 = (Person) o2;
if(p1.getAge() != p2.getAge()) {
return p1.getAge() - p2.getAge();
}
}
return 0;
}
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
};
Set set1 = new TreeSet(com);
set1.add(e1);set1.add(e2);set1.add(e3);set1.add(e4);
Iterator i1 = set1.iterator();
while(i1.hasNext()) {
Person e = (Person) i1.next();
System.out.println(e);
}
//2.TreeSet的两种排序方法：自然排序以及定制排序
//2.1自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系
//，然后将集合元素按升序排列
//如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
//实现 Comparable 的类必须实现 compareTo(Object obj) 方法，
//两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
//2.2
//自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排列
//
//如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
//实现 Comparable 的类必须实现 compareTo(Object obj) 方法，
//两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
//void add(int index, Object ele)
lst.add(e1);lst.add(e2);lst.add(e3);lst.add(e4);
lklist.add(e1);lklist.add(e2);
lklist.add(e3);lklist.add(e4);
set.add(e1);set.add(e2);
//boolean addAll(int index, Collection eles)
//Object get(int index)
Person p = (Person) lst.get(2);
System.out.println§;
//int indexOf(Object obj)
System.out.println(lst.indexOf(e3));
//int lastIndexOf(Object obj)
System.out.println(lst.lastIndexOf(e4));
//Object remove(int index)
lst.remove(2);
Iterator i = lst.iterator();
while(i.hasNext()) {
Person p1 = (Person) i.next();
System.out.println(p1);
}
//Object set(int index, Object ele)
try {
Person p2 = new Person(“shali”,14);
lst.set(2, p2);
} catch (Exception e) {
e.printStackTrace();
System.err.println(“数组越界”);
}
//List subList(int fromIndex, int toIndex)
List subl = lst.subList(0, 2);
}

}
Map

package
testcollection;

import java.util.Comparator;

import java.util.Hashtable;

import
java.util.Iterator;

import java.util.Map;

import
java.util.TreeMap;

/**

* @author dell

* 1.Map

*  1.1
Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value

*  1.2
Map 中的 key 和  value 都可以是任何引用类型的数据

*  1.3
Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法。

*  1.4 常用String类作为Map的“键”。

*  1.5
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。

* 2.MapTree

* 2.1TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。

* 2.2TreeMap 的 Key 的排序：

*  2.2.1自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，

*                      而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException

*  2.2.2定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。

*                                  此时不需要 Map 的 Key 实现 Comparable 接口

*/

public class MyMap {

public static void main(String[] args) {

Comparable com = new Comparable();

TreeMap map = new TreeMap(com);

//Object put(Object key,Object value)

map.put(“A”, new Person(“Tom”,12));

map.put(“B”, new Person(“Jerry”,13));

map.put(“C”, new Person(“Phil”,11));

map.put(“D”, new Person(“Green”,14));

Iterator it = map.keySet().iterator();

while(it.hasNext()) {

System.out.println(map.get(it.next()));

}

//Object remove(Object key)

//map.remove(“C”);

//Object get(Object key)

//boolean containsKey(Object key)

System.out.println(map.containsKey(“A”));

//boolean containsValue(Object value)

Person p = new Person(“Green”,14);

System.out.println(map.containsValue§);

//int size()

System.out.println(map.size());

//boolean isEmpty()

System.out.println(map.isEmpty());

}

}