黑马程序员——Java集合类学习笔记

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

为什么会出现集合？

1、面向对象的语言，对事物的体现都是通过对象的形式，所以为方便对多个对象的操作，java就提供了集合类。

2、集合与数组的共同点，和区别：

共同点：它们都是用来存储数据的容器。

区别：数组的长度是固定的，其中只能存储基本数据类型。

集合的长度是可变的，其中只能存储对象，并且一个集合里可以存储不同类型的对象。

一、 Collection接口

Collection接口继承体系：

Collection

|

|------List

| |--ArrayList

| |--LinkedList

| |--Vector

|------Set

|--HashSet

| |--LinkedHashSet |

|--TreeSet

主要成员方法：

add()存对象。

size() 获取长度;

contains() 判断集合是不是包含对象;

iterator() 获取迭代器方法,返回的是接口实现类，就是集合内部类.

iterator()示例：

/*
* 迭代器集合获取方式
*   1. 调用集合方法iterator 获取迭代器Iterator的接口实现类对象
*   2. 调用Iterator接口的方法hasNext判断集合中有没有元素
*   3. 调用Iterator接口的方法next取出集合中的元素
*/
import java.util.*;
public class IteratorDemo {
public static void main(String[] args) {
Collection col = new ArrayList();
col.add("abc1");
col.add("abc2");
col.add("abc3");
//调用集合方法iterator 获取迭代器Iterator的接口实现类对象
Iterator it = col.iterator();
//for循环遍历
for( Iterator it = col.iterator() ; it.hasNext();){
System.out.println(it2.next());
}
}
}

两大子接口： List接口 Set接口

【List接口】

List接口的特点是：有序（获取顺序与存储方法一致）,有索引,可有重复对象元素

常用方法(特点: 可以操作索引):

添加

void add(index, element)

void add(index, collection)

删除

Object remove(index)

获取

Object get(index) 可以不用迭代器获取元素, List特有

int IndexOf(Object)

int lastIndexOf(Object)

List subList(from, to)

List接口实现类有：ArrayList, LinkedList, Vecter

1、ArrayList实现类概述：

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

线程不安全，效率高。数组初始化容量10个位置，扩容原来大小的50%。

示例： 定义一个方法实现去掉集合中重复的元素；

接收一个List集合，返回一个List集合。

public static List method(List oldList){
//定义新的空集合
List newList=new ArrayList();
//迭代器遍历老集合
Iterator it=oldList.iterator();
while(it.hasNext()){
//定义变量保存老集合中的元素
Object o=it.next();
//利用contains方法的返回值为波尔型,来判断新集合中是否存在老集合中的元素。
//新集合中不存在时，就将该元素存到新集合中
//newList.contains(o):当新集合中存在o元素时,则返回值为true
//不存在时，返回false
if(!(newList.contains(o))){
//存储到新集合中
newList.add(o);
}
return newList;
}
}

2、LinkedList实现类概述：

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

线程不安全，效率高。

LinkedList实现类特有方法：

添加元素：

addFirst(Object o):实现在链表的开头插入对象。无返回值

addLast(Object o):实现在链表的结尾插入对象。无返回值

offerFirst(Object o):实现在链表的开头插入对象。返回值为波尔类型

offerLast(Object o):实现在链表的结尾插入对象。返回值为波尔类型

获取元素但不移除

getFirst() 链表为空抛NoSuchElementException

getLast() 链表为空抛NoSuchElementException

peekFirst() 链表为空返回null

peekLast() 链表为空返回null

获取并移除：

removeFirst（）：获取并删除开头的对象。返回值为Object类型。

removeLast（）：获取并删除结尾的对象。返回值为Object类型。

pollFirst():获取并删除列表中开头的对象。如果列表没有元素返回值为null。

pollLast():获取并删除列表中结尾的对象。如果列表没有元素返回值为null。

示例：

package collection;
/**
* 模拟数据结构 栈
*实现元素先进去的后出来。
*/
import java.util.*;

class Data {
public static void method(LinkedList<String> li) {
while (li.size() > 0) {
System.out.println(li.pollLast());
}
}
}
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> li = new LinkedList<String>();
li.add("a");
li.add("b");
li.add("c");
new Data().method(li);
}
}

3、Vecter实现类概述：

底层是数组结构，可变长度，默认容量是10个，扩容原来大小的100%。

查询快，增删慢。线程安全，运行速度慢。

被ArrayList取代。

【Set接口】

Set接口的特点是：无序（获取顺序与存储方法不一致）,无索引,不可有重复对象元素

ps:Set 接口中的方法与Collection中的方法一致。

实现类有：HashSet, TreeSet. LinkedHashSet 是HashSet的子类.

1、HashSet实现类概述：

底层数据结构是哈希表（元素时链表的数组）,不允许重复元素,无序集合

线程不安全，运行速度快

哈希表依赖于哈希值存储

添加功能底层依赖两个方法： int hashCod(); boolean equals(Object o);

ps：

判断元素是不是重复的依据：依据对象自身的hashCode方法和equals方法。

因此，在存储自定义类型对象时，要重写这两个方法。

示例：存储Studen类,重写hashCode方法和equals方法

