集合的简单介绍：
集合的由来：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);
}
}
}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);
}
}列表迭代器 (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);
}
}ArrayList：
底层数据结构式数组结构,查询块,增删慢；
从内存角度考虑:线程不安全的,不同步的,执行效率高；
多线程:synchronized :同步的意思，解决线程安全问题
sychronized(锁对象){ 同步代码
共享数据;
}
解决线程安全问题,通过同步可以解决,但是效率低了...
LinkedList：
底层数据结构式链表结构,查询慢,增删块；
从内存角度考虑:线程不安全,不同步,执行效率高；
Vector:：
这是一个线程安全的类；
底层数据结构是数组:查询快,增删慢；
线程安全的,同步,执行效率低；
3576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
