JavaSE知识-15(Colletion集合)

Posted 2021-03-11 20145232

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE知识-15(Colletion集合)相关的知识，希望对你有一定的参考价值。

对象数组的概述和使用
集合的由来及集合继承体系图
Collection集合的基本功能测试
集合的遍历之集合转数组遍历
Collection集合的带All功能测试
集合的遍历之迭代器遍历
List集合的特有功能概述和测试
List集合存储学生对象并遍历
并发修改异常产生的原因及解决方案
ListIterator
Vector的特有功能
数据结构之数组和链表
List的三个子类的特点

对象数组的概述和使用

案例演示
- 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。

创建学生类:
Alt Shift s c 空参构造
Alt Shift s o 有参构造
Alt Shift s r get/set方法
Alt Shift s s 重写toString方法

package com.hwh.collection;
import com.hwh.bean.Student;
public class Demo1_Array {
	public static void main(String[] args) {
			Student[] arr = new Student[5];             //创建引用数据类型数组

			arr[0] = new Student("张三", 23);				//创建一个学生对象,存储在数组的第一个位置
			arr[1] = new Student("李四", 24);				//创建一个学生对象,存储在数组的第二个位置
			arr[2] = new Student("王五", 25);				//创建一个学生对象,存储在数组的第三个位置
			
			for (int i=0; i<arr.length; i++)
			System.out.println(arr[i]);
	}
}

集合的由来及集合继承体系图

A:集合的由来
- 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
B:数组和集合的区别
- 区别1 :
  - 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  - 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
- 区别2:
  - 数组长度是固定的,不能自动增长
  - 集合的长度的是可变的,可以根据元素的增加而增长
C:数组和集合什么时候用
* 1,如果元素个数是固定的推荐用数组
* 2,如果元素个数不是固定的推荐用集合
D:集合继承体系图

Collection集合的基本功能测试

A:案例演示

基本功能演示

boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()

B:注意:
collectionXxx.java使用了未经检查或不安全的操作.
注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
java编译器认为该程序存在安全隐患
温馨提示:这不是编译失败,所以先不用理会

不想出现黄色标记,需要Ctrl+1,原始类型不检查

package com.hwh.collection;
import java.util.ArrayList;
import java.util.Collection;
import com.hwh.bean.Student;
		@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_Collection {
		/**
			add方法如果是List集合一直都返回true,因为List集合中是可以存储重复元素的
			如果是Set集合当存储重复元素的时候,就会返回false
			
			ArrayList的父类的父类重写toString方法,所以在打印对象的引用的时候,输出的结果不是Object类中toString的结果
		 */
		public static void main(String[] args) {
			demo1();
			Collection c = new ArrayList();		
			c.add("a");
			c.add("b");
			c.add("c");
			c.add("d");
			
			//c.remove("b");										//删除指定元素
			//System.out.println(c);//[a, c, d]
			
			//c.clear();	//清空集合
			//System.out.println(c);//[]
			
			//System.out.println(c.contains("b"));		//true			//判断是否包含
			//System.out.println(c.isEmpty());         //false
			System.out.println(c.size()); //4							//获取元素的个数
			System.out.println(c);//[a, b, c, d]
		}
		
		public static void demo1() {
			Collection c = new ArrayList();						//父类引用指向子类对象
			boolean b1 = c.add("abc");
			boolean b2 = c.add(true);							//自动装箱new Boolean(true);
			boolean b3 = c.add(100);
			boolean b4 = c.add(new Student("张三",23));			
			boolean b5 = c.add("abc");
			
			System.out.println(b1);//true
			System.out.println(b2);//true
			System.out.println(b3);//true
			System.out.println(b4);//true
			System.out.println(b5);//true
			
			System.out.println(c.toString());//[abc, true, 100, Student [Name=张三, Age=23], abc]
		}
	}

集合的遍历之集合转数组遍历

A:集合的遍历
- 其实就是依次获取集合中的每一个元素。
B:案例演示
- 把集合转成数组，可以实现集合的遍历
- toArray()

