Java--集合体系(ArrayList、Vector、LinkedList)

我会带着你远行 2023-10-17 11:12 79阅读 0赞

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

1、集合的由来

数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦

java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

2、数组和集合的区别

\[1\]区别1 :

数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值

集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象

\[2\]区别2:

数组长度是固定的,不能自动增长

集合的长度的是可变的,可以根据元素的增加而增长

3、数组和集合什么时候用

\[1\]如果元素个数是固定的推荐用数组

\[2\]如果元素个数不是固定的推荐用集合

![Center][]

二、集合的基本功能

boolean add(E e) 添加元素

boolean remove(Object o) 移除元素

void clear() 清除所有元素

boolean contains(Object o) 是否包含

boolean isEmpty() 是否为空

int size() 元素个数

三、带all功能

\[1\]boolean addAll(Collection c) 添加每一个元素

\[2\]boolean removeAll(Collection c) 删除交集

\[3\]boolean containsAll(Collection c) 判断集合是否包含集合

\[4\]boolean retainAll(Collection c)

四、集合的遍历之迭代器遍历

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

迭代器的使用

Collection c = new ArrayList();

c.add("a");

c.add("b");

Iterator it = c.iterator();//获取迭代器的引用

while(it.hasNext()) \{ //集合中的迭代方法(遍历)

System.out.println(it.next());

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /*
     *  collectionXxx.java使用了未经检查或不安全的操作.
    	注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
    	java编译器认为该程序存在安全隐患
     * */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public class CollectionMethod {
    	public static void main(String[] args) {
    		/*
    		 * 一、集合的由来及集合继承体系图
    		   1、集合的由来
    			   数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦
    			   java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少 
    		   2、数组和集合的区别
    			  [1]区别1 : 
    					数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
    					集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
    			  [2]区别2:
    					数组长度是固定的,不能自动增长
    					集合的长度的是可变的,可以根据元素的增加而增长
    		   3、数组和集合什么时候用
    			  [1]如果元素个数是固定的推荐用数组
    		      [2]如果元素个数不是固定的推荐用集合
    		   二、集合的基本功能
    		      boolean add(E e)    添加元素
    			  boolean remove(Object o)   移除元素
    			  void clear()       清除所有元素
    			  boolean contains(Object o)   是否包含
    			  boolean isEmpty()    是否为空
    			  int size()     元素个数
    		   三、带all功能
    		      [1]boolean addAll(Collection c)           添加每一个元素
    	 		  [2]boolean removeAll(Collection c)        删除交集
    			  [3]boolean containsAll(Collection c)      判断集合是否包含集合
    			  [4]boolean retainAll(Collection c)
    		   四、集合的遍历之迭代器遍历
                  集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历) 
                  迭代器的使用
                     Collection c = new ArrayList();
    			     c.add("a");
    			     c.add("b");
    			     Iterator it = c.iterator();			//获取迭代器的引用
    			     while(it.hasNext()) {				//集合中的迭代方法(遍历)
    				     System.out.println(it.next());
    			     }
    			  迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,
    			  那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器
    			  是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合
    			  体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
    		 * */
    		addMethod();
    		forCollection();//集合遍历
    		allMethod();
    		iterator();//迭代器
    	}
    
    	private static void iterator() {
    		System.out.println("===============迭代器==============");
    		Collection c = new ArrayList();
    		c.add(new Student("王二",12));        //Object s = new Student();
    		c.add(new Student("张三",13));     
    		c.add(new Student("李四",14));
    		c.add(new Student("赵五",15));
    		
    	    Iterator i = c.iterator();
    	    while(i.hasNext()){
    			Student s1 = (Student)i.next();
    			System.out.println(s1.getName() + "----" + s1.getAge());
    	    }
    	}
    
    	private static void allMethod() {
    		System.out.println("==============all方法===============");
    		Collection c1 = new ArrayList();
    		c1.add("a");
    		c1.add("b");
    		c1.add("c");
    		c1.add("d");
    		
    		//alt+shift+r 改名
    		Collection c2 = new ArrayList();
    		c2.add("a");
    		c2.add("b");
    		c2.add("c");
    		c2.add("z");
    		c1.addAll(c2);              //将c2中每一个元素添加到c1中
    //		c1.add(c2);    				//将c2作为一个对象添加到c1中
    		System.out.println(c1);
    //		c1.removeAll(c2);           //删除交集
    		System.out.println(c1);
    //		System.out.println(c1.containsAll(c2));
    		
    		//取交集，如果调用的集合改变就返回true,如果调用的集合不变就返回false
    		System.out.println(c1.retainAll(c2));
    		System.out.println(c1);
    	}
    
    	private static void forCollection() {
    		Collection c = new ArrayList();
    		c.add(new Student("王二",12));        //Object s = new Student();
    		c.add(new Student("张三",13));     
    		c.add(new Student("李四",14));
    		c.add(new Student("赵五",15));
    		Object[] arr = c.toArray();//将集合转为数组
    		for (int i = 0; i < arr.length; i++) {
    			System.out.println(arr[i]);
    			Student s1 = (Student)arr[i];
    			System.out.println(s1.getName() + "----" + s1.getAge());
    		}
    	}
    
    	private static void addMethod() {
    		Collection c = new ArrayList();  //父类对象指向子类引用
    		/*
    		 * add方法如果是List集合一直都返回true，因为list集合中可以存储重复元素
    		 * 如果是set集合当存储重复元素时，就会返回FALSE
    		 * ArrayList的父类的父类重写toString()方法，因此在打印对象的引用时，输出结果不是Object中toString结果
    		 * */
    		c.add(true);
    		c.add("new");
    		c.add(11);
    		c.add("new");
    		System.out.println(c);
    		System.out.println(c.size());
    	}
    }

![Center 1][]

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

void add(int index,E element)

E remove(int index)

E get(int index)

E set(int index,E element) 修改指定位置上元素

六、ListIterator

boolean hasNext()是否有下一个

boolean hasPrevious()是否有前一个

Object next()返回下一个元素

Object previous();返回上一个元素

七、Vector类特有功能

public void addElement(Eobj)

public E elementAt(int index)

public Enumeration elements()

八、数据结构之数组和链表

1、数组

查询快修改也快(通过索引直接找值)

增删慢(增：当前索引位置之后的所有元素向后移动，并在修改处修改值

删：当前索引位置之后的所有元素向前移动，且没有值位置覆盖为默认值)

2、链表

查询慢,修改也慢(先根据距离后面还是前面近来一个元素一个元素向前或者向后查找)

增删快(链表的重新断开和连接)

九、List的三个子类的特点

1、ArrayList:

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

线程不安全，效率高。

2、Vector:

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

线程安全，效率低。

Vector相对ArrayList查询慢(线程安全的)

Vector相对LinkedList增删慢(数组结构)

3、LinkedList:

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

线程不安全，效率高。

4、Vector和ArrayList的区别

Vector是线程安全的,效率低

ArrayList是线程不安全的,效率高

共同点:都是数组实现的

5、ArrayList和LinkedList的区别

ArrayList底层是数组结果,查询和修改快

LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢

共同点:都是线程不安全的

6、List三个子类，如何使用

查询多用ArrayList

增删多用LinkedList

如果都多ArrayList

import java.util.ArrayList;
    import java.util.Enumeration;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    import java.util.Vector;
    
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public class ListMethod {
    	public static void main(String[] args) {
    		/*
    		 * 一、List集合的特有功能概述和测试
    		       void add(int index,E element)
    	           E remove(int index)
    	           E get(int index)
    	           E set(int index,E element)       修改指定位置上元素
    	       二、ListIterator
    	       	   boolean hasNext()是否有下一个
    			   boolean hasPrevious()是否有前一个
    			   Object next()返回下一个元素
    			   Object previous();返回上一个元素
    		   三、Vector类特有功能
    			  public void addElement(E obj)
    			  public E elementAt(int index)
    			  public Enumeration elements()
    		   四、数据结构之数组和链表
    		     1、数组
    			    查询快修改也快(通过索引直接找值)
    				增删慢(增：当前索引位置之后的所有元素向后移动，并在修改处修改值
    				      删：当前索引位置之后的所有元素向前移动，且没有值位置覆盖为默认值)
    			 2、链表
    				查询慢,修改也慢(先根据距离后面还是前面近来一个元素一个元素向前或者向后查找)
    				增删快(链表的重新断开和连接)
    		   五、List的三个子类的特点
    		     1、ArrayList:
    					底层数据结构是数组，查询快，增删慢。
    					线程不安全，效率高。
    			 2、Vector:
    					底层数据结构是数组，查询快，增删慢。
    					线程安全，效率低。
    					Vector相对ArrayList查询慢(线程安全的)
    					Vector相对LinkedList增删慢(数组结构)
    			 3、LinkedList:
    					底层数据结构是链表，查询慢，增删快。
    					线程不安全，效率高。
    		     4、Vector和ArrayList的区别
    					Vector是线程安全的,效率低
    					ArrayList是线程不安全的,效率高
    					共同点:都是数组实现的
    		     5、ArrayList和LinkedList的区别
    					ArrayList底层是数组结果,查询和修改快
    					LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
    					共同点:都是线程不安全的
    			 6、List三个子类，如何使用
    					查询多用ArrayList
    					增删多用LinkedList
    					如果都多ArrayList
    		 * */
    		initList();
    		forList();//循环遍历
    		exception();
    		listIterator();
    		
    		vector();
    	}
    
    	private static void vector() {
    		Vector v = new Vector();
    		v.add("abc");
    		v.add("123");
    		v.add("ckn");
    		Enumeration e = v.elements();
    		while(e.hasMoreElements()){
    			System.out.print(e.nextElement() + " ");
    		}
    	}
    
    	private static void listIterator() {
    		System.out.println("=========ListIterator===========");
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("w");
    		list.add("d");
    		list.add("e");
    		
    		ListIterator lit = list.listIterator();
    	    while(lit.hasNext()){
    	    		System.out.print(lit.next() + " ");
    	    }
    	    System.out.println("");
    	    //此处必须正向遍历一遍才能反向遍历
    	    while(lit.hasPrevious()){
        			System.out.print(lit.previous() + " ");
    	    }
    	    System.out.println();
    	}
    
    	private static void exception() {
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("w");
    		list.add("d");
    		list.add("e");
    		
    		/*Iterator it = list.iterator();
    		while(it.hasNext()) {
    			String str = (String)it.next();
    			if(str.equals("world")) {
    				list.add("javaee");	//遍历的同时在并发修改
    				//这里会抛出ConcurrentModificationException并发修改异常
    			}
    		}  修改如下：   */
    	    ListIterator lit = list.listIterator();
    	    while(lit.hasNext()){
    	    		String str = (String)lit.next();
    	    		if(str.equals("w")) {
    //	    			list.add("javaee");
    	    			lit.add("java");
    	    		}
    	    }
    	    System.out.println(list);
    	}
    
    	private static void initList() {
    		List l = new ArrayList();
    		l.add("a");
    		l.add("b");
    		l.add("c");
    		
    		l.add(3, "d");             //index <= size 
    		System.out.println(l);
    //		l.add(10, "e");			   //java.lang.IndexOutOfBoundsException索引越界异常
    		Object obj = l.remove(1);
    		System.out.println(obj);
    		System.out.println(l);
    		
    		System.out.println(l.get(1));
    		l.set(2, "g");
    		System.out.println(l);
    	}
    
    	private static void forList() {
    		System.out.println("==============List遍历对象=============");
    		List list = new ArrayList();
    		list.add(new Student("张三", 18));
    		list.add(new Student("李四", 18));
    		list.add(new Student("王五", 18));
    		list.add(new Student("赵六", 18));
    		
    		for(int i = 0; i < list.size(); i++) {   //list.size()
    			Student s = (Student)list.get(i);
    			System.out.println(s.getName() + "," + s.getAge());
    		}
    	}
    }

![Center 2][]

[Center]: https://img-blog.csdn.net/20170228152957468?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 1]: https://img-blog.csdn.net/20170228153054920?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 2]: https://img-blog.csdn.net/20170228153718695?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center