一、集合框架——体系概述
为什么出现集合类？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。 数据多了用对象存，对象多了用集合存。数组是固定长度的，集合是可变长度的；数组只能存储同中类型的数据，集合可以存储不同类型的数据。 数组和集合类同是容器，有何不同？ 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。 数组中可以存储基本数据类型和对象，集合只能存储对象。 集合类的特点： 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。 Collection 体系(集合框架)： Collection -List -ArrayList -LinkedList -Vector -Set -HashSet -TreeSet 为什么会出现这么多的容器呢？ 因为每一个容器对数据的存储方式都有不同。这个存储方式称之为——数据结构。二、集合框架——共性方法
java.util.Collection public interface Collection<E> extends Iterable Collection -List: 元素是有序的，元素可以重复，因为该集合体系有索引。 -ArrayList: 底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢。线程不同步。 -LinkedList: 底层使用的是链表数据结构，特点：增删速度很快，查询稍慢 -Vector: 底层是数组数据结构。线程同步。被ArrayList替代。 -Set: 元素是无序的(元素存入和取出的顺序不一致)，元素不可以重复。 -HashSet: 底层数据结构是哈希表。 -TreeSet: 底层数据结构是二叉树。 注意： 1、add方法的参数类型是 Object ,以便于接收任意类型对象； 2、集合中存储的都是对象的引用(地址)； 常见方法： ArrayList al = new ArrayList();//创建一个集合容器 al.add("java01");//添加元素 al.add("java02"); al.size();//获取个数，集合长度 sop(al);//打印的是元素 al.remove("java02");//删除元素//返回结果是boolean类型 al.clear();//清空集合 al.contains("java01");//是否包含元素 al.isEmpty();//是否为空 取交集： ArrayList al1 = new ArrayList(); ArrayList al2 = new ArrayList(); al1.add("java01"); al1.add("java02"); al2.add("java01"); al2.add("java03"); al1.retainAll(al2); 结果： al1=[java01]; al2=[java01,java03]; 删除交集： ArrayList al1 = new ArrayList(); ArrayList al2 = new ArrayList(); al1.add("java01"); al1.add("java02"); al2.add("java01"); al2.add("java03"); al1.removeAll(al2); 结果： al1=["java02"]; al2=["java01","java03"]; 代码：import java.util.*; class CollectionDemo1 { public static void main(String[] args) { base_method(); method_2(); } public static void base_method() { //创建一个集合容器。 ArrayList al = new ArrayList(); //添加元素。 al.add("java01"); al.add("java02"); al.add("java03"); al.add("java04"); //获取个数，集合长度 sop("size: "+al.size());//4 //打印集合 sop("原集合: "+al);//[java01, java02, java03, java04] //判断元素 sop("java03是否存在: "+al.contains("java03"));//true sop("集合是否为空？"+al.isEmpty());//false //删除元素 sop(al.remove("java02"));//true sop("删除后集合: "+al);//[java01, java03, java04] //清空集合 al.clear(); sop("清空后: "+al);//[] } public static void method_2() { ArrayList al1 = new ArrayList(); al1.add("java01"); al1.add("java02"); al1.add("java03"); al1.add("java04"); ArrayList al2 = new ArrayList(); al2.add("java05"); al2.add("java06"); al2.add("java03"); al2.add("java04"); //al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素 al1.removeAll(al2);//删除交集，al1中删除和al2相同的元素 sop("al1: "+al1); sop("al2: "+al2); } public static void sop(Object obj) { System.out.println(obj); } }三、集合框架——迭代器 Iterator
java.util.Iterator
public interface Iterator<E>
什么是迭代器？
其实就是集合的取出元素的方式。
用于获取元素。
代码：import java.util.*; class CollectionDemo2 { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("java01"); al.add("java02"); al.add("java03"); al.add("java04"); Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。 while(it.hasNext()) sop(it.next()); /*优化内存 for (Iterator it=al.iterator() ;it.hasNext() ; ) { sop(it.next()); } */ } public static void sop(Object obj) { System.out.println(obj); } }
Iterator 接口只有hasNext();next();remove();三个方法。
因为每一种集合的取出方式不一致，就把取出方式定义在集合内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容——判断和取出，那么可以将共性内容抽取形成一个接口。该接口是 Iterator 。
如何获取集合的取出对象呢？
集合通过一个对外提供的方法——iterator() 来获取该接口。
这就是内部类的设计在 Iterator 中的体现。四、集合框架—— List 集合共性方法
List 集合的特有方法:
凡是可以操作角标的方法都是该体系特有的方法。
增: 在指定位置插入元素
void add(index, element);
boolean addAll(index, Collection);
删:
E remove(index);//返回的是该元素
改:
E set(index, element);
查:
E get(index);
List<E> subList(from, to);
ListIterator<E> listIterator();
int indexOf(Object obj);
代码：import java.util.*; class ListDemo { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("java01"); al.add("java02"); al.add("java03"); sop("原集合: "+al);//原集合: [java01, java02, java03] //在指定位置添加元素，即插入 al.add(1,"java09"); sop("添加后集合: "+al);//添加后集合: [java01, java09, java02, java03] //删除指定位置元素 sop(al.remove(2));//java02 sop("删除后集合: "+al);//删除后集合: [java01, java09, java03] //修改元素 al.set(2,"java007"); sop("修改后集合: "+al);//修改后集合: [java01, java09, java007] //通过角标获取元素 sop("al.get(1) : "+al.get(1));//al.get(1) : java09 //通过for循环方式获取所有元素 for (int x=0 ;x<al.size() ;x++ ) { sop("al("+x+") : "+al.get(x)); } //通过迭代器的方式获取所有元素 Iterator it = al.iterator(); while (it.hasNext()) { sop("next() : "+it.next()); } //通过indexOf获取对象的位置 sop("index="+al.indexOf("java007"));//index=2 List sub = al.subList(1,3); sop("sub="+sub);//sub=[java09, java007] } public static void sop(Object obj) { System.out.println(obj); } }五、集合框架—— ListIterator
java.util.ListIterator
public interface ListIterator<E> extends Iterator<E>
List 集合特有的迭代器, ListIterator 是 Iterator 的子接口。
代码一：class IteratorDemo { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("java01"); al.add("java02"); al.add("java03"); Iterator it = al.iterator(); while (it.hasNext()) { Object obj = it.next(); if(obj.equals("java02")) al.add();//ConcurrentModificationException //it.remove();//运行OK System.out.println(obj); } } }
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生 ConcurrentModificationException 异常。
所以，在迭代时，只能用迭代器的方法操作元素。可是 Iterator 方法是有限的，只能对元素进行判断、取出、删除的操作；如果想要其他的操作，如添加、修改等，就需要使用其子接口: ListIterator , 该接口只能通过 List 集合的 listIterator() 方法获取。
代码二：import java.util.*; class ListDemo { public static void main(String[] args) { //演示列表迭代器 ArrayList al = new ArrayList(); al.add("java01"); al.add("java02"); al.add("java03"); System.out.println(al); ListIterator li = al.listIterator(); while (li.hasNext()) { Object obj = li.next(); if (obj.equals("java02")) { //li.set("java006"); li.add("java009"); } } System.out.println(al); } }
hasPrevious(); previous(); 可用于反向遍历；(不常用)六、集合框架—— List 集合具体对象的特点
Collection
-List
-ArrayList 数组数据结构，线程不同步
-LinkedList 链表结构
-Vector 数组数据结构，线程同步，被ArrayList替代。
ArrayList 长度可变原理：
ArrayList 默认长度为10，当元素超过10时, ArrayList 会new一个新的数组，该数组延长50%；然后把原来的元素copy到该数组，再把新元素添加到该数组中。
Vector 是100%延长。七、集合框架—— Vector 中的枚举
Vector 和 ArrayList 功能是一致的。
其特有方法：
elements()方法返回一个枚举 Enumeration 。
枚举是 Vector 特有的取出方式，其实枚举和迭代器是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。
示例代码：import java.util.*; class VectorDemo { public static void main(String[] args) { Vector v = new Vector(); v.add("java01"); v.add("java02"); v.add("java03"); v.add("java04"); Enumeration en = v.elements(); while (en.hasMoreElements()) { System.out.println(en.nextElement()); } } }八、集合框架—— LinkedList
Collection
-List
-LinkedList: 链表结构
特有方法：
add();
addFirst();
addLast();
offer();
offerFirst();
offerLast();
get(int index);
getFirst();
getLast();
获取元素；如果列表为空，抛出 NoSuchElementException 。
peek();
peekFirst();
peekLast();
获取元素；而且当列表为空时，不会抛出异常，而是返回null。
remove(int index/Object o);
removeFirst();
removeLast();
获取元素，并删除元素；如果列表为空，抛出 NoSuchElementException 。
poll();
pollFirst();
pollLast();
获取元素，并删除元素；而且当列表为空时，不会抛出异常，而是返回null。
代码：import java.util.*; class LinkedListDemo { public static void main(String[] args) { LinkedList link = new LinkedList(); link.addFirst("java01"); link.addFirst("java02"); link.addFirst("java03"); System.out.println(link);//结果[java03,02,01] //不用迭代器的取出方式： while (!(link.isEmpty())) { System.out.println(link.remove());//删除第一个元素 //removeFirst(); //removeLast(); //poll(); } } }九、集合框架—— LinkedList 练习
使用 LinkedList 模拟一个堆栈或者队列数据结构。
堆栈：先进后出
队列：先进先出 First in First out FIFO
代码：import java.util.*; class LinkedListTest { public static void main(String[] args) { DuiLie dl = new DuiLie(); dl.myAdd("java01"); dl.myAdd("java02"); dl.myAdd("java03"); while(!dl.isNull()) System.out.println(dl.myGet()); } } class DuiLie { private LinkedList link; DuiLie() { link = new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public Object myGet() { return link.removeLast();//改为removeFirst(),就是堆栈结构。 } public boolean isNull() { return link.isEmpty(); } }十、集合框架—— ArrayList 练习
需求：
取出 ArrayList 集合中的重复元素。
思路:
1、创建一个新的ArrayList集合，用于存储原集合中不重复的元素；
2、迭代原集合，并在迭代过程中判断新集合中是否包含迭代出的元素；
3、如果新集合不包含该元素，则将该元素存入新集合；
4、迭代完毕，返回新的集合。
代码：import java.util.*; class ArrayListTest { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("java01"); al.add("java02"); al.add("java01"); al.add("java03"); al.add("java01"); al.add("java02"); al = singleElement(al); System.out.println(al); } public static ArrayList singleElement(ArrayList al) { //定义一个临时容器 ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while (it.hasNext()) { Object obj = it.next(); if(!newAl.contains(obj)) newAl.add(obj); } return newAl; } }
注意：在迭代时，next调用一次，就要hasNext调用一次。十一、集合框架 —— ArrayList 练习2
需求：
将自定义对象作为元素存到 ArrayList 集合中，并去除重复元素。比如：存人对象，同姓名同年龄，视为同一个人，为重复元素。
思路：
1、对人描述，将数据封装进人对象；
2、定义容器，将人存入；
3、取出。
注意:
List 集合contains()方法判断元素是否相同，调用的是元素的equals方法。
remove(Object o),底层调用的也是equals方法。
定义一个对象时，如果该对象要放到 ArrayList 集合中，则该对象需要复写 Object 中的equals方法，自定义equals的比较方式。
代码：import java.util.*; class ArrayListTest2 { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add(new Person("lisi01",30)); al.add(new Person("lisi02",33)); al.add(new Person("lisi03",34)); al.add(new Person("lisi04",35)); al.add(new Person("lisi03",34)); al.add(new Person("lisi04",35)); al = singleElement(al); Iterator it = al.iterator(); while (it.hasNext()) { Object obj = it.next(); Person p = (Person)obj; System.out.println(p.getName()+"::"+p.getAge()); } } public static ArrayList singleElement(ArrayList al) { ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while (it.hasNext()) { Object obj = it.next(); if(!(newAl.contains(obj))) newAl.add(obj); } return newAl; } } class Person { private String name; private int age; Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; System.out.println(this.name+"..."+p.name); return this.name.equals(p.name) && this.age == p.age; } }十二、集合框架 —— HashSet
-Set: 元素是无序的(元素存入和取出的顺序不一致)，元素不可以重复。
-HashSet: 底层数据结构是哈希表。
-TreeSet: 底层数据结构是二叉树。
Set 集合的功能和 Collection 的功能是一致的。
HashSet 集合中元素存储顺序是按照哈希值来存储。
当元素的哈希值不相同时，每一个元素都有自己的位置；
当两个元素的哈希值相同时，则判断两个元素是否是同一个对象，如果不是同一个对象，则会在前一个元素位置上顺延，用来存放另一个元素，两个元素的地址值相同。
add() 方法返回值类型是 boolean 类型，添加成功，结果是 true ; 添加失败，结果是 false 。
代码：import java.util.*; class HashSetDemo { public static void main(String[] args) { HashSet hs = new HashSet(); hs.add("java01"); hs.add("java02"); System.out.println(hs.add("java03"));//true System.out.println(hs.add("java03"));//false 添加失败 System.out.println(hs);//[java02, java03, java01] } }十三、集合框架 —— HashSet 存储自定义对象
HashSet 是如何保证元素的唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成的。
如果元素的hashCode值相同，才会判断equals是否为true；
如果hashCode值不同，不会调用equals.
在自定义对象时，通常复写hashCode方法和equals方法。因为这个对象有可能放到 HashSet 集合中。
注意：比较对象是否相同，调用的是equals方法。
代码：import java.util.*; class HashSetTest1 { public static void main(String[] args) { HashSet hs = new HashSet(); hs.add(new Person("a1",11)); hs.add(new Person("a2",12)); hs.add(new Person("a3",13)); hs.add(new Person("a3",13)); Iterator it = hs.iterator(); while (it.hasNext()) { Object obj = it.next(); Person p = (Person)obj; System.out.println(p.getName()+"..."+p.getAge()); } } } class Person { private String name; private int age; Person(String name, int age) { this.name = name; this.age = age; } public int hashCode() { System.out.println(name+"..hashCode..."); //return 60; return name.hashCode()+age*37; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; System.out.println(this.name+"...equals.."+p.name); return this.name.equals(p.name) && this.age == age; } public String getName() { return name; } public int getAge() { return age; } }十四、集合框架 —— HashSet 判断和删除的依据
对于判断元素是否存在 contains() ，以及删除 remove() 等操作，依赖的方法是hashCode和equals
1994
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