package com.hwh.collection;
import java.util.ArrayList;
import java.util.Collection;
import com.hwh.bean.Student;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo3_Collection {
	public static void main(String[] args) {
		//demo1();
		Collection c = new ArrayList();
		c.add(new Student("张三", 23));				//Object obj = new Student("张三",23);
		c.add(new Student("李四", 24));
		c.add(new Student("王五", 25));
		c.add(new Student("赵六", 26));
		
		Object[] arr = c.toArray();					//将集合转换成数组
		for (int i = 0; i < arr.length; i++) {
			//System.out.println(arr[i]);
			Student s = (Student)arr[i];			//向下转型, 强转成Student, 才有get方法
			System.out.println(s.getName() + "..." + s.getAge());
		}
	}

	public static void demo1() {
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		Object[] arr = c.toArray();						//将集合转换成数组
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

运行结果为
张三...23
李四...24
王五...25
赵六...26

Collection集合的带All功能测试

案例演示
带All的功能演示
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)

package com.hwh.collection;
import java.util.ArrayList;
import java.util.Collection;
	@SuppressWarnings({ "rawtypes", "unused", "unchecked" })
public class Demo4_CollectionAll {
			public static void main(String[] args) {
				demo1();
				//demo2();
				//demo3();
				Collection c1 = new ArrayList();
				c1.add("a");
				c1.add("b");
				c1.add("c");
				c1.add("d");
				
				Collection c2 = new ArrayList();
				c2.add("a");
				c2.add("b");
				c2.add("c");
				c2.add("d");
				c2.add("e");
				c2.add("f");
				
				//取交集,如果调用的集合改变就返回true,如果调用的集合不变就返回false
				boolean b = c1.retainAll(c2);					//取交集
				System.out.println(b); //false
				System.out.println(c1); //[a, b, c, d]
			}

			public static void demo3() {
				Collection c1 = new ArrayList();
				c1.add("a");
				c1.add("b");
				c1.add("c");
				c1.add("d");
				
				Collection c2 = new ArrayList();
				c2.add("a");
				c2.add("b");
				c2.add("z");
				
				boolean b = c1.containsAll(c2);				//判断调用的集合是否包含传入的集合
				System.out.println(b); //false
			}

			public static void demo2() {
				Collection c1 = new ArrayList();
				c1.add("a");
				c1.add("b");
				c1.add("c");
				c1.add("d");
				
				Collection c2 = new ArrayList();
				c2.add("a");
				c2.add("b");
				c2.add("z");
				
				boolean b = c1.removeAll(c2);					//删除的是交集
				System.out.println(b); //true
				System.out.println(c1);  //[c, d]
				
			}

			public static void demo1() {
				Collection c1 = new ArrayList();
				c1.add("a");
				c1.add("b");
				c1.add("c");
				c1.add("d");
				
				Collection c2 = new ArrayList();			//alt + shift + r改名
				c2.add("a");
				c2.add("b");
				c2.add("c");
				c2.add("d");
				
				//c1.addAll(c2);							//将c2中的每一个元素添加到c1中
				//System.out.println(c1);//[a, b, c, d, a, b, c, d]
				c1.add(c2);									//将c2看成一个对象添加到c1中
				System.out.println(c1); //[a, b, c, d, [a, b, c, d]]
			}
		}

集合的遍历之迭代器遍历

A:迭代器概述
- 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)

package com.hwh.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import com.hwh.bean.Student;
		@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo5_Iterator {
		public static void main(String[] args) {
			//demo1();
			Collection c = new ArrayList();
			c.add(new Student("张三", 23));				//Object obj = new Student("张三",23);
			c.add(new Student("李四", 24));
			c.add(new Student("王五", 25));
			c.add(new Student("赵六", 26));
			
			//获取迭代器
			Iterator it = c.iterator();
			while(it.hasNext()) {
				//System.out.println(it.next());
				Student s = (Student)it.next();			//向下转型
				System.out.println(s.getName() + "..." + s.getAge());
			}
		
		}

		public static void demo1() {
			Collection c = new ArrayList();
			c.add("a");
			c.add("b");
			c.add("c");
			c.add("d");
			
			//对集合中的元素迭代(遍历)
			Iterator it = c.iterator();					//获取迭代器
			boolean b1 = it.hasNext();					//判断集合中是否有元素,有就返回true
			Object obj1 = it.next();
			System.out.println(b1);//true
			System.out.println(obj1);//a
			
			boolean b2 = it.hasNext();					//判断集合中是否有元素,有就返回true
			Object obj2 = it.next();
			System.out.println(b2);//true
			System.out.println(obj2);//b
			
			while(it.hasNext()) {
				System.out.println(it.next());//c d
			}
		}
	}

List集合的特有功能概述和测试

A:List集合的特有功能概述
- void add(int index,E element)
- E remove(int index)
- E get(int index)
- E set(int index,E element)

