Java语言基础
集合框架
集合
- 集合的由来：
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。 - 数组和集合的区别：
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
增强for遍历
- 概述：简化数组和Collection集合的遍历
- 格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
} - 好处和注意事项：
简化遍历
注意事项：增强for的目标要判断是否为null
迭代器
- 迭代器概述：
可迭代是Java集合框架下的所有集合类的一种共性，也就是把集合中的所有元素遍历一遍。迭代的过程需要依赖一个迭代器对象，那么什么是迭代器呢？
迭代器（Iterator）模式，又叫做游标模式，它的含义是，提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。
从定义上看，迭代器是为容器而生，它本质上就是一种遍历的算法。因为容器的实现千差万别，很多时候不可能知道如何去遍历一个集合对象的元素。Java为我们提供了使用迭代的接口，Java的所有集合类丢失进行迭代的；简单的说，迭代器就是一个接口Iterator，实现了该接口的类就叫做可迭代类，这些类多数时候指的就是java.util包下的集合类。 - 方法:
a：hasNext() 该方法英语判断集合对象是否还有下一个元素，如果已经是最后一个元素则返回false
b：next() 把迭代器的指向移到下一个位置，同时，该方法返回下一个元素的引用
c：remove() 从迭代器指向的Collection中移除迭代器返回的最后一个元素，该操作使用的比较少。
从Java5.0开始，迭代器可以被foreach循环所替代，但是foreach循环的本质也是使用Iterator进行遍历的。
- 系列表迭代器：
ListIterator的特有功能：
boolean hasPrevious()： 是否存在前一个元素
E previous()： 返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前，要先进行正向遍历 ，这样指针才能移到最后，如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素。
- List集合
//将Student类对象存入List集合中：多种遍历方式
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class MyTest2 {
public static void main(String[] args) {
List<Student> List = new ArrayList();
List.add(new Student("张三",20));
List.add(new Student("张三1",21));
List.add(new Student("张三2",22));
//迭代器遍历
Iterator iterator = List.iterator();
while (iterator.hasNext()){
//Student student = (Student) iterator.next(); 向下转型
System.out.println(iterator.next());
}
System.out.println("==============================");
//列表迭代器遍历
ListIterator listIterator = List.listIterator();
while (listIterator.hasNext()){
//Student stu = (Student) listIterator.next(); 向下转型
System.out.println(listIterator.next());
}
System.out.println("==============================");
//使用size()和get()方法遍历
for (int i = 0; i < List.size(); i++) {
Student stu = List.get(i);
System.out.println(stu.getName()+"==="+stu.getAge());
}
System.out.println("==============================");
//使用增强for遍历
for (Student student : List) {
System.out.println(student);
}
}
}
/*
结果:
Student{name='张三', age=20}
Student{name='张三1', age=21}
Student{name='张三2', age=22}
==============================
Student{name='张三', age=20}
Student{name='张三1', age=21}
Student{name='张三2', age=22}
==============================
张三===20
张三1===21
张三2===22
==============================
Student{name='张三', age=20}
Student{name='张三1', age=21}
Student{name='张三2', age=22}
*/
//Student类
public class Student {
private String name;
private int age;
public Student(String name, int age) {
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;
}
//重写toString()方法,在测试类中就不用向下转型遍历集合中的元素了;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- ArrayList集合
//将Student类对象存入ArrayList集合中：多种遍历方式
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList List = new ArrayList();
List.add(new Student("张三",20));
List.add(new Student("张三1",21));
List.add(new Student("张三2",22));
List.add(new Student("张三3",23));
for (int i = 0; i < List.size(); i++) {
//Student stu = (Student) List.get(i); 向下转型
System.out.println(List.get(i));
}
}
}
- Vector集合
- Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
- Vector类特有功能：
public void addElement(E obj)：将指定的组件添加到此向量的末尾，将其大小增加 1
public E elementAt(int index)：返回指定索引处的组件
public Enumeration elements()：返回此向量的组件的枚举
//将Student类对象存入Vector集合中：多种遍历方式
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class Demo {
public static void main(String[] args) {
Vector<Student> vector = new Vector();
vector.add(new Student("张三",20));
vector.add(new Student("张三1",21));
vector.add(new Student("张三2",22));
//迭代器遍历
Iterator iterator = vector.iterator();
while (iterator.hasNext()){
//Student student = (Student) iterator.next(); 向下转型
System.out.println(iterator.next());
}
System.out.println("===========================");
//使用Vector特有的迭代器遍历
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
//Student student = (Student) elements.nextElement(); 向下转型
System.out.println(elements.nextElement());
}
System.out.println("===========================");
//使用size()和get()方法遍历
for (int i = 0; i < vector.size(); i++) {
Student student = vector.get(i);
System.out.println(student.getName()+"==="+student.getAge());
}
System.out.println("===========================");
//使用增强for遍历
for (Student student : vector) {
System.out.println(student);
}
}
}
- LinkedList集合
- LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的
- LinkedList类特有功能：
public void addFirst(E e)：将指定元素插入此列表的开头
public void addLast(E e)：将指定元素添加到此列表的结尾
public E getFirst()：返回此列表的第一个元素
public E getLast()：返回此列表的最后一个元素
public E removeFirst()：移除并返回此列表的第一个元素
public E removeLast()：移除并返回此列表的最后一个元素
//将Student类对象存入LinkedList集合中：多种遍历方式
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class MyTest {
public static void main(String[] args) {
LinkedList<Student> linkedList = new LinkedList();
linkedList.add(new Student("张三",20));
linkedList.add(new Student("张三1",21));
linkedList.add(new Student("张三2",22));
//使用迭代器遍历
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()){
//Student student = (Student) iterator.next(); 向下遍历
System.out.println(iterator.next());
}
System.out.println("=========================");
//使用列表迭代器遍历
ListIterator<Student> studentListIterator = linkedList.listIterator();
while (studentListIterator.hasNext()){
//Student student = studentListIterator.next(); 向下遍历
System.out.println(studentListIterator.next());
}
System.out.println("=========================");
//使用size()和get()方法遍历
for (int i = 0; i < linkedList.size(); i++) {
Student student = linkedList.get(i);
System.out.println(student.getName()+"==="+student.getAge());
}
System.out.println("=========================");
//使用增强for遍历
for (Student student : linkedList) {
System.out.println(student);
}
}
}
- List的三个子类的特点：
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。 - 并发修改异常（ConcurrentModificationException）
我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合会出现并发修改异常；
- 原因：
是我们的迭代依赖与集合，当我们往集合中添加好了元素之后 获取迭代器 ，那么迭代器已经知道了集合的元素个数，这个时候你在遍历的时候又突然想给，集合里面加一个元素（用的是集合的add方法） 那迭代器不同意，就报错了； - 解决方案：
我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
b:集合遍历元素，集合修改元素
解决方案2 ：使用for循环遍历集合 添加元素 不会报错
//并发修改异常演示：想要在"bbb"后面加上"111",但下面的程序运行出错，原因就是ConcurrentModificationException:并发修改异常
class Demo {
public static void main (String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
for (Iterator it = list.iterator(); it.hasNext(); ) {
String str = (String)it.next();
if ("bbb".equals( str )) {
list.add("111");
}
}
System.out.println( list );
}
}
//修改程序：第一种：Iterator迭代器没有添加功能，可以使用它的子接口ListIterator
class Demo {
public static void main (String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
for (ListIterator lit = list.listIterator(); lit.hasNext(); ) {
String str = (String)lit.next();
if ("bbb".equals( str )) {
lit.add("111");
}
}
System.out.println( list );
}
}
//修改程序:集合遍历元素，在遍历过程中添加元素
for (int i = 0; i < list.size(); i++) {
String str = (String) list.get(i);
if ("bbb".equals( str )) {
list.add("111");
}
}
- Collection集合
// 单列集合 顶层父接口
- Collection的功能概述：
a:添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
b:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 ，如果没有交集元素则删除失败，返回false
c:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)，比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean isEmpty()：判断集合是否为空
d:获取功能
Iterator iterator()：返回在此 collection 的元素上进行迭代的迭代器。
e:长度功能
int size():元素的个数
f:把集合转换为数组
Object[] toArray()
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
//将Student类对象存入Collection集合中：并且遍历
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(new Student("张三",20));
collection.add(new Student("张三1",21));
collection.add(new Student("张三2",22));
Object[] objects = collection.toArray();
for (int i = 0; i < objects.length; i++) {
//Student student = (Student) objects[i]; 向下转型
System.out.println(objects[i]);
}
//迭代器遍历
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
Student student = (Student) iterator.next();
System.out.println(student.getName()+"==="+student.getAge());
}
}
//下篇再见…谢谢
扫一扫
140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
