JavaSE十一（集合,Collection,List）

文章目录

• 集合
• • 1 Collection
  • 2.List

集合

1 Collection

1.1 集合知识回顾

集合类的特点：提供一个种存储空间可变的存储模型，存储的数据容量可以随时发生改变

1.2 集合类体系结构

1.3Collection集合概述和使用

Collection集合概述

• 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
• JDK不提供此接口的任何直接实现，他提供更具体的子接口(如Set和List)实现

创建Collection集合的对象

• 多态的方式
• 具体的实现类ArrayList

/*
	创建Collection集合的对象
	多态的方式
	ArrayList()
 */
public class CollectionDemo01 {
	public static void main(String[] args) {
		//创建Collection对象
		Collection<String> c = new ArrayList<String>();
		//添加元素：boolean add (E e)
		c.add("Hello");
		c.add("World");
		c.add("java");
		//输出集合对象
		System.out.println(c);
	}
}
------------------结果
[Hello, World, java]

1.4 Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

1.5 Collection集合的遍历

Iterator:迭代器，集合的专用遍历方式

• Iterator iterator():返回此集合元素的迭代器，通过集合的iterator()方法得到
• 迭代器是用过集合的iterator()方法得到的，所以说我们说它是依赖于集合而存在的

Iterator中常用的方法

• E next():返回迭代中的下一个元素
• boolean hasNext()：如果迭代具有更多元素，则返回true

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {
	public static void main(String[] args) {
		//创建集合对象
		Collection<String> c = new ArrayList<String>();
		//添加元素
		c.add("Hello");
		c.add("World");
		c.add("hahah");

		//Iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
		Iterator<String> it = c.iterator();
		/*
			public Iterator<E> iterator() {
			return new Itr();

			private class Itr implements Iterator<E> {
			....
			//NoSuchElementException表示被请求的元素不存在
		 */
		/*System.out.println(it.next());
		System.out.println(it.next());
		System.out.println(it.next());
		System.out.println(it.next());*/

		//boolean hasNext():如果迭代具有更多元素，则返回true
		/*if (it.hasNext()){
			System.out.println(it.next());
		}
		if (it.hasNext()){
			System.out.println(it.next());
		}
		if (it.hasNext()){
			System.out.println(it.next());
		}
		if (it.hasNext()){
			System.out.println(it.next());
		}*/

		//用while循环改进判断
		while (it.hasNext()){
//			System.out.println(it.next());
			String s = it.next();
			System.out.println(s);
		}
	}
}

1.6 集合的使用步骤

1.7 案例 Collection集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：

1. 定义学生类
2. 创建Collection集合对象
3. 创建学生对象
4. 把学生对象添加到集合
5. 遍历集合（迭代器方式）

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
		1. 定义学生类
		2. 创建Collection集合对象
		3. 创建学生对象
		4. 把学生对象添加到集合
		5. 遍历集合（迭代器方式）
 */
public class CollectionDemo {
	public static void main(String[] args) {
		//创建Collection集合对象
		Collection<Student> c = new ArrayList<Student>();
		//创建学生对象
		Student s1 = new Student("张三",11);
		Student s2 = new Student("张私",15);
		Student s3 = new Student("张五",13);

		//把学生对象添加到集合
		c.add(s1);
		c.add(s2);
		c.add(s3);

		//遍历集合
		//创建迭代器对象
		Iterator<Student> it = c.iterator();
		//使用while 迭代器遍历
		while (it.hasNext()){
			Student s = it.next();
			System.out.println(s.getName()+","+s.getAge());
		}
	}
}

2.List

2.1List集合概述和特点

List集合概述

• 有序集合（也称为序列），用户可以精确的控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
• 与Set集合不同，列表通常允许重复的元素

List集合特点

• 有序：存储和取出的元素顺序一致
• 可重复：存储的元素可以重复

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo01 {
	public static void main(String[] args) {
		//创建集合对象
		List<String> list = new ArrayList<String>();
		//添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("hello");//可以重复

		//输出集合对象
		//System.out.println(list);

		//使用迭代器的方式遍历
		Iterator<String> it = list.iterator();
		while (it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}
	}
}
-----------
hello
world
java
hello

2.2 List集合特有方法

方法名	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

import java.util.ArrayList;
import java.util.List;

public class ListDemo02 {
	public static void main(String[] args) {
		//创建集合对象
		List<String> list = new ArrayList<String>();

		//向集合中添加元素
		list.add("hello");
		list.add("world");
		list.add("final");

		//void add(int index,E element)
		//list.add(1,"haha");
		//list.add(11,"aa");//IndexOutOfBoundsException

		//E remove(int index) 返回被删除的元素
		//System.out.println(list.remove(1));

		//E set(int index,E element)
		//System.out.println(list.set(1,"hah"));

		//E get(int index)返回指定索引处的元素
		//System.out.println(list.get(2));

		//遍历集合
		for (int i=0;i<list.size();i++){
			String s = list.get(i);
			System.out.println(s);
		}
		//输出集合对象
//		System.out.println(list);
	}
}

案例：LIst集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台 遍历集合