//重写equals方法
public boolean equals(Object obj){
//对obj参数非空判断
if( obj == null)
return false;
//强制类型转换问题
//判断传递的参数obj是不是Student类型
if( obj instanceof Student){
Student s = (Student)obj;
//就是this和s比较
return this.name.equals(s.name) && this.age == s.age ;
}
return false;
}
//重写hashCode方法，目的是为了降低，
//（对象成员变量不同时，而出现一样的哈希值）的概率。
public int hashCode(){
return name.hashCode()+age*2;
}

2 、TreeSet实现类概述：

无序（获取顺序与存储方法不一致）,不重复,无索引

线程不安全，运行速度快

TreeSet集合，会对储存到集合中的元素进行排序（根据对象元素的自然顺序）

底层数据结构为红黑树。

ps:

对于没有自然顺序的自定义类型的对象,想要存储到TreeSet集合中,

就需要使该类型对象具备自然顺序.

第一种方法：因此需要实现java.lang.Comparable接口，重写抽象方法compareTo

示例：存储Studen类对象,Studen类实现Comparable接口,并重写抽象方法compareTo方法

//Studen类实现Comparable接口
class Student implements Comparable{
//重写重写抽象方法compareTo
public int compareTo(Student s){
int num=this.name.compareTo(s.name);
return num==0? this.age-s.age:num;
}
}

第二种方法：用比较器类对象作为参数创建TreeSet对象

示例：

public class ComparatorDemo {
/**
* 需求：实现Integer类型对象，在TreeSet集合中的逆自然排序。
* 思路：使用自定义的比较器IntegerCom类，实现Comparetor接口，重写compare（）方法。
* 将比较器的对象作为参数，传递到TreeSet类构造方法中。
*/

public static void main(String[] args) {
// 比较器(实现类)的对象作为构造器的参数
TreeSet<Integer> tr = new TreeSet<Integer>(new IntegerCom());
tr.add(11);
tr.add(14);
tr.add(13);
// 打印出的不再是自然顺s序。而是逆自然顺序
System.out.println(tr);
}
}

//定义比较器 InegerCom类，实现Comparetor接口，重写compare（）方法
class IntegerCom implements Comparator<Integer>{
//重写compare（）方法。
public int compare(Integer i1,Integer i2){
return i2-i1;
}
}

3、LinkedHashSet实现类概述：

基于链表的哈希表实现，父类是HashSet

线程不安全，运行速度快

有序的，保证存储和取出的顺序一致。

示例：

public class LinkedHashSetDemo{
public static void main（String[]args）{
LinkedHashSet lhs=new  LinkedHashSet();
lhs.add("abc");
lhs.add("fbc");
lhs.add("dbc");
Iterator it=lhs.iterator();
while(it.hasNext()){
//输出结果为 abc  fbc  dbc
//按照存储顺序进行了输出
System.out.println(it.next());
}
}
}

二、Map接口

Map和Collection区别:

Map一次添加一对元素(键值对), Collection一次添加一个元素

Map成为双列集合, Collection成为单列集合

Map必须保证键的唯一性

继承体系：

Map

|--TreeMap

|--Hashtable(被HashMap替代)

||--Properties

|--HashMap

|--LinkedHashMap

常用方法:

添加

value put(key, value) 返回之前与key对应的value, 没有则返回null

删除

value remove(key) 删除键值对, 改变长度

判断

boolean containsKey(key)

boolean containsValue(value)

boolean isEmpty()

遍历获取

两种方法：

第一种：keySet()遍历遍历Map集合中的键,然后再获取对应的值.

第二种：利用map集合的方法 entrySet(),获得map集合中元素的 键值对应关系对象 Map.Entry.

示例：遍历Map集合

package collection;
import java.util.*;
public class MapDemo {
public static void main(String[] args) {
method();
}
/**
* 第一种方法
*/
public static void  method_1() {
HashMap<String,Integer> map=new HashMap<String,Integer>();
map.put("zhangsan", 100);
map.put("lisi", 90);
map.put("wangwu", 80);
//将Map集合中的 键值  取出放进Set集合中
Set<String> set = map.keySet();
//利用了Set集合中的迭代器，迭代出key 键值
Iterator<String> it=set.iterator();
while(it.hasNext()){
String key=it.next();
//调用map的get（）方法  获取key 所对应的值。
Integer value=map.get(key);
System.out.println(key+"="+value);
}
}
/**
* 第二种 遍历 map集合的方法：
* 利用map集合的方法 entrySet(),获得map集合中元素的  键值对应关系对象 Map.Entry.
* 然后将该对象 Map.Entry 存进 Set集合中。 遍历set集合，取出 Map.Entry对象。
* 再逐个调用 Map.Entry对象的方法getKey(),getValue()得到键  以及对应的值。
* */
public static void  method_2(){
//创建map集合。 并存入键值对
HashMap<String,Integer> map=new HashMap<String,Integer>();
map.put("zhangsan", 100);
map.put("lisi", 90);
map.put("wangwu", 80);
//增强for
for(Map.Entry<String,Integer> entry:map.entrySet()){
System.out.println(entry.getKey()+"="+entry.getValue());
}
}
}