package com.hwh.list;
import java.util.ArrayList;
import java.util.List;
		@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo1_List {
		public static void main(String[] args) {
			demo1();
			//demo2();
			//demo3();
			//demo4();
			List list = new ArrayList();
			list.add("a");
			list.add("b");
			list.add("c");
			list.add("d");
			
			list.set(1, "z");						//将指定位置的元素修改
			System.out.println(list);//[a, z, c, d]
		}

		public static void demo4() {
			List list = new ArrayList();
			list.add("a");
			list.add("b");
			list.add("c");
			list.add("d");
			
			Object obj1 = list.get(2);
			System.out.println(obj1);//c
			//通过索引遍历List集合
			for(int i = 0;i < list.size(); i++) {
				System.out.println(list.get(i));//a b c d
			}
		}

		public static void demo3() {
			List list = new ArrayList();
			list.add(111);
			list.add(222);
			list.add(333);
			
			list.remove(111);							//删除的时候不会自动装箱,把111当作索引
			System.out.println(list);// java.lang.IndexOutOfBoundsException
		}

		public static void demo2() {
			List list = new ArrayList();
			list.add("a");
			list.add("b");
			list.add("c");
			list.add("d");
			
			Object obj = list.remove(1);				//通过索引删除元素,将被删除的元素返回
			System.out.println(obj);//b
			System.out.println(list);//[a, c, d]
		}

		public static void demo1() {
			List list = new ArrayList();
			list.add("a");
			list.add("b");
			list.add("c");
			list.add("d");
			list.add(4, "f");						//index<=size并且index>=0都不会报异常
			//list.add(1,"e");
			//list.add(10, "z");					//java.lang.IndexOutOfBoundsException,当存储时使用不存在的索引时
			System.out.println(list); //[a, b, c, d, f]
		}
	}

List集合存储学生对象并遍历

A:案例演示
- 通过size()和get()方法结合使用遍历。

package com.hwh.list;
import java.util.ArrayList;
import java.util.List;
import com.hwh.bean.Student;
	@SuppressWarnings({ "unchecked", "rawtypes" })
public class Demo2_List {
	public static void main(String[] args) {
				List list = new ArrayList();
				list.add(new Student("张三", 23));					//Object obj = new Student("张三",23);
				list.add(new Student("李四", 24));
				list.add(new Student("王五", 25));
				list.add(new Student("赵六", 26));
				
				for(int i = 0; i < list.size(); i++) {
					//System.out.println(list.get(i));	 			//通过索引获取每一个元素
					Student s = (Student)list.get(i);
					System.out.println(s.getName() + "..." + s.getAge());
				}
			}
		}

并发修改异常产生的原因及解决方案

案例演示
- 需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

package com.hwh.list;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo3_List {
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {

				List list = new ArrayList();
				list.add("a");									//Object obj = new String();
				list.add("b");
				list.add("world");
				list.add("c");
				list.add("d");
				list.add("e");
				
				/*Iterator it = list.iterator();					//获取迭代器
				while(it.hasNext()) {							//判断集合中是否有元素
					String str = (String)it.next();				//向下转型
					if("world".equals(str)) {
						list.add("javaee");						//遍历的同时在增加元素,抛出并发修改异常ConcurrentModificationException
					}
				}*/
				
				ListIterator lit = list.listIterator();			//获取迭代器(List集合特有的)
				while(lit.hasNext()) {
					String str = (String)lit.next();			//向下转型
					if("world".equals(str)) {
						//list.add("javaee");						//遍历的同时在增加元素,并发修改ConcurrentModificationException
						lit.add("javaee");
					}
				}
				System.out.println(list);
			}
		}

ListIterator

boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous();返回上一个元素

package com.hwh.list;

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

public class Demo4_ListIterator {

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {

			List list = new ArrayList();
			list.add("a");									//Object obj = new String();
			list.add("b");
			list.add("world");
			list.add("c");
			list.add("d");
			list.add("e");
			
			ListIterator lit = list.listIterator();			//获取迭代器
			while(lit.hasNext()) {
				System.out.println(lit.next()); //a b world c d e			//获取元素并将指针向后移动
			}
			
			System.out.println("-----------------");
			
			while(lit.hasPrevious()) {
				System.out.println(lit.previous()); //e d c world b a		//获取元素并将指针向前移动
			}
		}
	}

Vector的特有功能

Vector类概述
Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()

package com.hwh.list;
import java.util.Enumeration;
import java.util.Vector;
public class Demo5_Vector {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {

				Vector v = new Vector();
				v.addElement("a");
				v.addElement("b");
				v.addElement("c");
				v.addElement("d");
				
				Enumeration en = v.elements();					//获取枚举
				while(en.hasMoreElements()) {					//判断集合中是否有元素
					System.out.println(en.nextElement());		//获取集合中的元素
				}
			}
		}

数据结构之数组和链表

A:数组
- 查询快修改也快
- 增删慢
B:链表
- 查询慢,修改也慢
- 增删快

List的三个子类的特点

A:List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
Vector和ArrayList的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
共同点:都是数组实现的
ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的
B:List有三个儿子，我们到底使用谁呢?
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList

以上是关于JavaSE知识-15(Colletion集合)的主要内容，如果未能解决你的问题，请参考以下文章

Java基础_集合概述以及Colletion集合

JAVA常用集合框架用法详解基础篇一之Colletion接口

大数据必学Java基础（五十三）：Colletion接口

JavaSE高阶知识总结

JavaSE集合基础总览

JAVA-初步认识-常用对象API(集合框架-ListIterator接口)