集合的简单介绍:
集合的由来:Java是面向对象的语言,面向对象语言对事物的描述是通过对象体现的,但是要存储对个对象,不能使用基本类型的变量,需要的是容器类型的变量,我们学过的右数组,String,以及StringBuffer,但是String以及StringBuffer始终存储的是字符串类型,不能满足要求,而数组的长度是固定的不符合长度编号的要求,所以Java提供了一个Collection集合;
面试题:
集合与数组的区别:
1) 长度区别:
数组长度固定;
集合长度可变;
2) 内容的区别:
数组可以存储同一种类型的元素;
集合可以存储多种类型的元素;
3) 存储类型的区别:
数组可以存储基本类型,也可以存储引用类型
例如:String[] str = {"hello","world","java",100} ; 错误的
集合只能存储引用类型;
集合:Collection子接口有两个,两个子接口分别对应多个子实现类,多个集合数据结构不同,但是他们有共性内容,将共性内容抽取出来,就可以集合继承体系图;
先来看看在数据结构中数据的存储方式:
主要分为数组,栈,链表,队列;
1> 数组和链表的存储方式:
2> 栈和队列的存储方式:
Collection:
Collection 层次结构中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的(既可有序,也可以无序);
JDK 不提供此接口的任何直接实现:它提供更具体的子接口,更具体的实现类;
集合的基本功能:
添加功能:boolean add(Object e);
删除功能:
void clear():删除集合中所有元素(暴力删除);
boolean remove(Object o):删除集合中的指定元素;
判断功能:
boolean contains(Object o):集合中是否包含指定的元素;
获取功能:
int size():获取集合中的元素数;
转换功能:
Object[] toArray():将集合转换成数组;
举例:
public class CollectionDemo {
public static void main(String[] args) {
//创建集合对象
//Collection c = new Collecton() ; //不能实例化
Collection c = new ArrayList() ;
Collection c1 = new ArrayList();
System.out.println(c);
//添加元素:boolean add(Object e);
System.out.println("flag:"+c.add("hello"));
c.add("hello") ;
c.add("world") ;
c.add("java") ;
c1.add("world");
c1.add("java");
c1.add("hello");
System.out.println("c:"+c) ;
System.out.println("c1:"+c1) ;
/**
add()方法的源码:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true; //只要添加就返回true
}
*/
//删除功能:c.clear();
System.out.println("remove():"+c.remove("java"));
System.out.println("c:"+c);
//boolean contains(Object o):集合中是否包含指定的元素
System.out.println("contains():"+c.contains("android"));
System.out.println("contains():"+c.contains("hello"));
//获取集合中的元素数:
System.out.println(c.size());
//boolean isEmpty() :判断集合是否为空
System.out.println(c.isEmpty());
//交集功能:boolean retainAll(Collection c);
System.out.println("retainAll:"+c.retainAll(c1));
System.out.println("c:"+c) ; //将交集的元素赋给集合c;
System.out.println("c1:"+c1) ;
//删除一个集合中所有元素:boolean removeAll(Collection c);
System.out.println("removeAll:"+c1.removeAll(c));
System.out.println("c:"+c) ;
System.out.println("c1:"+c1) ; //删除集合c中的所有元素,并将删除元素后的集合c赋给c1;
}
}
Collection集合的高级功能:
boolean addAll(Collection c):添加一个集合中的所有元素;
boolean removeAll(Collection c):删除的高级功能;
思考:删除一个算是删除还是删除所有算是删除?);
boolean containsAll(Collection c):包含所有元素算是包含,还是包含一个算是包含;
boolean retainAll(Collection c):交集功能,A集合对B集合取交集;
思考:交集的元素到底是去A集合还是去B集合中,返回值boolean表达什么意思?
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
//创建Collection集合1
Collection c1 = new ArrayList() ;
//添加元素
c1.add("abc1") ;
c1.add("abc2") ;
c1.add("abc3") ;
c1.add("abc4") ;
//创建第二个集合
Collection c2 = new ArrayList() ;
c2.add("abc1") ;
c2.add("abc2") ;
c2.add("abc3") ;
c2.add("abc4") ;
c2.add("abc5") ;
c2.add("abc6") ;
c2.add("abc7") ;
System.out.println("未发生变化的数据:");
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
System.out.println("--------------------------------");
//boolean addAll(Collection c) :添加一个集合中的所有元素
System.out.println("addAll():"+c1.addAll(c2)); //将c2中的所有元素都添加到c1中
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
System.out.println("--------------------------------");
//boolean removeAll(Collection c):删除的高级功能(思考:删除一个算是删除还是删除所有算是删除?)
//结论:删除一个算是删除...
System.out.println("removeAll():"+c1.removeAll(c2));
System.out.println("c1:"+c1); //删除集合c2中的所有元素,并将删除元素后的集合赋给c1;
System.out.println("c2:"+c2);
System.out.println("--------------------------------");
//boolean containsAll(Collection c):包含所有元素算是包含,还是包含一个算是包含
//结论:包含所有算是包含
System.out.println("containsAll():"+c1.containsAll(c2));
System.out.println("c1:"+c1); //c1的所有元素都要在c2中能找到才算包含,并将包含的元素赋给集合c1;
System.out.println("c2:"+c2);
System.out.println("--------------------------------");
//boolean retainAll(Collection c):A集合对B集合取交集,交集的元素到底是去A集合还是去B集合中
//返回值boolean表达什么意思?
//结论:c1集合对c2集合取交集,交集的元素要存到c1集合中,boolean返回值表达的c1集合的元素是否发生变化,如果发生变化,则返回true,否则,返回false
System.out.println("retainAll():"+c1.retainAll(c2));
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
}
}
转换功能:
Object[] toArray():将集合转换成数组;
public class CollectionDemo2 {
public static void main(String[] args) {
//创建一个集合对象
Collection c = new ArrayList() ;
//给集合中添加元素
c.add("hello") ;
c.add("world") ;
c.add("java") ;
c.add("JavaEE") ;
//需要去转换
//Object[] toArray()
//将集合转成数组
Object[] objs = c.toArray() ;
for(int x =0 ; x < objs.length ; x ++) {
//System.out.println(objs[x]);
//需求:输出不同的元素的同时,还需要输出字符串元素的长度
//System.out.println(objs[x]+"----"+objs[x].length());
/**
*上面代码有问题
* length():属于String类型的特有功能,可以获取字符串长度,不能再Object类中使用
*/
String str = (String) objs[x] ; //相当于:向下转型
System.out.println(str+"----"+str.length());
}
}
}
综合练习:
package org.westos_02;
import java.util.ArrayList;
import java.util.Collection;
/**
*需求:存储自定义对象并遍历
*
*有5个学生,学生有姓名,年龄,遍历5个学生,输出5个学生对应的信息(集合改进)
*
*1)创建一个学生类
*2)在测试类中,创建集合对象
*3)创建5个具体学生对象,并且添加集合中
*4)将集合转换数组
*5)遍历
*6)输出
*/
public class CollectionDemo {
public static void main(String[] args) {
//创建一个集合对象
Collection c = new ArrayList() ;
//创建5个具体学生对象
Student s1 = new Student("高圆圆", 27) ;
Student s2 = new Student("杨桃", 28) ;
Student s3 = new Student("王力宏", 35) ;
Student s4 = new Student("周星驰", 60) ;
Student s5 = new Student("成龙", 55) ;
//添加到集合中
c.add(s1) ;
c.add(s2) ;
c.add(s3) ;
c.add(s4) ;
c.add(s5) ;
//转换数组
Object[] objs = c.toArray() ;
//遍历
for(int x = 0 ; x < objs.length ;x ++) {
//System.out.println(objs[x]);
//需求:需要的通过getXXX方法获取学生信息
Student s = (Student) objs[x] ; //向下转型
System.out.println(s.getName()+"----"+s.getAge());
}
}
}
集合中的迭代器:
Iterator iterator():集合的迭代器方法(获取集合的迭代器);集合的专有遍历方式:迭代器遍历;
Iterator :接口中有以下的方法::
boolean hasNext():如果有元素可以迭代,那么返回true,否则返回false;
Object next():返回迭代的下一个元素;
举例:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList() ;
//添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("javaee");
//通过集合获取迭代器
Iterator it = c.iterator() ;
//使用while循环
while(it.hasNext()) {
//Object obj = it.next() ; //Object obj = new Objct();
//需求:打印字符串同时,获取长度
//String str = (String) obj ;
String str = (String)(it.next()) ;
System.out.println(str+"---"+str.length());
}
}
}
存储自定义对象并遍历(使用专有遍历方式):
package org.westos_03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
*存储自定义对象并遍历(使用专有遍历方式)
*
*/
class Student {
private String name ;
private int age ;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
public class IteratorDemo2 {
public static void main(String[] args) {
//创建集合对象:
Collection c = new ArrayList() ;
//创建学生对象
Student s1 = new Student("张三", 27) ;
Student s2 = new Student("李四", 29) ;
Student s3 = new Student("王五", 25) ;
//添加集合中
c.add(s1) ;
c.add(s2) ;
c.add(s3) ;
//获取迭代器
Iterator it = c.iterator() ;
//遍历
while(it.hasNext()) { //模板代码
//System.out.println(((Student) it.next()).getName() + "----" + ((Student) it.next()).getAge());
Student s = (Student)it.next() ;
System.out.println(s.getName()+"="+s.getAge());
}
}
}
Collection有两个子接口:List,Set;
重点讲解List接口:1> List集合包括List接口的所有实现类;
2> List集合中元素允许重复,各元素顺序就是对象插入的顺序(有序的,存储和取出一致);
3> List类似Java数组,用户可以通过使用索引(元素在集合中的位置)来访问集合中的元素;
4> List继承了Collection接口,也包括Collection中的所有方法,而且还定义了以下两个重要的方法:
get (int index):获得指定索引位置的元素;
set (int index,Object obj):将集合中指定索引位置的对象修改为指定的对象;
Set集合的特点:
无序性(不能保证迭代的顺序,基于hashMap),并且元素不能重复;
举例:
public class ListDemo2 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//存储重复元素
list.add("hello") ;
list.add("world") ;
list.add("hello") ;
list.add("java") ;
list.add("javaee") ;
list.add("javaee") ;
list.add("android") ;
list.add("android") ;
//遍历
Iterator it = list.iterator() ;
while(it.hasNext()) {
String s = (String)it.next() ;
System.out.println(s);
}
}
}
List集合的特有功能:
void add(int index,Object element):在指定位置处添加指定元素;
Object get(int index):获取功能,返回列表中指定位置的元素;
ListIterator listIterator():列表迭代器;
Object remove(int index):删除指定位置处的元素;
Object set(int index, Object element):修改功能,用指定element元素替换掉指定位置处的元素;
举例:
import java.util.ArrayList;
import java.util.List;
public class ListDemo3 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
System.out.println("list:"+list);
System.out.println("---------------------");
//void add(int index,Object element):在指定位置处添加指定元素
list.add(1, "javaee"); //在下标为1的位置添加元素"javaee";
System.out.println("list:"+list);
System.out.println("---------------------");
//Object get(int index):返回列表中指定位置的元素。
System.out.println("get():"+list.get(2)); //返回集合下标为2的元素;
System.out.println("---------------------");
//Object remove(int index):删除指定位置处的元素
System.out.println("remove():"+list.remove(3)); //删除集合下标为3的元素;
System.out.println("---------------------");
//Object set(int index, Object element):用指定element元素替换掉指定位置处的元素
System.out.println("set():"+list.set(2, "android")); //将集合下标为2的元素替换成android;
System.out.println("list:"+list);
}
}
ListIterator listIterator():
列表迭代器 (List集合的专有迭代遍历,列表迭代器);
ListIterator接口中:
boolean hasNext() :判断是否有下一个可以迭代的元素(正向遍历);
Object next():获取下一个元素;
boolean hasPrevious():判断是否有上一个可以迭代 元素(逆向遍历);
Object previous():返回上一个元素;
逆向迭代(遍历),单独使用没意义,前提:要先正向遍历;
举例:
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//ListIterator listIterator():列表迭代器
ListIterator it = list.listIterator() ;
//正向遍历
while(it.hasNext()) {
String s = (String)it.next() ;
System.out.println(s+"---"+s.length());
}
System.out.println("--------------------------");
//boolean hasPrevious():判断是否有上一个可以迭代 元素(逆向遍历)
//Object previous():返回上一个元素
//逆向迭代没有意义,前提是先进行了正向遍历,it刚好指向末尾,才能执行逆向遍历的方法;
while(it.hasPrevious()) {
String s = (String)it.previous() ;
System.out.println(s+"---"+s.length());
}
}
}
存储自定义对象并遍历:
size()和get(int index):相结合,普通for循环的方式;
举例:
import java.util.ArrayList;
import java.util.List;
public class ListTest2 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//存储元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
System.out.println("list:"+list);
System.out.println("---------------------");
//遍历(可以是Collection的iterator())
//使用普通遍历
System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
//角标越界:没有元素了
//System.out.println(list.get(3));
System.out.println("---------------------");
//循环
for(int x = 0 ; x < 3 ;x ++) {
System.out.println(list.get(x));
}
System.out.println("---------------------");
//size()和get(int index)相集合
for(int x = 0; x < list.size(); x ++) {
System.out.print(list.get(x)+" ");
}
}
}
存储自定义对象并遍历:两种方式;
方式1:Iterator iterator();
方式2:size() 和 get() 方法相结合;
举例:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTest3 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//创建4个学生对象
Student s1 = new Student("高圆圆", 27) ;
Student s2 = new Student("赵又廷", 30) ;
Student s3 = new Student("文章", 29) ;
Student s4 = new Student("马伊琍", 39) ;
list.add(s1) ;
list.add(s2) ;
list.add(s3) ;
list.add(s4) ;
//方式1:获取迭代器的方式
Iterator it = list.iterator() ;
while(it.hasNext()) {
Student s = (Student)it.next() ;
System.out.println(s.getName()+"---"+s.getAge());
}
System.out.println("--------------------------");
//方式2:size()和get(int index)结合: 普通for循环
for(int x =0 ;x < list.size() ; x ++) {
Student s = (Student)list.get(x) ;
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
综合练习:
package org.westos_05;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* 需求:
*
* 我有一个集合,如下List,请问,我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现
* 假设:List集合 的元素:"hello","world","java"
*
*
* 按照正常的思路:完成了需求,发现出现异常:
* java.util.ConcurrentModificationException:当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。
*
* 产生的原因:按照正常的需求,给集合添加元素,遍历,遍历同时,判断集合中是否有需要的元素,有就添加新元素,
* 遍历的时候,使用迭代器遍历,但是添加元素,使用集合添加元素.
* 集合添加了一个新的元素,迭代器不知道...
*
* 使用迭代器遍历元素,不能使用集合添加元素!
*
* 解决方案:
* 方式1:要么使用迭代器遍历,使用迭代器添加元素!
* 方式2:要么使用集合遍历,使用集合添加元素!
*
*/
public class ListTest {
public static void main(String[] args) {
//创建一个集合对象
List list1 = new ArrayList() ;
List list2 = new ArrayList() ;
//添加元素
list1.add("hello") ;
list1.add("world") ;
list1.add("java") ;
list2.add("hello") ;
list2.add("world") ;
list2.add("java") ;
//这种方法会出现异常:java.util.ConcurrentModificationException;
/*
获取迭代器
Iterator it = list.iterator() ;
判断集合中是否有"world"这个元素
while(it.hasNext()) {
String s = (String)it.next() ;
//判断集合是否有"world"元素,有就添加一个新的元素
if("world".equals(s)) {
//添加元素
list.add("javaee") ;
}
}
*/
//方式1:使用迭代器遍历,迭代器添加元素解决并发修改异常
//Iterator接口没有添加功能呢
//ListIterator:列表迭代器中有add(object e):方法
ListIterator it = list1.listIterator() ;
while(it.hasNext()) {
String s = (String)it.next() ;
if("world".equals(s)) {
//迭代器添加
it.add("javaee"); //指定元素后面插入元素
}
}
System.out.println("list1:"+list1);
System.out.println("-----------------------");
//方式2:使用集合遍历,使用集合添加元素(普通for循环)
for(int x =0 ;x < list2.size() ; x ++) {
String s = (String)list2.get(x) ;
//判断
if("world".equals(s)) {
list2.add("javaee") ;
}
}
System.out.println("list2:"+list2);
}
}
List集合有三个子实现类:
ArrayList:
底层数据结构式数组结构,查询块,增删慢;
从内存角度考虑:线程不安全的,不同步的,执行效率高;
多线程:synchronized :同步的意思,解决线程安全问题
sychronized(锁对象){ 同步代码
共享数据;
}
解决线程安全问题,通过同步可以解决,但是效率低了...
LinkedList:
底层数据结构式链表结构,查询慢,增删块;
从内存角度考虑:线程不安全,不同步,执行效率高;
Vector::
这是一个线程安全的类;
底层数据结构是数组:查询快,增删慢;
线程安全的,同步,执行效率低;