java编程基础_11

集合

集合是一个用来储存和获取数据的容器。集合的长度是可变的。

collection是单列集合的顶层接口。使用需要import。
import java.util.Collection;

创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。因为这个类是最常用的集合类。
Collection：
:是一种特殊的数据类型，泛型。在出现E的地方用引用数据类型替换即可，例：Collection,Collection
Collection c = new ArrayList(); //多态的方式

collection一些成员方法

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

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

public class CollectionDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		Collection<String> c = new ArrayList<String>();
		
		//boolean add(E e):添加元素
		//通过查看源码，我们知道ArrayList集合的add方法的返回值永远都是true
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//boolean remove(Object o):从集合中移除元素
		//System.out.println("remove:"+c.remove("world"));
		
		//void clear():清空集合中的元素
		//c.clear();
		
		//boolean contains(Object o):判断集合中是否存在指定的元素
		//System.out.println("contains:"+c.contains("world"));
		
		//boolean isEmpty():判断集合是否为空
		//System.out.println("isEmpty:"+c.isEmpty());
		
		//int size():集合的长度，也就是集合中元素的个数
		System.out.println("size:"+c.size());
		
		//输出集合对象
		System.out.println(c);
	} 
}

集合的Iterator接口

Iterator iterator():返回在此 collection 的元素上进行迭代的迭代器。
遍历集合：通过集合对象调用iterator()方法得到迭代器对象。

Iterator:

• E next():返回迭代的下一个元素。
• boolean hasNext():如果仍有元素可以迭代，则返回 true。

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

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

		//Iterator<E> iterator()
		Iterator<String> it = c.iterator();//返回的是迭代器接口的实现类的对象
		while(it.hasNext()){
			//System.out.println(it.next());
			String s = it.next();
			System.out.println(s);
		}
	}
}

List

List 为有序的collection。
此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与 set 不同，列表通常允许重复的元素。

特点：

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

构造方法：
List list = new ArrayList();

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.List;

public class ListDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		List<String> list = new ArrayList<String>();
		
		//使用继承Collection的添加功能
		list.add("hello");
		list.add("world");
		list.add("java");
		
		//void add(int index,E element):在指定位置添加元素
		//list.add(1, "javaee");
		
		//E remove(int index):删除指定位置的元素,返回被删除的元素
		//System.out.println("remove:"+list.remove(1));
		
		//E get(int index):获取指定位置的元素
		//System.out.println("get:"+list.get(1));
		
		//E set(int index,E element):修改指定位置的元素,返回被修改的元素
		//System.out.println("set:"+list.set(1, "javaee"));
		
		//输出集合对象
		System.out.println(list);
	}
}

ListIterator 列表迭代器

ListIterator:
ListIterator listIterator():返回此列表元素的列表迭代器
public interface ListIteratorextends Iterator

特有功能：

• E previous():返回列表中的前一个元素。
• boolean hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。但是要求先正向遍历，才能逆向遍历。

并发修改异常

并发修改异常：

• 迭代器遍历的时候，我可以通过迭代器修改集合中的元素。元素是跟在刚才迭代的元素后面的
• 集合遍历的时候，我可以通过集合对象修改集合中的元素。元素是在最后添加的

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<String> list = new ArrayList<String>();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		//迭代器遍历的时候，我可以通过迭代器修改集合中的元素
		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(元素的数据类型 变量名 : 数组名或者Collection集合对象名) {
使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
}
好处：简化了数组和Collection集合的遍历
弊端：目标不能为null。在遍历前先对目标进行不为null的判断。

ArrayList三种遍历方式

三种遍历方式：

• 迭代器
• 普通for
• 增强for

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

public class ArrayListTest {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<Student> array = new ArrayList<Student>();
		
		//创建元素对象
		Student s1 = new Student("林青霞",30);
		Student s2 = new Student("张曼玉",35);
		Student s3 = new Student("王祖贤",33);
		
		//把元素添加到集合
		array.add(s1);
		array.add(s2);
		array.add(s3);
		
		//迭代器
		Iterator<Student> it = array.iterator();
		while(it.hasNext()){
			Student s = it.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("----------------------");
		
		//普通for
		for(int x=0; x<array.size(); x++) {
			Student s = array.get(x);
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("----------------------");
		
		//增强for
		for(Student s : array) {
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

常见数据结构简介

数据结构：数据的组织方式

栈

存储时为压栈，取数为弹栈。遵循先入后出。像一个乒乓球筒，存放时，后一个将前一个压入更深一个位置。取出时，先取出的是最后存放的那一个。
存入数据：A，B，C； 取出数据：C，B，A；

队列

队列就像日常排队，遵循先入先出。
存入数据：A，B，C； 取出数据：A，B，C；

数组

存储同一种数据类型的多个元素的容器，有索引，访问获取元素。
需求1：获取某一个元素：根据索引取得
需求2：添加一个新元素：
A. 定义一个新数组，长度为之前数组长度+1
B. 遍历以前数组，得到每一个元素，添加元素之前的元素按照之前的索引储存到新数组中，添加新元素，将添加元素之后的元素按照索引+1的新索引储存到新数组中。
需求3：删除一个元素
A. 定义一个新数组，长度为之前数组长度-1
B. 遍历以前数组，得到每一个元素，被删除元素之前的元素按照之前的索引储存到新数组中，被删除元素不储存，之后的元素按照索引-1的新索引储存到新数组中。
特点：查询快，增删慢，
在内存中占用连续完整的空间。顺序储存，随机访问。

链表

由一个链子把多个结点连接起来的数据。结点由数组和地址组成。
需求1：获取某一个元素：从头开始一一找
需求2：添加一个新元素：
A. 把上一步的元素的Next地址用temp储存，把新添加元素的元素地址赋值给这个Next地址
B. temp储存的地址赋值给新添加元素的Next地址。
特点：查询慢，增删快。
在内存中随机储存，可以灵活运用碎片空间；随机储存，顺序访问。

List子类的特点：
ArrayList: 底层数据结构是数组，查询快，增删慢
LinkedList: 底层数据结构是链表，查询慢，增删快