目录
目录
List集合子类特点及ArrayList集合存储字符串并遍历：
List集合子类特点及ArrayList集合存储字符串并遍历：
集合：
为什么出现集合类：
我们学习的是面向对象的编程语言，面向对象的编程语言对事物的描述都是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储，而要想存储多个对象，就不能是基本的变量了，应该是一个容器类型的变量。
容器类型的举例：
数组，StringBuilder
StringBuilder,它的结果是一个字符串，不一定满足我们的需求，所以我们只能选择数组了，而数组的长度固定，不能适应变化的需求，在这种情况下，Java就提供了集合类供我们使用。由此可见，集合的长度是可变的。
常用集合类体系结构图：
collection：
Collection:是单列集合的顶层接口。
Collection 表示一组对象，这些对象也称为 collection 的元素。
一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。
JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。
因为这个类是最常用的集合类。
ArrayList()
Collection<E>：
<E>:是一种特殊的数据类型，泛型。
在出现E的地方用引用数据类型替换即可。
举例：Collection<String>,Collection<Student>
import java.util.ArrayList;
import java.util.Collection;
public class Arraylist001 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();//多态的方式
//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<String> c = new ArrayList<String>();
//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<E> 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<String> c = new ArrayList<String>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//Iterator<E> iterator():返回在此 collection 的元素上进行迭代的迭代器。
//通过集合对象调用iterator()方法得到迭代器对象。
//Iterator:
// E next():返回迭代的下一个元素。
// boolean hasNext():如果仍有元素可以迭代，则返回 true。
Iterator<String>it = 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) {
//创建集合对象
Collection<Student>c = new ArrayList<Student>();
//创建元素对象
Student s1 = new Student("林青霞",30);
Student s2 = new Student("张曼玉",35);
Student s3 = new Student("王祖贤",33);
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合
Iterator<Student>it = 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) {
//创建集合对象
List<String>list = new ArrayList<String>();
//存储元素
list.add("hello");
list.add("world");
list.add("java");
list.add("world");
//遍历集合
Iterator<String>it = 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) {
//创建集合对象
List<String>list = new ArrayList<String>();
//存储元素
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) {
List<String>list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
for (int x = 0;x<list.size();x++){
String s = list.get(x);
System.out.println(s);
}
}
}输出结果：
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) {
List<Student>list = new ArrayList<Student>();
Student s = new Student("林青霞",33);
Student s1 = new Student("张曼玉",35);
Student s2 = new Student("王祖贤",30);
list.add(s);
list.add(s1);
list.add(s2);
Iterator<Student>it = list.iterator();
while (it.hasNext()){
Student s4 = it.next();
System.out.println(s4.getName()+"---"+s4.getAge());
}
System.out.println("-------");
for (int x = 0;x<list.size();x++){
Student s4 = list.get(x);
System.out.println(s4.getName()+"---"+s4.getAge());
}
}
}输出结果：
林青霞---33
张曼玉---35
王祖贤---30
-------
林青霞---33
张曼玉---35
王祖贤---30
List集合迭代器的特有功能：
ListIterator:
ListIterator<E> listIterator():返回此列表元素的列表迭代器
public interface ListIterator<E>extends Iterator<E>
特有功能：
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) {
List<String>list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
ListIterator<String>lis = 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<String> list = new ArrayList<String>();
里面有三个元素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<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
// Iterator<String>it = list.iterator();
// while (it.hasNext()){
// String s = it.next();
// if(s.equals("world")){
// list.add("javaee");
//ConcurrentModificationException并发修改异常
// }
// }
// ListIterator<String> lit = list.listIterator();
// while (lit.hasNext()) {
// String s = lit.next();
// if (s.equals("world")) {
// lit.add("javaee");
// }
// }
for (int x = 0;x<list.size();x++){
String s = list.get(x);
if(s.equals("world")){
list.add("javaee");
}
}
System.out.println(list);
}
}增强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;x<arr.length;x++){
System.out.print(arr[x]);
}
System.out.println("");
for (int x:arr){
System.out.print(x);
}
System.out.println("");
String[]arr1 = {"hello ","haha ","heihei "};
for (String s:arr1){
System.out.print(s);
}
System.out.println("");
Collection<String>c = new ArrayList<String>();
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) {
List<Student>list = new ArrayList<Student>();
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) {
List<String>list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("javaee");
Iterator<String>it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
for (int x = 0;x<list.size();x++){
System.out.println(list.get(x));
}
for (String s:list){
System.out.println(s);
}
}
}练习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) {
List<Student>list = new ArrayList<Student>();
Student s1 = new Student("林青霞",33);
Student s2 = new Student("张曼玉",30);
Student s3 = new Student("王祖贤",35);
list.add(s1);
list.add(s2);
list.add(s3);
Iterator<Student>it = list.iterator();
while (it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+"---"+s.getAge());
}
for (int x = 0;x<list.size();x++){
Student s = list.get(x);
System.out.println(s.getName()+"---"+s.getAge());
}
for (Student s:list){
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
3425
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
