下面是常用的工具类:
1. 数组
a) 作用
是一种容器,可以在其中放置对象或基本类型数据。从而,实现使用数组管理一组对象。
b) 优势
是一种简单的线性序列,可以快速的访问数组元素,效率高。如果从效率和类型检查的角度讲,数组是最好的。
c) 劣势
不灵活:容量事先定义好,不能随着需求的变化而扩容。
比如:我们在一个用户管理系统中,要把今天注册的所有用户取出来,那么这个用户有多少个?我们在写程序时是无法确定的。如果,你能确定那你就是神了。因此,就不能使用数组。
因此,数组远远不能满足我们的需求。我们需要一种灵活的,容量可以随时扩充的容器来装载我们的对象。这就是我们今天要学习的容器类,或者叫集合框架。
2.list
Collection接口
Collection 表示一组对象,它是集中,收集的意思,就是把一些数据收集起来
Collection接口的两个子接口:
Set中的数据没有顺序,不可重复。
List中的数据有顺序,可重复。
Collection接口中定义的方法:
boolean add(Object element);
boolean remove(Object element);
boolean contains(Object element);
int size();
boolean isEmpty();
void clear();
Iterator iterator();
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c); //交集
Object[] toArray();
LIST接口
有序的Collection。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。与 set不同,列表通常允许重复的元素。更确切地讲,列表通常允许满足e1.equals(e2) 的元素对 e1 和e2,并且如果列表本身允许 null 元素的话,通常它们允许多个 null 元素。
多了一些跟顺序有关的方法:
void add(Object element);
void add(int index, Object element);
Object get (int index);
Object set(int index,Object element);//修改某一位置的元素
Objectremove (int index);
int indexOf (Object o);//返回某个元素的索引。如果没有该数据,返回-1
LinkedList:底层用双向链表实现的List。特点:查询效率低,增删效率高,线程不安全。
ArrayList:底层用数组实现的List。特点:查询效率高,增删效率低,线程不安全。
Vector:底层用数组实现的List,特点:线程安全。
如何选用?
线程安全用Vector。
线程不安全,查找较多用ArrayList。增加或删除元素较多用LinkedList
SET接口
HashSet:采用哈希算法实现的Set
HashSet的底层是用HashMap实现的,因此,查询效率高。由于采用Hashcode算法直接确定元素的内存地址,增删效率也高。
Set s = new HashSet();
s.add (“hello”);
s.add (“world”);
s.add (new Integer(4));
s.add (new Double(1.2));
s.add (“hello”); // 相同的元素不会被加入
System.out.println (s);
练习
将list、set中的方法挨个写测试。学习一下。
a) 熟悉debug。使用debug帮助我们理解学习。
b) 熟悉:typeHierarchy(类的层次关系), call Hierarchy(方法调用关系)
Map接口
实现Map接口的类用来存储键(key)-值(value) 对。
Map 接口的实现类有HashMap和TreeMap等。
Map类中存储的键-值对通过键来标识,所以键值不能重复。
HashMap: 线程不安全,效率高. 允许key或value为null
HashTable:线程安全,效率低. 不允许key或value为null
ashTable的子类,key和value都是string
常用的方法:
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();
方法测试:
Map m1 = new HashMap();
Map m2 = new HashMap();
m1.put(“one”, new Integer(1));
m1.put(“two”, new Integer(2));
m1.put(“three”, new Integer(3));
m2.put(“A”, new Integer(1));
m2.put(“B”, new Integer(2));
System.out.println(m1.size());
System.out.println(m1.containsKey(“one”));
System.out.println(m2.containsValue(new Integer(1)));
if (m1.containsKey(“two”)) {
int i = ((Integer) m1.get(“two”)).intValue();
System.out.println(i);
}
Map m3 = new HashMap(m1);
m3.putAll(m2);
System.out.println(m3);
Iterator接口[雨林木风2]
所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
Iterator对象称作迭代器,用以方便的实现对容器内元素的遍历操作。
Iterator接口定义了如下方法:
boolean hasNext(); //判断是否有元素没有被遍历
Object next(); //返回游标当前位置的元素并将游标移动到下一个位置
void remove(); //删除游标左面的元素,在执行完next之后该
//操作只能执行一次
遍历集合:
遍历List方法1,使用普通for循环:
for(int i=0;i<list.size();i++){
String temp = (String)list.get(i);
System.out.println(temp);
//list.remove(i); //遍历删除元素,不过不推荐这种方式!
}
遍历List方法2,使用增强for循环(应该使用泛型定义类型!):
for (String temp : list) {
System.out.println(temp);
}
遍历List方法3,使用Iterator迭代器:
for(Iterator iter = list.iterator();iter.hasNext()😉{
String temp = (String)iter.next();
System.out.println(temp);
}
或者:
Iterator iter = c.iterator();
while(iter.hasNext()){
Object obj = iter.next();
iter.remove(); //如果要遍历删除集合中的元素,建议使用这种方式!
System.out.println(obj);
}
遍历Set方法1,:
for(String temp:set){
System.out.println(temp);
}
遍历Set方法2,使用iterator迭代器
for(Iterator iter = set.iterator();iter.hasNext()😉{
String temp = (String)iter.next();
System.out.println(temp);
}
遍历Map
// Map<Integer, Man> maps = new HashMap<Integer, Man>();
Set keySet = maps.keySet();
for(Integer id : keySet){
System.out.println(maps.get(id).name);
}
Collections工具类
类 java.util.Collections 提供了对Set、List、Map操作的工具方法。
void sort(List) //对List容器内的元素排序,
//排序的规则是按照升序进行排序。
void shuffle(List) //对List容器内的元素进行随机排列
void reverse(List) //对List容器内的元素进行逆续排列
void fill(List, Object) //用一个特定的对象重写整个List容器
int binarySearch(List, Object)//对于顺序的List容器,采用折半查找的 //方法查找特定对象
List aList = new ArrayList();
for (int i = 0; i < 5; i++)
aList.add(“a” + i);
System.out.println(aList);
Collections.shuffle(aList); // 随机排列
System.out.println(aList);
Collections.reverse(aList); // 逆续
System.out.println(aList);
Collections.sort(aList); // 排序
System.out.println(aList);
System.out.println(Collections.binarySearch(aList, “a2”));
Collections.fill(aList, “hello”);
System.out.println(aList);
Comparable接口
Ø 问题:上面的算法根据什么确定集合中对象的“大小”顺序?
Ø 所有可以“排序”的类都实现了java.lang.Comparable 接口,Comparable接口中只有一个方法
public int compareTo(Object obj);
该方法:
§ 返回 0 表示 this == obj
§ 返回正数表示 this > obj
§ 返回负数表示 this < obj
Ø 实现了Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。
public class TestComparable {
/**
* @param args
*/
public static void main(String[] args) {
List list = new ArrayList();
Student stu1 = new Student(1,“张三”,100);
Student stu2 = new Student(2,“张四”,80);
Student stu3 = new Student(3,“张五”,90);
list.add(stu1);
list.add(stu2);
list.add(stu3);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
}
}
class Student implements Comparable {
int id;
String name;
int score;
public Student(int id, String name, int score) {
super();
this.id = id;
this.name = name;
this.score = score;
}
public String toString(){
return name+score;
}
@Override
public int compareTo(Student o) {
if(this.score>o.score){
return 1;
}else if(this.score<o.score){
return -1;
}else {
return 0;
}
}
}
equals和hashcode方法:
l Collection类对象是否相等对象在调用remove、contains 等方法时需要比较,这会涉及到对象类型的 equals 方法和hashCode方法;对于自定义的类型,需要重写equals 和 hashCode 方法以实现自定义的对象相等规则。
l 注意:Java中规定,两个内容相同的对象应该具有相等的hashcode
什么时候需要我们重写equal,hashcode方法?
这样作的目的就是为了你的类就能够很好的与java的集合框架协同工作。如果我们能够确认我们定义的类不会和java集合类产生关系,那么我们完全没有必要在覆写equals()方法的时候覆写hashCode。
如下情况,可能需要我们重写equal/hashcode方法:
要将我们自定义的对象放入HashSet中处理。
要将我们自定义的对象作为HashMap的key处理。
放入Collection容器中的自定义对象后,可能会调用remove,contains等方法时。
Equal和hashcode的关系和原理:
1. Hashcode并不是内存地址,是内存地址转换而来的。系统通过它也可以确定内存地址。
2. hashcode方法主要用在集合框架中,目的是为了快速比较两个对象是否相等,因为集合框架中的对象很多,每个都使用equals比较效率很差。
每个对象都有一个hashcode,规定:
1、内容相同的对象hashcode肯定相等
2、内容不相同的对象hashcode可能相等也可能不相等
所以如果两个对象的hashcode不相等则两个对象的内容肯定不相等,这样就不必一个一个去比较属性的值了,从而提高对象比较的速度。
可以直接利用eclipse生成equal和hashcode方法,对于我们一般的程序来说已经足够了。
class Man {
int id;
int age;
String name;
public Man(int id, int age, String name) {
super();
this.age = age;
this.name = name;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Man other = (Man) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode()) ;
return result;
}
}
Ø 泛型(5.0以后增加的!! 以后大家使用容器时,建议大家使用泛型!!)
为什么需要泛型?
1. JDK1.4以前类型不明确:
2. 装入集合的类型都被当作Object对待,从而失去自己的实际类型。
3. 从集合中取出时往往需要转型,效率低,容易产生错误。
泛型的好处:
4. 增强程序的可读性和稳定性。
泛型的使用:
List list = new ArrayList();
Set mans = new HashSet();
Map<Integer, Man> maps = new HashMap<Integer, Man>();
Iterator iterator = mans.iterator();
n 常见面试题:
1. Collection 和 Collections的区别。
Collections是个java.util下的类,它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口,它是各种集合结构的父接口。
2. List, Set, Map是否继承自Collection接口?
List,Set是 Map不是
3. ArrayList和Vector的区别。
一.同步性:Vector是线程安全的,也就是说是同步的,而ArrayList是线程序不安全的,不是同步的 。
二.数据增长:当需要增长时,Vector默认增长为原来一培,而ArrayList却是原来的一半。
4. HashMap和Hashtable的区别
同步性:Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的
作用:
经常用于读取资源文件内容
所有的属性的值都相等才算相等。这个可以根据自己的实际情况进行改写。
如果只需要比较id,那么就用id 就可以了。
散列算法。
而如果只用少量的属性采样散列,极端情况会产生大量的散列冲突,如对"人"的属性中,如果用性别而不
是姓名或出生日期,那将只有两个或几个可选的hashcode值,将产生一半以上的散列冲突.
原文链接:https://blog.csdn.net/HarderXin/article/details/6802777