黑马程序员—java基础之集合

黑马程序员—java基础之集合

------- android培训、java培训、期待与您交流！
----------

感恩，感恩，感恩！懂得感恩的人，才会是有福报的人！感谢所有发生的一切！

什么是集合:集合是一个容器. 还记得数组也是一个容器,那么他们之间有什么不同呢.

集合与数组比较

数组有什么特点?

1.有顺序

2.定长

3.类型单一

集合特点:

1.有顺序也可以没顺序

2.集合长度可以随着元素的增加而增加

3.集合中可以装入任何Object

Java中的集合类都在java.util包下

Java中的集合元素全是Object类型的。

Collection集合

Collection(特点:有顺序也无顺序，可重复也不可重复)

它是一个接口,下面是它的子接口.

|---List:有顺序的可重复

｜----ArrayList

|----LinkedList

|----Vector

|---Set :无顺序不可重复

|-----HashSet

|-----TreeSet

重复的概念是两个元素做equals相等

Collection接口中声明的方法

1.add 向集合中添加元素

声明:public boolean add(Object obj)

作用:向集合添加元素obj

参数:要添加的元素

返回值:代表是否添加成功.

2.clear清空集合中的元素

声明:public void clear();

作用:清空集合中所有元素

3.contains判断集合中是否包含指定元素

声明:public boolean contains(Object obj)

作用:判断集合中是否包含指定元素，如果包含返回true，不包含返回false;

注意：所谓的包含是指obj与集合中的元素做equals返回true.

4.size

声明:public int size();

作用:返回集合中元素的个数

5.isEmpty

声明:public boolean isEmpty();

作用:判断集合中是否包含元素，如果没有任何元素返回true,有元素返回false

6.remove

声明:public boolean remove(Object obj)

作用:删除集合中的指定元素obj，如果删除成功返回true,否则返回false

注意:一次只能删除一个.

Collection中的所有带All方法

1.addAll

声明:public boolena addAll(Collection c);

作用:求两个集合的并集

简单说就是将两个集合中内容合并

2.containsAll

声明:public boolean containsAll(Collection c)

作用:判断集合c是否是集合的子集

3.removeAll

声明:public boolean removeAll(Collection c);

作用:将集合中包含的c集合中的所有元素删除。如果一个都不包含，返回false;

4.retainAll

声明:public boolean retainAll(Collection c);

作用:得到两个集合的交集.

Collection中的迭代器(****)

想要将集合中的所有元素取出来，需要使用迭代器.

声明:public Iterator iterator();

Iterator它是对Collection进行迭代的迭代器(简单说就是用来遍历 Collection集合的)

Iterator接口中的方法

1.hasNext

声明:public boolean hasNext();

作用:判断集合中是否有元素可以进行迭代

2.next

声明:public Object next();

作用:将下一个迭代出来。

3.remove

声明

publicvoid remvoe();

作用: 删除元素

使用迭代器遍历集合元素步骤

1.创建迭代器

Iteratorit=集合对象.iterator();

2.通过迭代器判断是否有元素可以进行迭代

while(it.hasNext()){它返回的是boolean 值

}

3.通过迭代器将元素迭代出来

Objectobj=it.next();

集合中的元素在迭代出来后，都是Obejct

关于迭代器的问题

iterator这个方法是声明在Collection接口中.

Iteratorit=集合对象.iterator();

在迭代的过程中不能对集合中元素进行修改,如果修改产生java.util.ConcurrentModificationException

关于迭代器中的remove方法与Collection中的方法区别

在对集合使用迭代器操作的过程中，不允许使用集合提供的可以修改集合中元素的方法。

例如：将集合中的元素删除，如果想要删除，必须使用迭代器提供的行为.

迭代器的实现伪代码

interfaceIterator{

}

interfaceCollection{

Iteratoriterator();

}

classArrayList implements Collection{

publicIterator iterator(){

returnnew Iter();

}

class Iter implements Iterator{

}

}

classLinkedList implements Collection{

publicIterator iterator(){

returnnew LinkedIter();

}

classLinkedIter implements Iterator

{

}

}

Collection c=new ArrayList();

Iteratorit=c.iterator();

List集合

List集合的特点:有顺序可重复

List是继承自Collection，Collection中的方法在List中都是存在。

List集合是有索引的，我们可以通过索引对其元素进行精确控制.

List集合中的特性方法:

1.add方法

声明:public void add(int index,Object obj);

作用:在指定index索引位置添加元素

2.get方法(***)

声明:public Object get(int index);

作用:根据索引index得到对应位置上的元素

3.remove方法

声明:public Object remove(int index);

作用:将指定index索引位置上的元素删除，返回值就是删除的元素.

4.set方法

声明:public Object set(int index,Object obj)

