对collection的理解

集合（容器）和数组的区别

• 长度

  • 数组长度固定
  • 集合长度可变

• 内容

  • 数组存储同一类型元素
  • 集合存储不同类型元素

• 元素类型

  • 数组可以存基本类型，也可以存引用类型
  • 集合只可以存引用类型

继承体系

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()： 判断集合是否为空

4. 获取功能

​ Iterator iterator()(重点)

5. 长度功能

   int size(): 元素的个数

面试题：数组没有length()方法,有length属性。 字符串有length()方法。集合没有length()方法，有size()方法。

6. 交集功能

​ boolean retainAll(Collection c): 两个集合都有的元素,元素到了第一个集合中，返回的boolean是如果

​ 有相同的元素赋值给第一个集合为真

7. 把集合转换为数组

​ Object[] toArray() （引申：数组转集合）

示例

//创建集合的对象
		Collection collection = new ArrayList();
		//添加一个元素
		collection.add(1);
		collection.add("张三");  
	System.out.println(collection.add("张三"));  //直接输出为true，用来判断是否添加了值，无意义。
		System.out.println(collection);
		
		Collection collection2 = new ArrayList<>();
		collection2.add(789);
		collection2.add("李四");
		//移除一个元素
		//collection2.remove(789);
		//移除所有元素
		//collection2.clear();
		//添加一个集合元素
		collection.addAll(collection2);
		System.out.println(collection);
		//移除一个集合元素
		collection.retainAll(collection2);
		System.out.println(collection);
		//判断集合中是否包含指定的元素
		collection.contains(1);
		//判断集合中是否包含指定的集合元素(是一个还是所有)
		collection.containsAll(collection2);
		//判断集合是否为空
		collection.isEmpty();
		//长度
		System.out.println(collection.size());
		//交集
		System.out.println(collection.retainAll(collection2));
		System.out.println(collection);
		//集合转换为数组
		Object object = collection.toArray();
		//数组转换为集合
		int []a = {8};
		Arrays.asList(a);

迭代器（集合独有的遍历方式）

• Iterator iterator = collection.iterator();
• while
• for
• 不能多次使用next
• 原理

示例

//迭代器 获取集合迭代器
		Iterator iterator = collection.iterator();
		//判断下一行是否有值
		while (iterator.hasNext()) {
			//输出值 且光标挪到下一行
			System.out.println(iterator.next());
			}
			//如果有两个next会报错没有这样的元素异常(NoSuchElementException)
		for (; iterator.hasNext();) {
			System.out.println(iterator.next());
		}	

List

有序的集合，允许重复的元素存在

• List集合的特有功能：

  1. 添加功能

     void add(int index,Object element):在指定位置添加元素

  2. :获取功能

     Object get(int index):获取指定位置的元素

  3. 列表迭代器

     ListIterator listIterator()：List集合特有的迭代器

     • listiterator.next():返回下一行元素的值

     • listlterator.nextIndex()返回下一行元素的索引

     • listiterator.previouslndex()返回上一行元素的索引

  4. 删除功能

     Object remove(int index)：根据索引删除元素,返回被删除的元素

  5. 修改功能

     Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

示例

//List
		java.util.List list = new ArrayList();
		list.add(123);
		//添加功能  在指定位置添加元素
		list.add(0, 456);
			System.out.println(list);
		//获取功能  获取指定位置的元素 	
			  //list可以获取下标的元素，collection不能
			System.out.println(list.get(0));
		//删除功能
		list.remove(0);
		//修改功能
		list.set(0, 896);
//list 独有的迭代器
		ListIterator listIterator = list.listIterator();
		while ( listIterator.hasNext()) {
			System.out.println(listIterator.next());
			}

ConcurrentModificationException

并发修改异常

常见数据结构

• 数组：连续的存储空间----查询快，增删慢
• 链表：不连续，中间用箭头指向
• 队列: 先进先出
• 栈： 先进后出
• 堆：
• 树： 二叉树 数字小的左边放，数字大的右边放
• 图： 人物关系图Java的jvm运行机

子类

• ArrayList:

  底层数据结构是数组，查询快，增删慢。

  线程不安全，效率高。

• Vector:

  底层数据结构是数组，查询快，增删慢。

  线程安全，效率低。

• LinkedList:

  底层数据结构是链表，查询慢，增删快。

  线程不安全，效率高。

LinkedList独有方法 ：模拟栈操作1

泛型

foreach循环

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

​ 使用用变量即可，该变量就是元素

}

示例

Arraylist<Integer> list=new Arrayist<Integer>();
    for(Integer a:list){
            system.out.println(a);
       }
//循环前先判断是否为null

可变参数

定义方法的时候不知道该定义多少个参数

示例

修饰符 返回值类型 方法名(数据类型… 变量名){}
public static void main(String[] args) {
		System.out.println(sum(10,20,30,40));
	}
//可变参数：写一个方法实现很多数的相加
public static int sum(int...a) {
		int sum = 0;
		for (int i : a) {
			sum+=i;
		}
		System.out.println(a);
		return sum;
	}

注意：

• 这里的变量其实是一个数组
• 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

set

无序，不允许重复

• hashset
  • 不保证顺序
  • 底层数据结构是哈希表
• linkedhashset
  • 底层是哈希表加链表
  • 哈希表保证唯一性，链表保证有序
• treeset
  • 可以排序
    • 使用元素自然排序
    • 使用Comparator

示例

//HashSet	
HashSet<String> set=new HashSet<>();
		set.add("123");
		set.add("456");
		set.add("678");
		set.add("123");
		set.add("sggb");
		set.add("rth");
		System.out.println(set);

//LinkedHashSet
Set<String> set=new LinkedHashSet<>();
	set.add("123");
	set.add("456");
	set.add("fdsag");
	set.add("456");
	for(String s:set) {
		System.out.println(s);     //123,456,fdsag
	}

//TreeSet
Set<String> set=new TreeSet<String>();
	set.add("123");
	set.add("789");
	set.add("234");
	set.add("456");
	set.add("456");
	for(String s:set) {
		System.out.println(s);    //123,234,456,789
	}

//获取十个二十以内的随机数，不重复
	Random random=new Random();
	Set<Integer> set1=new LinkedHashSet<>();
	while(set1.size()<10) {
		int a=random.nextInt(20)+1;
	set1.add(a);
		}System.out.println(set1);
	}