黑马程序员----集合框架（一）

最新推荐文章于 2021-03-31 16:59:52 发布

MyTiming

最新推荐文章于 2021-03-31 16:59:52 发布

阅读量280

点赞数

本文链接：https://blog.csdn.net/MyTiming/article/details/45821949

版权

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

一、集合概述

1、为什么出现集合？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2、几个特点

1）是可以存储很多元素的容器。

2）这个容器用于存储对象。（只能存对象，但可以存储不同类型的对象）

3）该容器的长度是可变的。

3、集合和数组的区别

1）数组是固定长度，集合长度可变。

2）数组可以存储基本数据类型，也可以存储引用类型。集合只能存储引用类型。

4、集合类型主要有三种：set、list和map

1）set接口继承Collection，但不允许重复，使用自己内部的一个排列机制，无序。

2）list接口继承Collection，允许重复，以元素安插的次序来放置元素。

3）map接口是一组成对的键-值对象，即所持有的是key-value pairs。map中不能有重复的key。拥有自己的内部排列机制。

4）容器中的元素类型都为Object。从容器中取得元素时，必须把它转成原来的类型。

二、Collection集合

1、Collection接口中的方法。

1）存储add 和addAll

//定义接口指向自己实现类对象，多态调用。

Collection co1 = new ArrayList();
Collection co2 = new ArrayList();

co1.add(123);

co1.add(456);

co2.add("abc");
co2.add("def");
System.out.println(co1);
System.out.println(co2);
//使用co1集合，调用方法addAll传递co2集合
co1.addAll(co2);
System.out.println(co1);
System.out.println(co2);

2)移除集合中存储的对象boolean remove（Object o）

Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
System.out.println(coll);
//移除集合中的对象abc3
boolean b = coll.remove("abc3");

3）清除集合中所以得元素：void clear（）

4）判断一个元素是不是包含在集合中：boolean contains（Object 0）

Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
System.out.println(coll);
//判断abc3是不是包含在集合中
boolean b = coll.contains("abc3");
System.out.println(b);

5）判断集合中有没有元素：boolean isEmpty（）

6）返回集合的长度：int size（）返回集合中存储元素的个数。

7）获取两个集合的交集：boolean retainAll（Collection c）

Collection co1 = new ArrayList();
Collection co2 = new ArrayList();

co1.add(456);
co1.add(123);

co2.add(456);
co2.add(123);
co2.add(12345);
System.out.println(co1);
System.out.println(co2);
//使用co1调用方法retainAll传递co2
//将两个集合中相同元素，保存到co1
boolean b = co1.retainAll(co2);
System.out.println(b);
System.out.println(co1);
System.out.println(co2);

2、迭代器

迭代器要使用，必须先有容器。
Iterator是容器中的一个内部类，因为该类要直接访问容器中的元素。同时对外提供了公共的访问规则Iteraror接口。
这样的好处是，不需要知道具体的容器，只要是Collection中的容器都可以通过该种取出方法取出体系中的所有容器中的元素。
使用迭代器的好处会是：降低了具体容器和取出方式的耦合性。
想要获取集合中的迭代器对象，就可以通过iterator方法来完成。

1、迭代器使用程序示例

Collection coll = new ArrayList();
//存储元素。
coll.add(“abc1”);
coll.add(“abc2”);
coll.add(“abc3”);
coll.add(“abc4”);
//取出元素。
//获取迭代器。
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());

二、List

List 接口有三个实现类对象 ArrayList、LinkedList、Vector

特点：是一个有序的集合，存储的顺序和取出顺序是一致的，有索引，可以像数组一样操作集合。，运行存储重复的元素。

List特有的方法：

1、add（int index，Object o）将元素存储到指定的下标上

List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);

//在第2索引，添加对象www
list.add(2, "www");
System.out.println(list);

2、Object set(int index,Object o) 修改指定索引上的元素，返回被修改之前的元素

List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//修改2下标上的元素，itcast
Object o = list.set(3, "itcast");
System.out.println(o);
System.out.println(list);