作用:使用obj将index位置上的元素替换，返回值是被替换的元素.

List集合的遍历方式

1.通用方式 Iterator（适用于所有的Collection集合）

通过从Collection继承的iterator方法

2.使用get（只适用于List集合）

因为List集合是有顺序的，我们可以通过索引对其位置上进行控制

3.使用List集合的特有的迭代器械 ListIterator(只适用于List集合)

ListIterator是继承自Iterator，也就是在Iterator中声明的hasNext,next,remove方法它也有。

但是它还提供了特有的方法

add

set

ListIterator比Iterator功能增强

1.Iterator只能从上到下遍历，而ListIterator可以双向遍历

2.Iterator在迭代过程中不能修改,而ListIterator可以add ,set

ArrayList

它实现了List集合,所以在List集合中的方法它都可以用

我们主要研究，ArrayList的实现方式

ArrayList它的实现是使用可变数组

ArrayList类的特点:

1.它的底层实现是使用数组实现。

2.每一次数组会扩充50%

3.它是线程不安全。在单线程中使用。

//扩充方式伪代码:

classMyList{

privateObject[] obj;

privateint size=0;

publicMyList(){

this(10);

}

publicMyList(int len){

obj=newObject[len];

}

publicvoid add(Object o){

obj[size]=o;

//为了实现可以一直向MyList中不断的添加元素.

change();

size++;

}

privatevoid change(){

Object[]old=obj;

obj=newObject[old.length*3/2]; //在原来数组基础上扩大50%

/*

for(inti=0;i<old.length;i++){

obj[i]=old[i];

}*/

}

publicString toString(){

StringBuilderbuilder=new StringBuilder();

builder.append("[");

for(inti=0;i<size;i++){

builder.append(obj[i]).append(",");

}

builder.deleteCharAt(builder.length()-1);

builder.append("]");

returnbuilder.toString();

}

}

LinkedList

LinkedList的底层实现:双向链表

LinkedList特殊的方法:它可以很方便的操作集合的头尾元素.

它对外提供了 get/remove/add

关于ArrayList与LinkedList集合区别?

ArrayList底层是使用数组实现，在内存中是连续的空间，那么他在做查找时会方法，

但是在做删除/修改时效率比较低.

LinkedList它的底层实现是链表实现，它在做查找时效率比较低。转为每一个元素

头存储的是上一个元素的地址，尾存储的是下一个元素的地址。

但是，它在做删除与修改时效率高。

LinkedList集合的特性方法

1.addFirst/addLast

声明:public void addFirst(Object obj);

作用:将obj元素添加到集合的首位置

声明:public void addLast(Object obj)

作用:将obj元素添加到集合的尾位置

//在jdk1.6后提供两个替代的方法

offerFirst

offerLast

它与我们addFirst与addLast区别在于它有返回值.

2.getFirst/getLast

声明:public Object getFirst();

作用:得到集合中的首元素

声明:public Object getLast();

作用:得到集合的尾元素

在jdk1.6后提供替代方法

peekFirst

peekLast

它们与getFirst/getLast区别,它们在集合为空时，返回的是null,而不会产生异常.

3.removeFirst/removeLast

声明:public Object removeFirst();

作用:删除集合中的首元素，返回的就是删除的这个元素

声明:public Object removeLast()

作用:删除集合中的最后一个元素，返回的是删除的这个元素.

jdk1.6后替换的方法

pollFirst

pollLast

它们区别在于pllFirst/pollLast列表为空时不会产生异常，而是返回null;

注意:对于getFirst/getLastremoveFirst/removeLast时，如果集合为空

会产生异常.

Vector

Vector是早期应用集合时所使用的一个类.

ArrayList是Vector的替代类.

ArrayList是数组实现，它是每次增加50%,线程不安全.

Vector是数组实现 它每次拉回100%,线程安全的。

关于使用Enumeration遍历Vector

//1.得到Enumeration对象

Enumeration enu=v.elements();

//2.判断是否有元素可以进行迭代

while(enu.hasMoreElements()){

//3.得到元素

Object obj=enu.nextElement();

System.out.println(obj);

}

List集合的总结

List有顺序可重复.

|----ArrayList

它的底层实现是使用数组，每次增长50%,在做查询操作时效率高。是线程不安全。

|----LinkedList

它的底层实现是使用链表，它在做修改与删除时效率高。线程不安全。

Linkedlist对于首尾元素操作比较方便.

|----Vector

它的底层实现是数组，每次增长100%,效率低下，线程安全。

对于List集合的遍历方式

1.Iterator

2.get+索引

3.listIterator

Set

Set集合:无顺序不可重复

|----HashSet

它是由hash表支持的。这使用hashCdoe与equals来维护元素的唯一

|----TreeSet

