程序员学习 集合

collection

Collection 接口用于表示任何对象或元素组。想要尽可能以常规方式处理一组元素时，就使用这一接口。Collection 在前面的大图也可以看出，它是List和Set 的父类。并且它本身也是一个接口。它定义了作为集合所应该拥有的一些方法。如下：

注意:

集合必须只有对象，集合中的元素不能是基本数据类型。

Collection接口支持如添加和除去等基本操作。设法除去一个元素时，如果 这个元素存在，除去的仅仅是集合中此元素的一个实例。

boolean add(Object element) 

boolean remove(Object element) 

  Collection 接口还支持查询操作：

u     int size() 

u     boolean isEmpty() 

u     boolean contains(Object element) 

u     Iterator iterator() 

组操作 ：Collection 接口支持的其它操作，要么是作用于元素组的任务，要么是同时作用于整个集合的任务。

 boolean containsAll(Collection collection) 

 boolean addAll(Collection collection) 

  void clear() 

   void removeAll(Collection collection) 

    void retainAll(Collection collection) 

containsAll() 方法允许您查找当前集合是否包含了另一个集合的所有元素，即另一个集合是否是当前集合的子集。其余方法是可选的，因为特定的集合可能不支持集合更改。 addAll() 方法确保另一个集合中的所有元素都被添加到当前的集合中，通常称为并。 clear() 方法从当前集合中除去所有元素。 removeAll() 方法类似于 clear() ，但只除去了元素的一个子集。 retainAll() 方法类似于 removeAll() 方法，不过可能感到它所做的与前面正好相反：它从当前集合中除去不属于另一个集合的元素，即交。

这里需要注意的是，Collection 它仅仅只是一个接口，而我们真正使用的时候，确是创建该接口的一个实现类。做为集合的接口，它定义了所有属于集合的类所都应该具有的一些方法。

而ArrayList （列表）类是集合类的一种实现方式。

 

这里需要一提的是，因为Collection的实现基础是数组，所以有转换为Object数组的方法： 

   Object[] toArray() 

  Object[] toArray(Object[] a)

其中第二个方法Object[] toArray(Object[] a) 的参数 a 应该是集合中所有存放的对象的类的父类。

迭代器（Iterator） 

　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。 

　　Java中的Iterator功能比较简单，并且只能单向移动： 

　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。 

　　(2) 使用next()获得序列中的下一个元素。 

　　(3) 使用hasNext()检查序列中是否还有元素。 

　　(4) 使用remove()将迭代器新返回的元素删除。 

　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

迭代器应用

import java.util.List;

import java.util.ArrayList;

import java.util.Iterator;

public class Test1 {

public static void main(String args[]){

 

List<String> list=new ArrayList<String>();

list.add("aa");

list.add("bb");

list.add("cc");

Iterator<String> it=list.iterator();

while(it.hasNext()){

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

}

}

}

List接口概述

 List:

  |--ArrayList

底层数据结构是数组,查询快,增删慢。

线程不安全,效率高。

    |--Vector

底层数据结构是数组,查询快,增删慢。

  线程安全,效率低。

|--LinkedList

底层数据结构是链表,查询慢,增删快。

线程不安全,效率高。

  我们到底该用谁?

线程安全：

是：Vector

否：ArrayList,LinkedList

查询多：ArrayList

增删多:LinkedList