3、Object remove(int index) 移除指定索引上的元素，并且返回被删除的元素

List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//移除0下标上的元素
Object o = list.remove(0);
System.out.println(o);
System.out.println(list);

4、subList(int begin ,int end) 获取集合中的一部分，包含头不包含尾。返回新集合

List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
list.add("abc5");
list.add("abc6");
//获取集合中的0-3索引
list = list.subList(0, 3);
System.out.println(list);

5、List集合特有迭代器

ListIterator List集合的特有迭代器
ListIterator lit = list.listIterator()
ListIterator方法：
add()添加对象
remove()移除对象
set() 修改对象

1）ListIterator接口中的方法，add 迭代过程中添加元素到集合

List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
list.add("abc5");

//调用集合方法listIterator()获取迭代器对象
//返回值是ListItertor接口的实现类对象（内部类）
ListIterator lit = list.listIterator();
//迭代过程中，判断有没有abc3对象，如果有添加一个abc33
while(lit.hasNext()){
Object o = lit.next();
if("abc3".equals(o))
lit.add("abc33");
System.out.println(o);
}
System.out.println(list);

2）ListIterator接口中的方法set(Object o) 修改对象。迭代到的是谁，修改的就是谁

List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
list.add("abc5");
//获取迭代器对象，List特有迭代器
ListIterator lit = list.listIterator();
//迭代中，判断有没有abc2元素，如果有，修改成QQ.exe
while(lit.hasNext()){
Object o = lit.next();
if("abc2".equals(o))
lit.set("QQ.exe");
System.out.println(o);
}
System.out.println(list);

3）

三、Set

Set 接口派系特点：不允许存储重复元素，是一个无序的集合，不保证迭代顺序，没有索引。

Set接口中的方法和Collection方法一模一样

增强for循环迭代

格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}

1、HasSet

HashSet集合是线程不安全的集合，运行速度快

HashSet底层数据结构哈希表(底层就是HashMap)

存储中，集合调用对象的哈希值，依据哈希值进行存储
如果集合中，没有哈希值，直接开辟空间，存储进去

HashSet<Integer> set2 = new HashSet<Integer>();
set2.add(new Integer(123));
set2.add(new Integer(123));
set2.add(new Integer(123));
set2.add(new Integer(123));
System.out.println(set2);

LinkedHashSet基于链表的哈希表
元素有序，怎么存储就怎么取出来，保证唯一性，线程不安全，不同步

LinkedHashSet<String> lhs = new LinkedHashSet<String>();
lhs.add("dgh");
lhs.add("jhgf");
lhs.add("34wer");
lhs.add("hgfv");
lhs.add("asdfvb");
for(String s : lhs){
System.out.println(s);

2、TreeSet

TreeSet集合，Set一个实现类，存储和取出方式都是一样的

TreeSet<String> ts = new TreeSet<String>();
ts.add("qwgte");
ts.add("jhbgvd");
ts.add("wqedf");
ts.add("a");
ts.add("hbgfvc");
ts.add("sdcv");

Iterator<String> it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());

TreeSet<Integer> ts2 = new TreeSet<Integer>();
ts2.add(123);
ts2.add(65);
ts2.add(23);
ts2.add(654);
for(Integer i : ts2){
System.out.println(i);

3、使用自然顺序排序

class MyComparator implements Comparator<Student> {
public int compare(Student s1,Student s2){
//参数s1 和上s2比较，年龄主要顺序，年龄相同，才比较姓名
int age =s1.getAge() - s2.getAge();
return age == 0?s1.getName().compareTo(s2.getName()):age;
}
}
public class TreeSetDemo{
public static void main(String[] args) {
//使用比较器，构造TreeSet时候，传递比较器对象
TreeSet<Student> ts = new TreeSet<Student>( new MyComparator());
ts.add(new Student("a",18));
ts.add(new Student("b",17));
ts.add(new Student("c",15));
ts.add(new Student("a",16));
ts.add(new Student("b",21));

for(Student s : ts){
System.out.println(s);
}