本文深入探讨Java集合框架的核心概念，包括集合的由来、数组与集合的区别、集合的基本功能及其实现原理。此外，还详细介绍了List接口及其子类的特点与应用场景，帮助读者更好地理解和运用Java集合。
一、集合的由来及集合继承体系图
1、集合的由来
数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦
java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
2、数组和集合的区别
[1]区别1 :
数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
[2]区别2:
数组长度是固定的,不能自动增长
集合的长度的是可变的,可以根据元素的增加而增长
3、数组和集合什么时候用
[1]如果元素个数是固定的推荐用数组
[2]如果元素个数不是固定的推荐用集合
二、集合的基本功能
boolean add(E e) 添加元素
boolean remove(Object o) 移除元素
void clear() 清除所有元素
boolean contains(Object o) 是否包含
boolean isEmpty() 是否为空
int size() 元素个数
三、带all功能
[1]boolean addAll(Collection c) 添加每一个元素
[2]boolean removeAll(Collection c) 删除交集
[3]boolean containsAll(Collection c) 判断集合是否包含集合
[4]boolean retainAll(Collection c)
四、集合的遍历之迭代器遍历
集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
迭代器的使用
Collection c = new ArrayList();
c.add("a");
c.add("b");
Iterator it = c.iterator();//获取迭代器的引用
while(it.hasNext()) {//集合中的迭代方法(遍历)
System.out.println(it.next());
}
迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* collectionXxx.java使用了未经检查或不安全的操作.
注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
java编译器认为该程序存在安全隐患
* */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class CollectionMethod {
public static void main(String[] args) {
/*
* 一、集合的由来及集合继承体系图
1、集合的由来
数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦
java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
2、数组和集合的区别
[1]区别1 :
数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
[2]区别2:
数组长度是固定的,不能自动增长
集合的长度的是可变的,可以根据元素的增加而增长
3、数组和集合什么时候用
[1]如果元素个数是固定的推荐用数组
[2]如果元素个数不是固定的推荐用集合
二、集合的基本功能
boolean add(E e) 添加元素
boolean remove(Object o) 移除元素
void clear() 清除所有元素
boolean contains(Object o) 是否包含
boolean isEmpty() 是否为空
int size() 元素个数
三、带all功能
[1]boolean addAll(Collection c) 添加每一个元素
[2]boolean removeAll(Collection c) 删除交集
[3]boolean containsAll(Collection c) 判断集合是否包含集合
[4]boolean retainAll(Collection c)
四、集合的遍历之迭代器遍历
集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
迭代器的使用
Collection c = new ArrayList();
c.add("a");
c.add("b");
Iterator it = c.iterator(); //获取迭代器的引用
while(it.hasNext()) { //集合中的迭代方法(遍历)
System.out.println(it.next());
}
迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,
那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器
是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合
体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
* */
addMethod();
forCollection();//集合遍历
allMethod();
iterator();//迭代器
}
private static void iterator() {
System.out.println("===============迭代器==============");
Collection c = new ArrayList();
c.add(new Student("王二",12)); //Object s = new Student();
c.add(new Student("张三",13));
c.add(new Student("李四",14));
c.add(new Student("赵五",15));
Iterator i = c.iterator();
while(i.hasNext()){
Student s1 = (Student)i.next();
System.out.println(s1.getName() + "----" + s1.getAge());
}
}
private static void allMethod() {
System.out.println("==============all方法===============");
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
//alt+shift+r 改名
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
c2.add("c");
c2.add("z");
c1.addAll(c2); //将c2中每一个元素添加到c1中
// c1.add(c2); //将c2作为一个对象添加到c1中
System.out.println(c1);
// c1.removeAll(c2); //删除交集
System.out.println(c1);
// System.out.println(c1.containsAll(c2));
//取交集，如果调用的集合改变就返回true,如果调用的集合不变就返回false
System.out.println(c1.retainAll(c2));
System.out.println(c1);
}
private static void forCollection() {
Collection c = new ArrayList();
c.add(new Student("王二",12)); //Object s = new Student();
c.add(new Student("张三",13));
c.add(new Student("李四",14));
c.add(new Student("赵五",15));
Object[] arr = c.toArray();//将集合转为数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
Student s1 = (Student)arr[i];
System.out.println(s1.getName() + "----" + s1.getAge());
}
}
private static void addMethod() {
Collection c = new ArrayList(); //父类对象指向子类引用
/*
* add方法如果是List集合一直都返回true，因为list集合中可以存储重复元素
* 如果是set集合当存储重复元素时，就会返回FALSE
* ArrayList的父类的父类重写toString()方法，因此在打印对象的引用时，输出结果不是Object中toString结果
* */
c.add(true);
c.add("new");
c.add(11);
c.add("new");
System.out.println(c);
System.out.println(c.size());
}
}
五、List集合的特有功能概述和测试
void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element) 修改指定位置上元素
六、ListIterator
boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous();返回上一个元素
七、Vector类特有功能
public void addElement(Eobj)
public E elementAt(int index)
public Enumeration elements()
八、数据结构之数组和链表
1、数组
查询快修改也快(通过索引直接找值)
增删慢(增：当前索引位置之后的所有元素向后移动，并在修改处修改值
删：当前索引位置之后的所有元素向前移动，且没有值位置覆盖为默认值)
2、链表
查询慢,修改也慢(先根据距离后面还是前面近来一个元素一个元素向前或者向后查找)
增删快(链表的重新断开和连接)
九、List的三个子类的特点
1、ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
2、Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
3、LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
4、Vector和ArrayList的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
共同点:都是数组实现的
5、ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的
6、List三个子类，如何使用
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class ListMethod {
public static void main(String[] args) {
/*
* 一、List集合的特有功能概述和测试
void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element) 修改指定位置上元素
二、ListIterator
boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous();返回上一个元素
三、Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
四、数据结构之数组和链表
1、数组
查询快修改也快(通过索引直接找值)
增删慢(增：当前索引位置之后的所有元素向后移动，并在修改处修改值
删：当前索引位置之后的所有元素向前移动，且没有值位置覆盖为默认值)
2、链表
查询慢,修改也慢(先根据距离后面还是前面近来一个元素一个元素向前或者向后查找)
增删快(链表的重新断开和连接)
五、List的三个子类的特点
1、ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
2、Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
3、LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
4、Vector和ArrayList的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
共同点:都是数组实现的
5、ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的
6、List三个子类，如何使用
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList
* */
initList();
forList();//循环遍历
exception();
listIterator();
vector();
}
private static void vector() {
Vector v = new Vector();
v.add("abc");
v.add("123");
v.add("ckn");
Enumeration e = v.elements();
while(e.hasMoreElements()){
System.out.print(e.nextElement() + " ");
}
}
private static void listIterator() {
System.out.println("=========ListIterator===========");
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("w");
list.add("d");
list.add("e");
ListIterator lit = list.listIterator();
while(lit.hasNext()){
System.out.print(lit.next() + " ");
}
System.out.println("");
//此处必须正向遍历一遍才能反向遍历
while(lit.hasPrevious()){
System.out.print(lit.previous() + " ");
}
System.out.println();
}
private static void exception() {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("w");
list.add("d");
list.add("e");
/*Iterator it = list.iterator();
while(it.hasNext()) {
String str = (String)it.next();
if(str.equals("world")) {
list.add("javaee"); //遍历的同时在并发修改
//这里会抛出ConcurrentModificationException并发修改异常
}
} 修改如下： */
ListIterator lit = list.listIterator();
while(lit.hasNext()){
String str = (String)lit.next();
if(str.equals("w")) {
// list.add("javaee");
lit.add("java");
}
}
System.out.println(list);
}
private static void initList() {
List l = new ArrayList();
l.add("a");
l.add("b");
l.add("c");
l.add(3, "d"); //index <= size
System.out.println(l);
// l.add(10, "e"); //java.lang.IndexOutOfBoundsException索引越界异常
Object obj = l.remove(1);
System.out.println(obj);
System.out.println(l);
System.out.println(l.get(1));
l.set(2, "g");
System.out.println(l);
}
private static void forList() {
System.out.println("==============List遍历对象=============");
List list = new ArrayList();
list.add(new Student("张三", 18));
list.add(new Student("李四", 18));
list.add(new Student("王五", 18));
list.add(new Student("赵六", 18));
for(int i = 0; i < list.size(); i++) { //list.size()
Student s = (Student)list.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
}
}
扫一扫
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
