Collection&List&Iterator

最新推荐文章于 2024-09-05 21:26:22 发布

CS_GaoMing

最新推荐文章于 2024-09-05 21:26:22 发布

阅读量200

点赞数

分类专栏： Java基础学习文章标签： Java

本文链接：https://blog.csdn.net/CS_GaoMing/article/details/83480103

版权

Java基础学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

集合类

描述：
Java是一种面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作。就必须把这多个对象进行存储。而要想存储多个对象，就必须是一个引用类型容器，这就是对象数组。

/* 导包强调问题*/
import java.util.Collection;
import java.util.Iterator;
import java.util.ArrayList;

数组和集合的区别
- 长度区别：数组的长度固定，集合长度可变。
- 内容不同：数组存储的是同一种类型的元素，而集合可以存储不同类型的元素。
- 数据类型：数组可以存储基本数据类型，也可以存储引用数据类型，集合只能存储引用类型。
- 数据结构：数据的存储方式。
Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。
- Collection的功能概述：
  1：添加功能
  boolean add(Object obj):添加一个元素
  boolean addAll(Collection c):添加一个集合的元素, 若有相同元素仍然添加。
  2：删除功能
  void clear():移除所有元素.
  boolean remove(Object o):移除一个元素.
  boolean removeAll(Collection c):移除一个集合的元素,交集。
  3:判断功能
  boolean contains(Object o)：判断集合中是否包含指定的元素。
  boolean containsAll(Collection c)：判断集合中是否包含指定的集合的所有元素。
  boolean isEmpty()：判断集合是否为空。
```
  boolean retainAll(Collection c):两个集合都有的元素假设有两个集合A，B。A对B做交集，最终的结果保存在A中，B不变。返回值表示的是A是否发生过改变。
```
  4:获取功能
  Iterator iterator()–迭代器，极为重要.
  List li = new ArrayList();
  Collection co = new ArrayList();
```
  Itetator it = li.iterator();

  while(it.hasNext()){
  	animal a = (animal)it.next();
  	System.out.println(a);// 显示a的信息，通过@override toString()方法实现。
  }
```
  5:长度功能
  int size():元素的个数，List接口的特有方法，不被Collection所具有。
```
  /* for example*/
  Collection c = new ArrayList();//本质上不是Collection的，是重写的。
  c.add("hello");
  c.add("world");			
  System.out.println("size:"+c.size());		
  System.out.println("c:" + c);

  result:	
  size:2
  c:[hello, world]		
```
  6:交集功能
  boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
  7：把集合转换为数组
  Object[] toArray()；
Collection的继承体系
- PS：ListIterator是Iterator的子接口，具有更加详尽的成员方法.
```
/*for example*/
E previous();	//E = elem，表示元素。
boolean hasPrevious();
```

Collection的遍历

方式一：通过转为具体的类型，再利用for结构遍历。
方式的关键在于掌握转型：
Object[] objs = c.toArray(); //转Collection->Object.
String s = (String) objs[x]; //元素：Object->String.

/*for example*/
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();

		// 添加元素
		c.add("hello"); // Object obj = "hello"; 向上转型，Object为超类。
		c.add("world");		

		// 遍历
		// Object[] toArray():把集合转成数组，可以实现集合的遍历
		Object[] objs = c.toArray();
		for (int x = 0; x < objs.length; x++) {
			System.out.println(objs[x]);	//实现是通过toString方法实现的。

			// 我知道元素是字符串，我在获取到元素的的同时，还想知道元素的长度。
			// System.out.println(objs[x] + "---" + objs[x].length());
			// 上面的实现不了，原因是Object中没有length()方法
			// 我们要想使用字符串的方法，就必须把元素还原成字符串。
			//本身为String数据类型，所以可以向下转型。
			String s = (String) objs[x];
			System.out.println(s + "---" + s.length());
		}
	}

方式二：通过迭代器Iterator实现。

public static void main(String[] args) {			
		Collection c = new ArrayList();			
		c.add("hello");
		c.add("world");		

		// Iterator iterator():迭代器，集合的专用遍历方式
		Iterator it = c.iterator(); // 实际返回的是子类对象，这里是多态.

		while (it.hasNext()) {
			//不能通过it.next()拼接，因为迭代器会迭下去，所以需创建一个中间接受变量。
			String s = (String) it.next();
			System.out.println(“s:" + s + "s.length()" + s.length());
		}
	}

迭代器Iterator
- 获取集合元素的主要方式。
- 依赖于集合而存在。
- ListInterator解决Iterator：Concurrent modification exception：Iterator->ListIterator 。
- 结合迭代器的集合实现遍历集合。

/*for example*/
	public static void main(String[] args) {
		Collection c = new ArrayList();
		
		Student s1 = new Student("Tom", 22);
		Student s2 = new Student("John", 23);
		Student s3 = new Student("Mark", 24);
		
		c.add(s1);
		c.add(s2);
		c.add(s3);

		Iterator it = c.iterator();
		while (it.hasNext()) {
			Student s = (Student) it.next();
			System.out.println(s.getName() + " : " + s.getAge());
		}

List集合

描述：有序的Collection，也是一个接口，与Collection几乎一致。

特有遍历依赖于特有函数：get()和size()函数。

  ```
  	/*for example*/
  	List list = new ArrayList();
  	
  	list.add("hello");
  	list.add("world");
  	
  	Iterator it = list.iterator();
  	while(it.hasNext()){
  		String s = (String)it.next();
  		System.out.println(s);
  	}
  	System.out.println("********this is the dividing line********");
  	for(int x = 0; x < list.size(); ++x){
  		String s = (String)list.get();
  		System.out.println(s);
  	}
  	
  ```

ListIterator特殊性
- 可以逆向迭代，previous()；但是需要先顺序迭代，以及逆向迭代的判断hasPrevious()。可能以后对位置字符串长度的指定倒数第几个位置进行追加有一定的用处。
Concurrentmodificationexception：
解决方法如下：

public static void main(String[] args) {		
		List list = new ArrayList();
		
		list.add("hello");
		list.add("world");

		 //方式1：使用其子接口ListIterator。
		 ListIterator lit = list.listIterator();
		 while (lit.hasNext()) {
		 	String s = (String) lit.next();
		 	if ("world".equals(s))
				 lit.add("javaee");
		 }

		//方式2：集合遍历元素，集合修改元素(普通for)
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			if ("world".equals(s)) {
				list.add("TestCc");
			}
		}

List的子类
描述：底层本质为数组，子类与StringBUuffer与StringBuilder之间的关系。
- ArrayList，对比于StringBuilder数据结构为数组，应该是准确表达为顺序表，查询快，增删慢，线程不安全，效率低高。相对于链表…
- Vector，对比于StringBuffer，数据结构为数组，顺序表，查询快，增删慢，线程安全，效率低。
- LinkedList，底层链表结构，查询慢，增删快，线程不安全，效率高。
- 使用：
  - 默认使用ArrayList。
  - 查询多-ArrayList。
  - 增删多-LinkedList.