思路：

1. 定义学生类
2. 创建List集合对象
3. 创建学生对象
4. 把学生对象添加到集合
5. 遍历集合（迭代器方式，for循环）

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo {
	public static void main(String[] args) {
		//创建List集合对象
		List<Student> list = new ArrayList<Student>();

		//创建学生对象
		Student s1 = new Student("张曼玉",14);
		Student s2 = new Student("林青霞",33);
		Student s3 = new Student("邱淑贞",18);

		//把学生对象添加到集合
		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循环
		for (int i=0;i<list.size();i++){
			Student ss = list.get(i);
			System.out.println(ss.getName()+","+ss.getAge()+"岁");
		}
	}
}

2.3并发修改异常

并发修改异常

• ConcurrentModificationExpection

产生原因

• 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期值改值和实际值改值不一致

解决方案

• 用for循环遍历，然后用集合对象做对应的操作即可下面的列表迭代器中的void add方法可以将指定的元素插入列表

2.4 ListIterator

ListIterator: 列表迭代器

• 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
• 用于允许程序员沿任一方向遍历列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中的常用方法

• E next() : 返回迭代中的下一个元素

• boolean hasNext() : 如果迭代具有更多元素，则返回true

• E previous() ：返回列表中的上一个元素

• boolean hasPrevious() : 如果此列表迭代器存在相反方向遍历列表时具有更多元素，则返回true

• void add(E e ) : 将指定的元素插入列表

  ListIterator lit = list.listIterator();
  whiel(lit.hasNext()){
  String s = lit.next();
  if(s.equals(“world”)){
  lit.add(“hello”);//这边是注意下
  }
  }

2.5 增强for

增强for : 简化数组和Collection集合的遍历

• 实现Iterable接口的类允许其对象成为增强型for语句的目标
• 它是JDK5之后出现的，其内部原理的一Iterator迭代器

增强for的格式

• 格式：

for(元素数据的类型 变量名 : 数组或者Collection集合){

​ //在此处使用变量即可，改变量就是元素

}

• 范例

int arr[] = {1,3,55,3};
for(int i : arr){
sout(i);
}

public class ForDemo {
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		for (int a : arr){
			System.out.println(a);
		}

		System.out.println("-----------");

		String[] str = {"haha","hello","world"};
		for (String s : str){
			System.out.println(s);
		}

		System.out.println("---------");

		List<String> list = new ArrayList<>();
		list.add("hello");
		list.add("hello");
		list.add("hello");
		for (String l : list){
			System.out.println(l);
		}

		System.out.println("--------");
		//内部原理是一个Iterator迭代器，以下测试会抛出并发异常ConcurrentModificationException
		for (String i :list){
			if (i.equals("hello")){
				list.add("javaee");
			}
		}
	}
}
------------运行结果
1
2
3
4
5
-----------
haha
hello
world
---------
hello
hello
hello
--------
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.ListTest3.ForDemo.main(ForDemo.java:32)

案例：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：

1. 创建学生类
2. 创建集合对象
3. 创建学生对象
4. 将学生对象添加到集合当中
5. 遍历集合
   1. 迭代器：集合特有的遍历方式
   2. 普通for：带有索引的遍历方式
   3. 增强for：最方便的遍历方式

public class ListDemo {
	public static void main(String[] args) {
		//1.创建集合对象
		List<Student> list = new ArrayList<>();
		//2.创建学生对象
		Student s1 = new Student("狗一",1);
		Student s2 = new Student("狗二",14);
		Student s3 = new Student("狗三",1);
		//3.将学生对象添加到集合当中
		list.add(s1);
		list.add(s2);
		list.add(s3);
		//4.遍历集合
		//迭代器遍历，集合特有的遍历方式
		Iterator<Student> it = list.iterator();
		while (it.hasNext()){
			Student s = it.next();
			System.out.println(s.getName()+",,,"+s.getAge());
		}
		System.out.println("----------------");

		//普通for遍历，带有索引的遍历方式
		for (int i=0;i<list.size();i++){
			Student student = list.get(i);
			System.out.println(student.getName()+",,"+student.getAge());
		}
		System.out.println("--------------");
		
		//增强for循环遍历，最方便的遍历方式
		for (Student ss : list){
			System.out.println(ss.getName()+","+ss.getAge()+"岁");
		}
	}
}
-----------运行结果
狗一,,,1
狗二,,,14
狗三,,,1
----------------
狗一,,1
狗二,,14
狗三,,1
--------------
狗一,1岁
狗二,14岁
狗三,1岁

2.6 数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合，通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

2.7 常见数据结构之栈

2.8 常见数据结构之队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D5NF3Nnv-1602772331167)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201015220740186.png)]

2.9 常见数据结构之数组

2.10 常见数据之链表

2.11 List集合子类特点

List集合常用子类 ：ArrayList， LinkedList

• ArrayList：底层结构是数组，查询快，增删慢
• LinkedList：底层结构是链表，查询慢，增删快

练习：

分别使用ArrayList和LinkedList完成存储字符串并遍历

2.12 LinkedList集合的特有功能