对于Set集合，如果想要遍历出所有元素，只能使用迭代器.

元素不重复，是指元素做equals为true,代表重复.

HashSet怎样保证元素唯一

1.两个元素的hashCode不一样，不会判断equals，直接就能装入.

2.两个元素的hashCode一样，equals为false,能装入

3.两个元素的hashCdoe一样，equals为true,不能装入.

做equals相等的对象的hashCode值应该一样.

我们重写hashCode方法时怎样重写

就是将所有的做equals比较进应用的属性的hashCode值进行相加就可以，

为了减少重复的概率，我们可以定义一个质数，用这个质数与

所有的属性相乘，这样使用的hashCode值重复概率减少.

TreeSet集合的特点:有顺序不可重复

TreeSet集合怎样保证集合中的的元素是有顺序的，怎样保证元素的唯一性

TreeSet集合中的元素必须有自然顺序或给集合指定了比较器。

1.使用自然顺序

就是实现 Comparable接口，重写compareTo方法

怎样排序:根据compareTo方法的返回值是正数还是负数，知道大于还是小于.

怎样唯一:根据compareTo方法的返回值为0，知道重复.

2.使用比较器

就是实现 Comparator接口 重写compare方法。

怎样排序:根据compare方法的返回值是正数还是负数，知道大于还是小于.

怎样唯一:根据compare方法的返回值为0，知道重复.

注意:使用比较器要在创建集合时，就将其做为参数传递给集合。

什么时候使用比较器？

我们在开发中，发现集合中的元素已经存在了自然顺序，但是我们

想要进行排序的条件不是按照元素的自然顺序排序。这时就可以

自己去做比较器。

Set

|----HashSet 底层使用的hash表无顺序不重复，线程不安全的。 这是使用hashCode和equals方法保证元素唯一

|------LinkedHashSet

元素装入顺序与取出顺序一致.线程不安全

|----TreeSet

底层使用二叉树有顺序，不可重复 线程不安全的.TreeSet在使用时效率比较低。

它保证元素唯一有两种方式

1.自然顺序 Comparable----compareTo(Object obj)

2.比较器 Comparator----compare(Object o1,Object o1)

怎样选择List与Set集合

通常使用List，首先ArrayList ,如果是操作头尾元素还有频繁进行删除修改操作这时选择LinkedList

如果要求元素是不重复的。

这时就选择Set ,首先HashSet

如果要求对元素进行排序 TreeSet.

jdk1.5,jdk1.6中TreeSet集合在使用时，如果是装入的第一个元素，

这个时候它不会进行比较。也就是compareTo方法不会被执行.

jdk1.7后集合中元素必须有自然顺序，也就是说当装入元素时，

无论是否是第一个都会执行compareTo方法。

泛型

泛型:其实就是用来限定类型.

泛型的优点:

1.提高了我们程序的使用性.不需要在自己去做强转.

2.将原来在运行阶段处理的问题，放到了编译阶段.

3.提高安全性.

在我们学习过程中，使用泛型最多的就是在集合中。

泛型可以声明在类上，可以声明在方法上，可以声明在接口上。

声明在类上的泛型，在整个类的范围内都可以使用。

声明在方法上的泛型，只能在方法上使用。什么时候在方法上声明泛型？

类上已经声明了泛型，但是在方法上我们不使用类上的泛型，而是自定义的

一个，那么就可以在方法上声明，注意：在方法上声明时，泛型要定义在方法的返回值前面。

通配符: ? 泛型中使用通配符的限定

<?extends E> 它是用来限定是E类型或是E的子类型.

<?super E> 只能是E类型或E的父类型.

1.关于迭代器中使用泛型

集合上定义了泛型，我们在使用迭代器进行迭代操作时，必须给迭代器

也指定泛型，这样，在迭代出来时就不需要进行强制转换。

2.关于泛型的擦除.

泛型只对编译阶段有效，而在运行阶段就失效。

/*

//以下两种操作，不建议使用，什么情况下能使用，就是为了兼容以前定义的集合.

Listlist1=new ArrayList<String>();

list1.add("abc");

list1.add(123);

List<String>list2=new ArrayList();

list2.add("abc");

list2.add(123);

*/

ArrayList<String>list=new ArrayList<>(); //在jdk1.7后可以，简化操作，<>代表<String>

Map集合

Map集合是一种双列集合，它是采用key-value映射方式存储的。

它的key值不能重复。

Map接口下提供方法

1.怎样将元素添加到Map集合中.(*****)

声明: public Object put(Object key,Object value)

作用：向Map集合中添加key与value,

注意:如果key值重复，它会将原本的映射关系破坏，

用新的元素将旧的元素替换，而返回值就是旧的元素.

2.clear

声明:public void clear();

作用:清空集合

3.size

