Java基础篇之集合
目录
集合：
目录
集合：
常用集合类体系结构图：
collection：
Collection集合的成员方法：
Collection集合的遍历：
集合使用步骤图解：
Collection的练习：
List集合：
List集合的特有成员方法：
List集合的普通for循环遍历：
List集合练习：
List集合迭代器的特有功能：
集合中并发修改异常产生的原因及解决方案：
增强for：
增强for练习之List集合存储自定义对象并遍历：
常见数据结构之栈和队列：
List集合子类特点及ArrayList集合存储字符串并遍历：
常用集合类体系结构图：
collection：
Collection集合的成员方法：
Collection集合的遍历：
集合使用步骤图解：
Collection的练习：
List集合：
List集合的特有成员方法：
List集合的普通for循环遍历：
List集合练习：
List集合迭代器的特有功能：
集合中并发修改异常产生的原因及解决方案：
增强for：
增强for练习之List集合存储自定义对象并遍历：
常见数据结构之栈和队列：
List集合子类特点及ArrayList集合存储字符串并遍历：
集合：
为什么出现集合类：
我们学习的是面向对象的编程语言，面向对象的编程语言对事物的描述都是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储，而要想存储多个对象，就不能是基本的变量了，应该是一个容器类型的变量。
容器类型的举例：
数组，StringBuilder
StringBuilder,它的结果是一个字符串，不一定满足我们的需求，所以我们只能选择数组了，而数组的长度固定，不能适应变化的需求，在这种情况下，Java就提供了集合类供我们使用。由此可见，集合的长度是可变的。
常用集合类体系结构图：
collection：
Collection:是单列集合的顶层接口。
Collection 表示一组对象，这些对象也称为 collection 的元素。
一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。
JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。
因为这个类是最常用的集合类。
ArrayList()
Collection
：
:是一种特殊的数据类型，泛型。 在出现E的地方用引用数据类型替换即可。
举例：Collection
,Collection
import java.util.ArrayList;
import java.util.Collection;
public class Arraylist001 {
public static void main(String[] args) {
Collection c = new ArrayList();//多态的方式
//boolean add(E e):添加元素
c.add("hello");
c.add("world");
c.add("java");
//输出集合对象
System.out.println(c);
//输出了集合中的元素按照指定格式拼接的内容，说明ArrayList重写了toString（）方法
}
} 输出结果：
[hello, world, java]
Collection集合的成员方法：
boolean add(E e):添加元素
boolean remove(Object o):从集合中移除元素
void clear():清空集合中的元素
boolean contains(Object o):判断集合中是否存在指定的元素
boolean isEmpty():判断集合是否为空
int size():集合的长度，也就是集合中元素的个数
提示：IDEA中显示类中方法大纲快捷键：alt+7
import java.util.ArrayList;
import java.util.Collection;
public class Arraylist001 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//boolean add(E e):添加元素
System.out.println("add:"+c.add("hello"));
System.out.println("add:"+c.add("world"));
// public boolean add(E e) {
// ++this.modCount;
// this.add(e, this.elementData, this.size);
// return true;
// }
//通过查看源码，可知，返回值永远都是true
//输出集合对象
// System.out.println("remove:"+c.remove("world"));
// System.out.println("remove:"+c.remove("haha"));
// c.clear();
// System.out.println("contains:"+c.contains("hello"));
// System.out.println("contains:"+c.contains("haha"));
// System.out.println("isEmpty:"+c.isEmpty());
System.out.println("size:"+c.size());
System.out.println(c);
}
} 以上代码，想测试哪个方法，即可改变注释内容进行测试
Collection集合的遍历：
Iterator
iterator():返回在此 collection 的元素上进行迭代的迭代器。 通过集合对象调用iterator()方法得到迭代器对象。
Iterator:
E next():返回迭代的下一个元素。
boolean hasNext():如果仍有元素可以迭代，则返回 true。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Arraylist001 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//Iterator iterator():返回在此 collection 的元素上进行迭代的迭代器。
//通过集合对象调用iterator()方法得到迭代器对象。
//Iterator:
// E next():返回迭代的下一个元素。
// boolean hasNext():如果仍有元素可以迭代，则返回 true。
Iteratorit = c.iterator();//返回的是迭代器接口的实现类的对象
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
while (it.hasNext()){
// System.out.println(it.next());
String s = it.next();
System.out.println(s);
}
}
} 输出结果：
hello
world
java
集合使用步骤图解：
Collection的练习：
Collection集合存储自定义对象并遍历 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。 集合的使用步骤： A:创建集合对象 B:创建元素对象 C:把元素添加到集合 D:遍历集合
public class Student {
private String name;
private int age;
public Student(){}
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;
}
}import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
//创建集合对象
Collectionc = new ArrayList();
//创建元素对象
Student s1 = new Student("林青霞",30);
Student s2 = new Student("张曼玉",35);
Student s3 = new Student("王祖贤",33);
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合
Iteratorit = c.iterator();
while (it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+"---"+s.getAge());
}
}
} 输出结果：
林青霞---30
张曼玉---35
王祖贤---33
List集合：
List:有序的 collection（也称为序列）。
此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与 set 不同，列表通常允许重复的元素。
List集合的特点：
A:有序(存储和取出元素的顺序一致)
B:存储的元素可以重复
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
//创建集合对象
Listlist = new ArrayList();
//存储元素
list.add("hello");
list.add("world");
list.add("java");
list.add("world");
//遍历集合
Iteratorit = list.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
} 输出结果：
hello
world
java
world
List集合的特有成员方法：
void add(int index,E element):在指定位置添加元素
E remove(int index):删除指定位置的元素
E get(int index):获取指定位置的元素
E set(int index,E element):修改指定位置的元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
//创建集合对象
Listlist = new ArrayList();
//存储元素
list.add("hello");
list.add("world");
list.add("java");
//遍历集合
list.add(1,"javaee");
System.out.println(list);
System.out.println("remove:"+list.remove(1));
//返回删除位置的元素
//list.remove(1);
System.out.println(list);
System.out.println("get:"+list.get(1));
System.out.println("set:"+list.set(1,"javaee"));//修改指定位置的元素
System.out.println(list);
}
} 输出结果：
remove:javaee
[hello, world, java]
get:world
set:world
[hello, javaee, java]
List集合的普通for循环遍历：
List集合的遍历：
A：迭代器
B：普通for循环
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
Listlist = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
for (int x = 0;x 输出结果：
hello
world
java
List集合练习：
自定义一个学生类，给出成员变量name和age。
遍历集合的时候，在控制台输出学生对象的成员变量值。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
Listlist = new ArrayList();
Student s = new Student("林青霞",33);
Student s1 = new Student("张曼玉",35);
Student s2 = new Student("王祖贤",30);
list.add(s);
list.add(s1);
list.add(s2);
Iteratorit = list.iterator();
while (it.hasNext()){
Student s4 = it.next();
System.out.println(s4.getName()+"---"+s4.getAge());
}
System.out.println("-------");
for (int x = 0;x 输出结果：
林青霞---33
张曼玉---35
王祖贤---30
-------
林青霞---33
张曼玉---35
王祖贤---30
List集合迭代器的特有功能：
ListIterator:
ListIterator
listIterator():返回此列表元素的列表迭代器 public interface ListIterator
extends Iterator 特有功能：
E previous():返回列表中的前一个元素。
boolean hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
注意：ListIterator可以实现逆向遍历，但是要求先正向遍历，才能逆向遍历。
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
Listlist = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
ListIteratorlis = list.listIterator();
while (lis.hasNext()){
String s = lis.next();
System.out.println(s);
}
System.out.println("----------");
while (lis.hasPrevious()){
String s = lis.previous();
System.out.println(s);
}
}
} 输出结果：
hello
world
java
----------
java
world
hello
集合中并发修改异常产生的原因及解决方案：
我有一个集合：List
list = new ArrayList (); 里面有三个元素list.add("hello");list.add("world");list.add("java");
我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
产生的原因：
迭代器依赖于集合而存在，在判断成功后，集合中添加了新的元素，而迭代器并不知道，所有就报错了。
其实这个问题说的是：迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合中的元素。
解决方法： A:迭代器遍历的时候，我可以通过迭代器修改集合中的元素
元素是跟在刚才迭代的元素后面的
B:集合遍历的时候，我可以通过集合对象修改集合中的元素
元素是在最后添加的
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
List list = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
// Iteratorit = list.iterator();
// while (it.hasNext()){
// String s = it.next();
// if(s.equals("world")){
// list.add("javaee");
//ConcurrentModificationException并发修改异常
// }
// }
// ListIterator lit = list.listIterator();
// while (lit.hasNext()) {
// String s = lit.next();
// if (s.equals("world")) {
// lit.add("javaee");
// }
// }
for (int x = 0;x 增强for：
增强for：是for循环的一种
格式：
for(元素的数据类型 变量名 : 数组名或者Collection集合对象名) {
使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
}
好处：简化了数组和Collection集合的遍历
弊端：目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。
import java.util.ArrayList;
import java.util.Collection;
public class test002 {
public static void main(String[] args) {
int[]arr = {1,2,3,4,5,6};
for (int x = 0;xc = new ArrayList();
c.add("hello ");
c.add("world ");
c.add("java ");
c.add("javaee ");
for (String s :c){
System.out.print(s);
}
c = null;
if(c!=null){
for (String s :c){
System.out.print(s);
}
}
}
} 输出结果：
123456
123456
hello haha heihei
hello world java javaee得出：增强for是用来替代迭代器的
增强for练习之List集合存储自定义对象并遍历：
public class Student {
private String name;
private int age;
public Student(){}
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;
}
}import java.util.ArrayList;
import java.util.List;
public class test002 {
public static void main(String[] args) {
Listlist = new ArrayList();
Student s1 = new Student("林青霞",30);
Student s2 = new Student("张曼玉",35);
Student s3 = new Student("王祖贤",33);
list.add(s1);
list.add(s2);
list.add(s3);
for (Student s :list){
System.out.println(s.getName()+"---"+s.getAge());
}
}
} 输出结果：
林青霞---30
张曼玉---35
王祖贤---33
常见数据结构之栈和队列：
数据结构：数据的组织方式
栈：先进后出
举例：子弹夹，先放入的最后才打出来
队列：先进先出
举例：买票
图解：
数组：存储同一种数据类型的多个元素的容器，有索引
链表：由一个链子把多个结点连接起来的数据
结点：由数组和地址组成
List集合子类特点及ArrayList集合存储字符串并遍历：
List：
ArrayList：底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删慢
ArrayList存储字符并遍历：
A.迭代器
B.普通for
C.增强for
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class test003 {
public static void main(String[] args) {
Listlist = new ArrayList();
list.add("hello");
list.add("world");
list.add("javaee");
Iteratorit = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
for (int x = 0;x 练习2：
ArrayList集合存储自定义对象并遍历
提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
三种方式遍历
迭代器
普通for
增强for
其中的Student类如前一样，不附再给
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class test003 {
public static void main(String[] args) {
Listlist = new ArrayList();
Student s1 = new Student("林青霞",33);
Student s2 = new Student("张曼玉",30);
Student s3 = new Student("王祖贤",35);
list.add(s1);
list.add(s2);
list.add(s3);
Iteratorit = list.iterator();
while (it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+"---"+s.getAge());
}
for (int x = 0;x