Core Java第十一章知识点总结——集合
知识点预览
集合的概念
集合中的接口
ArrayList
LinkedList
HashSet
TreeSet
HashMap
HashTable
TreeMap
集合关系
Collections工具类
JDK 5.0及更高版本中增加的新特性
集合的概念
1.集合的概念
a)集合是Java中提供的一种类型,用于存储管理对象
b) 为什么不用数组
i.数组难于扩充
ii.不好进行插入和删除
c)集合存储的真是对象吗?
存储的是对象的引用
d) 集合的分类
List 有顺序可重复(有序是可重复的前提)例:上课
Set 无序不可重复(无序注定不可重复)例:大学老师
Map 键值对 keyvalue键值不可重复例:角色演员表
2. 集合中的几种接口
a) List接口
b) Set接口
c) Map接口
List接口
1. List接口
boolean add(Object o);
boolean isEmpty();
boolean remove(Object o);
void clear();
int size();
Iterator iterator();//遍历
Object get(int index);
ArrayList
1. ArrayList是List接口的实现类
import java.util.*;
List l = new ArrayList();
从0开始
2. Iterator遍历
Iterator i = List. iterator();
public boolean hasNext();
public Object next();//指针往下走一格
3. List排序
a)void Collections.sort(List);//默认升序
自动排序阿拉伯字母1-9,字母:a-z,A-Z,字符串比较首字母,相同比较第二个,以此类推。
b) 对Student类进行排序 //出现异常,不知道排序规则
c)Comparable接口
public int compareTo(){
当前对象排序的属性值 < 给定对象对应属性的值 return 负数
当前对象排序的属性值 == 给定对象对应属性的值 return 0
当前对象排序的属性值 > 给定对象对应属性的值 return 正数
负零正(升序) 正零负(降序)
}
eg:return this.age – age;
package chp11.ex06;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
/**
*
* @Author: Wentasy
* @FullName: TestList2.java
* @Description: 对象排序 实现Comparable接口 重写compareTo方法
* @Create Date: 2012-8-15
*/
class Student implements Comparable{
private String name;
private int age;
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
/*
public int compareTo(Object o) {
当前对象排序的属性值 < 给定对象对应属性的值 return 负数
当前对象排序的属性值 == 给定对象对应属性的值 return 0
当前对象排序的属性值 > 给定对象对应属性的值 return 正数
}
public int compareTo(Object o){
Student s = (Student)o;
return this.compareTo(s.getName());
}
*/
public int compareTo(Object o){
Student s = (Student)o;
if(this.age<s.age)return -1;
else if(this.age == s.age)return 0;
else return 1;
}
/*
public int compareTo(Object o) {
Student s = (Student)o;
return this.age-s.age;
}
*/
}
public class TestList2 {
public static void main(String args[]){
Student s1 = new Student("sun2",20);
Student s2 = new Student("sun1",10);
Student s3 = new Student("sun3",30);
List l = new ArrayList();
l.add(s1);
l.add(s2);
l.add(s3);
Collections.sort(l);
Iterator i = l.iterator();
while(i.hasNext()){
Student s = (Student)i.next();
System.out.println(s.getName());
}
}
}
d)String + 8种包装类默认已经实现了Comparable接口
e) List排序原理
Comparable接口达成了使用者和提供者之间的约定
4.List接口的实现类
a) ArrayList和LinkedList
b) ArrayList和Vector
Set接口
1.Set接口
boolean add(Object o);
boolean isEmpty();
boolean remove(Object o);
void clear();
int size();
Iterator iterator();//遍历
HashSet
1.HashSet:无顺序
2. HashSet:不可重复
元素对应的对象的内容不可重复
3. HashSet怎样存储对象
a) Object类中定义了public int hashCode();
b) HashSet怎样存储对象
i.调用hashCode
ii.当hashCode值满足条件时,再调用equals方法
c) hashCode:决定一个对象放在哪个桶(内存)里
d) 对象内容相同,hashCode值相同,放在同一桶里,把重复数据过滤掉(覆盖)
4.hashCode方法的覆盖建议
public int hashCode(){
returnage;
}
public int hashCode(){
return name.hashCode() & 1;//字符串已经覆盖了hashCode()
}
TreeSet
1. SortedSet接口的实现类
2. 可以排序,不可重复
3. 元素必须实现Comparable接口
4. 所有的Set接口的实现类对重复元素的处理不同
package chp11.ex11;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
*
* @Author: Wentasy
* @FullName: TestSet2.java
* @Description: TreeSet compareTo方法的重写优化
* @Create Date: 2012-8-15
*/
class Student implements Comparable{
private String name;
private int age;
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public int compareTo(Object o){
Student s = (Student)o;
if(this.age!=s.age)return this.age - s.age;
else return this.name.compareTo(s.name);
}
}
public class TestSet2 {
public static void main(String args[]){
Student s1 = new Student("sun2",20);
Student s2 = new Student("sun1",30);
Student s3 = new Student("sun3",30);
Student s4 = new Student("sun3",30);
Set set = new TreeSet();
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
Iterator i = set.iterator();
while(i.hasNext()){
Student s = (Student)i.next();
System.out.println(s.getName());
}
}
}
5.TreeSet过滤重复是以compareTo方法中判断两个内容是否相等作为判断重复数据的依据
Collection接口
Map接口
java.util.Map接口
key不可以重复,value可以重复
put(Object ket,Object value);
get(Obejct key);
remove(Objectkey);
clear();
isEmpty();
size();
HashMap
1. HashMap的常规使用
Map m = new HashMap();
2.HashMap的key也是通过Hash算法过滤重复数据
覆盖equals方法和hashCode
2. Map的key一般都应用String
3. Map的遍历
a) 值遍历
package chp11.ex13;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
/**
*
* @Author: Wentasy
* @FullName: TestMap1.java
* @Description: 值遍历
* @Create Date: 2012-8-15
*/
public class TestMap1 {
public static void main(String args[]){
Map m = new TreeMap();
m.put("key1", "value1");
m.put("key3","value2");
m.put("key1", "value4");
m.put("key2", "value2");
Collection c = m.values();
Iterator i = c.iterator();
while(i.hasNext()){
System.out.println(i.next());
}
}
}
b) 键遍历
package chp11.ex13;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
*
* @Author: Wentasy
* @FullName: TestMap2.java
* @Description: 键遍历
* @Create Date: 2012-8-15
*/
public class TestMap2 {
public static void main(String args[]){
Map m = new TreeMap();
m.put("key1", "value1");
m.put("key3","value2");
m.put("key1", "value4");
m.put("key2", "value2");
Set s = m.keySet();
Iterator ii = s.iterator();
while(ii.hasNext()){
System.out.println(ii.next());
}
}
}
c) 键值遍历
package chp11.ex14;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
* @Author: Wentasy
* @FullName: TestMap1.java
* @Description: 键值遍历
* @Create Date: 2012-8-15
*/
public class TestMap1 {
public static void main(String args[]){
Map m = new HashMap();
m.put("key1", "value1");
m.put("key2", "value2");
m.put("key3","value2");
m.put("key1", "value4");
//
// Set s = m.keySet();
// Iterator ii = s.iterator();
// while(ii.hasNext()){
// Object key = ii.next();
// System.out.println(key+" = "+m.get(key));
// }
// 错误的遍历方式 每调用一次next 指针往前移
Set s = m.keySet();
Iterator ii = s.iterator();
while(ii.hasNext()){
System.out.println(ii.next()+" = "+m.get(ii.next()));
}
}
}
TreeMap
1. TreeMap可以对key应用排序
2.TreeMap的key是通过Comparable接口过滤重复排序
3. Map的key一般都应用String
HashMap与HashTable
集合关系(5.0以前)
Collections工具类
Object max(Collection)
Object min(Collection)
shuffle(List) //打乱list顺序
List synchroniedList(List)//将ArrayList变成线程安全
package chp11.ex16;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
*
* @Author: Wentasy
* @FullName: TestCollections.java
* @Description: Collections工具类的使用
* @Create Date: 2012-8-15
*/
public class TestCollections {
/*
* 集合可以存简单类型 是jdk5新特性 集合部分没有讲解
*/
public static void main(String args[]){
List<String> src = new ArrayList<String>();
src.add("suns1");
src.add("suns2");
src.add("suns3");
List<String> dest = new ArrayList<String>();
Collections.copy(dest, src);
/*
List ll = new ArrayList();
ll.add(1);
ll.add(5);
Integer max = Collections.max(ll);
Integer min = Collections.min(ll);
System.out.println(max);
System.out.println(min);
List src = new ArrayList();
src.add("sun1");
src.add("sun2");
src.add("sun3");
src.add("sun4");
Collections.shuffle(src);
Iterator it = src.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
*/
LinkedList ll = null;
Hashtable s = new Hashtable();
HashMap hm = new HashMap();
System.out.println( s instanceof Map);
}
}
JDK5.0新特性
1.JDK5.0新特性:泛型
List<String>l = new ArrayList<String>();
2. for…each遍历
package chp11.ex18;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
*
* @Author: Wentasy
* @FullName: TestForEach.java
* @Description:for…each遍历的使用
* @Create Date: 2012-8-15
*/
public class TestForEach {
public static void main(String args[]){
List<String> l = new ArrayList<String>();//集合要使用,必加上泛型
l.add("suns");
l.add("suns2");
for(String name:l){
System.out.println("name "+name);
}
}
}
遍历集合、数组(集合要使用,必加上泛型)
3.Queue
a)JDK5.0新特性
b) Collection接口的子接口
c) 实现了FIFO算法(先入先出 队列)
d) LinkedList是其实现类
e) Queue常用API
i.offer(Object)//存对象
ii.Object poll()//获得最先进入的对象 获得后清除
iii.Object peek();//获得最先存入对象 获得后不清除
JDK5.0的集合关系