Oracle培训（十一）——Core Java第十一章知识点总结——集合

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的集合关系