当你什么都不知道，用ArrayList。

    public class ArrayListDemo {

public static void main(String[] args) {

// Collection c = new ArrayList();

// List list = new ArrayList();

ArrayList array = new ArrayList();

 

array.add("hello");

array.add("java");

array.add("world");

 

// 遍历

Iterator it = array.iterator();

while (it.hasNext()) {

String s = (String) it.next();

System.out.println(s);

}

for(int x=0; x<array.size(); x++){

String s = (String)array.get(x);

System.out.println(s);

}

与 set 不同，列表通常允许重复的元素。

List接口成员方法

void add(int index,E element)

E remove(int index)

E get(int index)

E set(int index,E element)

ListIterator listIterator()

 

ListIterator接口的成员方法

boolean hasPrevious()

E previous()

 

Vector类概述及使用

Vector类概述

底层数据结构是数组，查询快，增删慢

线程安全，效率低

Vector类特有功能

public void addElement(E obj)

public E elementAt(int index)

public Enumeration elements()

Vector案例

存储字符串并遍历

存储自定义对象并遍历

增强for概述及使用

增强for概述

简化数组和Collection集合的遍历

格式：

for(元素数据类型 变量 : 数组或者Collection集合) {

使用变量即可，该变量就是元素

    }

好处：简化遍历

注意事项：增强for的目标要判断是否为null

把前面的集合代码的遍历用增强for改进

 Set接口概述

一个不包含重复元素的 collection。

Set案例

存储字符串并遍历

存储自定义对象并遍历

HashSet类概述

不保证 set 的迭代顺序

特别是它不保证该顺序恒久不变。

HashSet如何保证元素唯一性

底层数据结构是哈希表(元素是链表的数组)

哈希表依赖于哈希值存储

添加功能底层依赖两个方法：

int hashCode()

boolean equals(Object obj)

LinkedHashSet类概述

LinkedHashSet类概述

元素有序唯一

由链表保证元素有序

由哈希表保证元素唯一

TreeSet类概述

使用元素的自然顺序对元素进行排序

或者根据创建 set 时提供的 Comparator 进行排序

具体取决于使用的构造方法。 

TreeSet是如何保证元素的排序和唯一性的

底层数据结构是红黑树(红黑树是一种自平衡的二叉树)

HashSet集合存储自定义对象并遍历。

如果对象的成员变量值相同即为同一个对象

TreeSet集合存储自定义对象并遍历

如果对象的成员变量值相同即为同一个对象

按照年龄进行从大到小进行排序

编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台

 

TreeSet自然顺序排序举例： 声明类Student，包含3个成员变量：name、age、score，创建5个对象装入TreeSet，按照成绩排序输出结果（考虑成绩相同的问题）。 

public class student implements Comparable<student>{

public String name;

public int age;

public int score;

public student(String name,int age,int score){

this.name=name;

this.age=age;

this.score=score;

}

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 void setScore(int score){

this.score=score;

}

public int getScore(){

return this.score;

}

public int compareTo(student s){

int num=s.score-this.score;

int num2=num==0?this.name.compareTo(s.name):num;

return num2;

}

public String toString() {

return (this.name+" "+this.age+" "+this.score);

}

}

import java.util.TreeSet;

class ScoreSort {

public static void main(String[] args) {

TreeSet<student>set=new TreeSet<student>();

student s1=new student("刘潘敏",22,89);

student s2=new student("张三",22,89);

student s3=new student("李四",23,90);

student s4=new student("王五",24,87);

student s5=new student("李明",20,99);

set.add(s1);

set.add(s2);

set.add(s3);

set.add(s4);

set.add(s5);

for(student s:set) {

System.out.println(s.toString());

 

}

}

}

根据创建 set 时提供的 Comparator 进行排序

import java.util.Comparator;

import java.util.TreeSet;

class student {

public String name;

public int age;

public int score;

public student(String name,int age,int score){

this.name=name;

this.age=age;

this.score=score;

}

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 void setScore(int score){

this.score=score;

}

public int getScore(){

return this.score;

}

public String toString() {

return (this.name+" "+this.age+" "+this.score);

}

 

}

public class Test10 {

public static void main(String[] args) {

// 匿名内部类实现

TreeSet<student> set= new TreeSet<student>(new Comparator<student>() {

public int compare(student s1,student s2){

int num=s2.getScore()-s1.getScore();

int num2=num==0?s1.getName().compareTo(s2.getName()):num;

return num2;

}

});   //创建5个student对象

student s1=new student("刘潘敏",22,89);

student s2=new student("张三",22,89);

student s3=new student("李四",23,90);

student s4=new student("王五",24,87);

student s5=new student("李明",20,99);

//添加元素

set.add(s1);

set.add(s2);

set.add(s3);

set.add(s4);

set.add(s5);

//遍历

for(student s:set) {

System.out.println(s.toString());

 

}

}

}

HashSet举例

import java.util.HashSet;

/*

 * 用HashSet存储自定义对象(Student name,age,address)

 * 我们认为属性相同即为同一个值。

 * 

 * 请存储5个学生，并保证元素的唯一性。

 */

public class HashSetTest {

public static void main(String[] args) {

// 创建集合对象

HashSet<Student> hs = new HashSet<Student>();

// 创建元素对象

Student s1 = new Student("刘德华", 50, "北京");

Student s2 = new Student("刘德华", 50, "北京");

Student s3 = new Student("张学友", 48, "上海");

Student s4 = new Student("郭富城", 49, "天津");

Student s5 = new Student("黎明", 52, "重庆");

       添加元素

hs.add(s1);

hs.add(s2);

hs.add(s3);

hs.add(s4);

hs.add(s5);

 

// 遍历

for (Student s : hs) {

System.out.println(s.getName() + "---" + s.getAddress() + "---"

+ s.getAge());

}

}

}

class Student {

private String name;

private int age;

private String address;

 

public Student() {

}

public Student(String name, int age, String address) {

this.name = name;

this.age = age;

this.address = address;

}

 

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 String getAddress() {

return address;

}

 

public void setAddress(String address) {

this.address = address;

}

@Override

public int hashCode() {

return this.name.hashCode() + this.age * 19 + this.address.hashCode();

}

@Override

public boolean equals(Object obj) {

if (this == obj) {

return true;

}

 

if (!(obj instanceof Student)) {

return false;

}

 

Student s = (Student) obj;

return this.name.equals(s.name) && this.age == s.age

&& this.address.equals(s.address);

}

}

Map接口概述

将键映射到值的对象

一个映射不能包含重复的键

每个键最多只能映射到一个值

Map接口和Collection接口的不同

Map是双列的,Collection是单列的

Map的键唯一,Collection的子体系Set是唯一的

Map集合的数据结构值针对键有效，跟值无关

Collection集合的数据结构是针对元素有效

Map接口成员方法

Map接口的功能：

A:添加功能

  V put(K key, V value) 

 

B:删除功能

  void clear() 

V remove(Object key) 

 

  C:获取功能

   Set<Map.Entry<K,V>> entrySet()

   V get(Object key) 

  Set<K> keySet() 

   Collection<V> values()

  

   d:判断功能

   boolean containsKey(Object key)

   boolean containsValue(Object value)

   boolean isEmpty() 

 

       E:长度

    int size() 

 

public class MapDemo {

public static void main(String[] args) {

// Map中的方法测试

Map<String, String> map = new HashMap<String, String>();

 

// 添加功能

map.put("it002", "西毒");

map.put("it004", "东邪");

map.put("it001", "南帝");

map.put("it003", "北丐");

//键不存在，就添加。存在，就值覆盖。

//map.put("it001", "中神通");

//删除功能

//map.clear();

//System.out.println("remove:"+map.remove("it001"));

//System.out.println("remove:"+map.remove("it007"));

//判断功能

//System.out.println("containsKey:"+map.containsKey("it001"));

//System.out.println("containsKey:"+map.containsKey("it007"));

//System.out.println("isEmpty:"+map.isEmpty());

//长度

System.out.println("size:"+map.size());

System.out.println("map:"+map);

}

}

Map接口成员方法

V get(Object key)

Set<K> keySet()

Collection<V> values()

Set<Map.Entry<K,V>> entrySet()

Map集合遍历

方式1：根据键找值

获取所有键的集合

遍历键的集合，获取到每一个键

根据键找值

import java.util.HashMap;

import java.util.Map;

import java.util.Iterator;

import java.util.Set;

class Test1 {

public static void main(String args[]){

     Map<String,String> map=new HashMap<String,String>();

 map.put("一号","刘潘敏");

 map.put("二号","张三");

 map.put("三号","李四");

 Set<String> set=map.keySet();

 for(String key: set){

    System.out.println(map.get(key));

 }}}

方式2：根据键值对对象找键和值

获取所有键值对对象的集合

遍历键值对对象的集合，获取到每一个键值对对象

根据键值对对象找键和值

import java.util.HashMap;

import java.util.Map;

import java.util.Iterator;

import java.util.Set;

class Test1 {

public static void main(String args[]){

     Map<String,String> map=new HashMap<String,String>();

 map.put("一号","刘潘敏");

 map.put("二号","张三");

 map.put("三号","李四");

Set<Map.Entry<String,String>> set=map.entrySet();

for(Map.Entry<String,String> me:set){

     String key=me.getKey();

 String value=me.getValue();

 System.out.println(key+"***"+value);

}

}

}

HashMap类概述

键是哈希表结构，可以保证键的唯一性

HashMap案例

HashMap<String,String>

HashMap<Integer,String>

HashMap<String,Student>

HashMap<Student,String>

TreeMap类概述

TreeMap类概述

键是红黑树结构，可以保证键的排序和唯一性

TreeMap案例

TreeMap<String,String>

TreeMap<Student,String>

 

练习： 

aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

package cn.kge.collection;

import java.util.Set;

import java.util.TreeMap;

public class MapDemo1 {

     public static void main(String[] args) {

      String str = "aababcabcdabcde";

TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();

char[] chs = str.toCharArray();

for(Character ch:chs){

Integer value = map.get(ch);

if(value==null){

map.put(ch, 1);

}else{

value++;

map.put(ch, value);

}

}

Set<Character> set = map.keySet();

StringBuilder sb =  new StringBuilder();

for(Character s:set){

Integer value = map.get(s);

sb.append(s).append("(").append(value).append(")");

}

System.out.println(sb.toString());

}

}

 

面试题

HashMap和Hashtable的区别?

A:HashMap是线程不安全的,允许null键和值。

B:Hashtable是线程安全的,不允许null键和值。