声明:public int size();

作用:得到集合的长度()

4.containsKey containsValue

声明: public boolean containsKey(Object key)

public boolean containsValue(Objectvalue)

作用:判断Map集合中是否包含指定的key或value

5.根据key取得value get

声明:public Object get(Object key)

作用:根据指定的key值，得到对应的value。

注意:如果没有映射关系，返回的是null.

6.remove

声明 public Object remove(Object key)

作用:根据key删除映射关系.

返回值返回的是这个key对应的value值

7.values

声明:publicCollection values();

作用:得到Map集合中的所有的value的值的一个Collection集合。

Map集合的遍历操作

1.使用keySet

1.通过Map的keySet方法得到的是key的Set视图.

2.通过Iterator对Set集合进行迭代，将Map中的所有的key得到了

3.通过Map的get方法，根据key得到对应的value.

2.使用entrySet

1.通过Map的entrySet方法得到的是key-value(其实就是Entry类型)映射的Set视图

2.通过Iterator得到Set集合中的所有的Entry对象.

3.通过Entry对象的getKey getValue方法得到Map集合中的所有的key与value.

Map集合与Collection集合的区别

1.Map是双列集合 Collection是单列集合

2.Map集合存储是使用put方法

Collection存储使用的是add方法.

3.Map集合不能直接使用迭代器遍历.

使用keySet或entrySet方法，得到一个Set集合，在使用迭代器将Map集合中的元素迭代出来。 Collection取值使用迭代器 Iterator

HashMap

HashMap

HashMap允许null值与null键，线程不安全。

它的底层实现是基于hash表的。

HashMap怎样保证其key值不重复？

使用元素的hashCode方法与equals方法保证.

Hashtable

Hashtable不允许null值null键,它是线程安全。

TreeMap

它的底层实现使用的二叉树。它也是线程不安全的。

它怎样保证key的唯一性?

1.自然顺序

2.比较器

与我们之前讲过的TreeSet一样的原理.

Map集合总结

Map 双列集合

|-----HashMap 底层使用hash表实现，它允许null值,null键,线程不安全。

HashMap使用元素的hashCode与equals方法来保证key的唯一。

|------LinkedHashMap

它保证了装入时的key的顺序与取出时key的顺序一样。

|-----Hashtable 它与HashMap的区别，除了不能null值，null键,线程安全。其它一样。

|------Properties

它是对配置文件进行映射的。

在早期开发中，经常的使用这样原的文件进行配置。

|-----TreeMap 底层实现二叉树，它线程不安全。

它使用 自然顺序与比较器保证 key的唯一.

怎样选择使用什么集合

1.判断是存储单列还是双列，这样就可以选择Collection还是Map

2.

2.1Collection

如果没有要求，先List，List下首选ArrayList

如果要求不重复 Set,Set下首先HashSet.

对于LinkedList,TreeSet,它们的使用要根据上体的特性。

2.2Map

首选HashMap,如果要求进行排序，TreeMap.

今日小练习:

将前面日志中的扑克牌程序用集合重写,并提供洗牌的功能.

Package com.itheima.test

import java.util.*;
class
Test2{
public
static void main(String[] args){
List<Poker> ps=new
ArrayList<Poker>();
PokerTools.createPoker(ps);
PokerTools.shuffle(ps);
PokerTools.show(ps);
}
}
//关于扑克的一些操作
class
PokerTools{
//生成扑克方法
public
static void createPoker(List<Poker> ps){
for(int i=0;i<GlobalPoker.cs.length;i++){
for(int j=0;j<GlobalPoker.ns.length;j++){
ps.add(new
Poker(GlobalPoker.cs[i],GlobalPoker.ns[j]));
}
}
}

//洗牌的方法
public
static void shuffle(List<Poker> ps){
Random ran=new
Random();
for(inti=0;i<ps.size();i++){
intn=ran.nextInt(ps.size());
Poker p1=ps.get(i);
Poker p2=ps.get(n);
ps.set(i,p2);
ps.set(n,p1);
}
}
//显示扑克牌的方法
public
static void show(List<Poker> ps){
for(inti=0;i<ps.size();i++){
if(i%GlobalPoker.ns.length==0){
System.out.println();
}
System.out.print(ps.get(i)+" ");
}
}
}
//这个类中定义的是一个常量
class
GlobalPoker{
public
static final
String[] cs={String.valueOf((char)3),String.valueOf((char)4),String.valueOf((char)5),String.valueOf((char)6)};
public
static final
String[] ns={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
}
class
Poker{
String
color;
String
number;
public Poker(){}
public Poker(String color,String number){
this.color=color;
this.number=number;
}
// 重写toString方法
public
String toString(){
return
color+number;
}
}

------- android培训、java培训、期待与您交流！
----------