java基础8

集合

集合类概述

为什么出现集合类：

我们学习的是面向对象的编程语言，面向对象的编程语言对事物的描述都是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储，而要存储多个对象，就不能是基本的变量了，应该是一个容器类型的变量，那么，哪些是容器类型的变量呢？

数组，StringBuilder

StringBuilder,它的结果是一个字符串，不一定满足我们的需求，所以我们只能选择数组了，而数组的长度固定，不能适应变化的需求，在这种情况下，Java就提供了集合类型供我们使用。由此可见，集合类的长度是可变的。

集合体系结构

单列(List)	单列(Set)	双列(Map)
可重复一致(ArrayList / LinkedList)	唯一不一致(HashSet)	Hashmap

collection

Collection:是单列集合的顶层接口。
Collection 表示一组对象，这些对象也称为collection的元素。
一些collection允许有重置的元素，而另一些则是无序的。
JDK不提供此接口的任何直接实现：它提供更具体的子接口（如Set和List）实现。
创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。因为这个类是最常用的集合类。

Collection<E>:
	<E>是一种特殊的数据类型，泛型。
	如何实现呢？
	在出现E的地方用引用数据类型替换即可。
	举例：Collection<String> ,Collection<Student>

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

public class CollectionDemo {
	public static void main(String[] args){
		//创建Collection对象
		Collection<String> c = new ArrayList<String>{};//多态的方式
		c.add("hello");
		c.add("world");
		c.add("java");
		//输出集合对象
		System.out.println(c);

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

迭代器

迭代器：是集合遍历的一种方式，依赖于集合而存在。

/*集合使用步骤
A:创建集合对象
Collection<String>c = new ArrayList<String>();
B:创建元素对象
String s = "hello";
C:把元素添加到集合
c.add(s);直接写成 c.add("hello");
D:遍历集合
a.通过集合对象获取迭代器对象
Iterator<String>it = c.iterator();
b:通过迭代器对象的hasNext()方法判断是否有元素
c.通过迭代器对象的next()方法获取元素并指向下一个位置
while(it.hasNext()){
	String s = it.next();
	System.out.println(s);
}
*/

需求：
Collection集合存储自定义对象并遍历
自定义一个学生类，给出成员变量name和age,遍历集合的时候，在控制台输出学生对象的成员变量的值。
学生类

public class Student {
	private String name;
	private int age;
	
	private 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;
	}
}

/*集合使用步骤
A:创建集合对象
B:创建元素对象
C:把元素添加到集合
public class  CollectionTest {
	public static void main(String[] args){
	//创建集合对象
	Collection<student> c = new ArrayList<Student>();
	//创建元素对象
	Student s1 = new Student("xxx",30);
	Student s2 = new Student("yyy",20);
	Student s3 = new Student("zzz",25);
	//把元素添加到集合
	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());
	}
}

List

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
 *List:有序的collection{也称序列}
 *此接口的用户可以对列表中每个元素的插入位置进行精确的控制。
 *用户可以根据元素的整数索引（在列高的位置）访问元素，并接受列表中的元素。
 *与set不同，列表通常允许重复的元素。
 *
 *List集合的特点：
 *A:有序（存储和取出元素的顺序一致）
 *B:存储的元素可以重复
 */
public class ListDemo {
	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();
			System.out.println(s);
		}
	}
} 

List集合特有成员方法
void add(int index, E element):在指定位置添加元素
E remove(int index):删除指定位置的元素
E get(int index):获取指定位置的元素
E set(int index, E element):修改指定位置的元素

List集合的普通for循环遍历

public class ListDemo3 {
	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++){
			//System.out.println(list.get(x));
			String s = list.get(x);
			System.out.println(s);
		}
	}
}

并发修改异常

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

/*
 *有一个集合：List<String> list = new ArrayList<String>();
 *里面有三个元素list.add("hello");list.add("world");list.add("java");
 *判断里面是否有"world"这个元素，如果有，就添加一个"javaee"元素
 */
public class ListIteratorDemo {
	public static void main(String[] args) {
		//创建集合对象
		List<String> list = new ArrayList<String>();
		//添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		//判断里面有没有"world"这个元素
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String s = it.next();
			if(s.equals("sorld")){
				list.add("javaee");
			}
		}
		System.out.println(list);
	}
}
/*ConcurrentModificationException:当方法检测到对象并发修改，但不允许这种修改时，会报错。
产生的原因：迭代器依赖集合而存在，在判断成功后，集合中添加了新的元素，而迭代器并不知情，所以就报错了。
迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合的元素。
如何解决呢？
A:迭代器遍历的时候，我们可以通过迭代器修改集合中的元素。添加的元素是跟在迭代的后面的。
B:集合遍历的时候，我可以通过集合对象修改集合中的元素。元素是在最后添加的。
*/
	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");
		}
	}

增强for

import java.util.ArrayList;
import java.util.List;
/*
*增强for:是for循环的一种
*for(元素的数据类型变量名：数组名或Collection集合对象名){
*	使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
*}
*好处：简化了数组和Collection集合的遍历
*弊端：目标不能为null,在遍历前先对目标进行不为null的判断
*/
public class ForDemo {
	public static void main(String[] args) {
		//定义一个int类型的数组
		int[] arr = {1, 2, 3, 4, 5};
		//普通for
		for(int x=0; x<arr.length; x++){
			System.out.println(arr[x]);	
		}
		System.out.println("---------");

		//增强for
		for(int x : arr){
			System.out.println(x);
		}
		System.out.println("---------");

		//定义一个String类型的数组
		String[] arrArray = {"hello","world", "java"};
		//增强for
		for(String s : strArray) {
			System.out.println(s);
		}
		System.out.println("---------");
		//创建集合对象
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		//增强for
		for(String s : list){
			System.out.println(s);
		}
		if(list != null){
			for(String s : list) {
				System.out.println(s);
			}
		}
		//报错说明增强for实际上是替代迭代器的
		for(String s : list) {
			if(s.equals("world")){
				list.add("javaee");
			}
		}
	}
}

数据结构

set

Map