Collection--ArrayList-Vector-LinkedList基础内容与实践应用

最新推荐文章于 2024-08-20 23:36:56 发布

我会写bug233

最新推荐文章于 2024-08-20 23:36:56 发布

阅读量114

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/weixin_51055570/article/details/109274022

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Collection 集合

集合中常用的方法

Collection:某些集合可以存储从重复元素,某些集合不能重复元素!
			有些集合有序,有些集合无序(有序/无序:存储元素和取出元素是否一致!)
JDk不提供直接实现集合的接口
    但是提供了更为具体的子接口实现集合

Collection接口(单例集合的根接口)

List接口	Set接口
实现类:ArrayList LinkedList Vector	实现类HashSet TreeSet

集合的功能

基本功能:
    添加功能:
  	  boolean add(Object e) :将任何数据类型添加到集合中
    删除功能:
 	   void clear():暴力删除
  	  boolean remove(Object o):移出指定的元素
    判断功能
 	   boolean contains(Object o):判断是否包含指定的元素
 	   boolean isEmpty():判断集合是否为空,如果为空,则返回 true;
转换功能:
    Object[] toArray():将集合转换成对象数组
    Iterator iterator():Collection集合的迭代器(集合的遍历方式)

Collection高级功能

  	boolean  addAll(Collection c):添加一个集合中的所有元素
	boolean  removeAll(Collection c):
		问题:是删除一个算删除还是删除所有算删除?
			只要集合中有一个元素被包含,将这个元素从c1删除掉,则返回true!
	boolean  containsAll(Collection c):
		问题:包含一个算包含还是包含所有算包含?
			包含所有元素才算包含,返回true
	public boolean retainAll(Collection c) 取交集
		boolean的真实含义是什么: c1.retainlAll(c2):c1集合的元素是否发生变化!
			A集合对B集合取交集,将交集的元素保存到A集合,boolean表达的是A集合是否发生变化
			如果A集合没有变化的,返回结果false;如果A集合有变化,则返回true!

Collection遍历方式

1)Collection集合的方法 Object[] toArray
2)Collection集合的迭代器Iterator iterator() 
3)size()+Object get(int index):普通for循环
4)列表迭代器:ListIteraotr listiterator()
5)增强for

迭代器

Iteritor iterator(): Collection集合的专有遍历方式
返回值为 Iteritor(接口),需要返回该接口的子实现类接口
Object next():获取下一个元素
boolean hasNext() 判断当前迭代器中是否有下一个元素
如果存在,则返回true,不存在内返回false

泛型

格式 : <数据类型:引用>
            数组的定义格式
           	 String[] strArray = {"hello","123"};
            定义的时候就已经将类型限定了
	集合为了迎合数组的特点,在创建数组的时候,将类型定义了,来保证集合中的元素类型是一致的
	
	泛型的特点:
		将集合的类型在创建的时候就明确了
	好处:
		1)避免了强制类型转换
		2)将运行时期异常提前到了编译时期
		3)解决的黄色警告线问题
		4)提高了程序的安全性

泛型的使用

//1)普通使用
Collection<Student> c = new ArrayList<Student>() ;
//2)将泛型先定义在类上,方法形式参和泛型类型保持一致
//将泛型定义在类上
//定义一个工具类
public class ObjectTool<T> {
	//成员变量:定义Object类型
	private T obj ;
	//设置一个set方法:赋值
	public void set(T obj) {//"高圆圆": Object obj = new String("高圆圆")
		this.obj = obj ;
	}
	//get方法:获取信息
	public T get() {
		return obj ;
	}
}
//3)将泛型定义在方法上
public class ObjectTool{
	//将泛型定义在方法上了
	public <T> void show(T t) {
		System.out.println(t);
	}
}
//4）将泛型可以定义在接口上
//第一种情况:
//将泛型定义在接口上,子实现类明确了类型是什么
public class InterImpl implements Inter<String> {
	@Override
	public void inter(String t) {
		System.out.println("hello,"+t);
	}
}
//第二种情况:接口的子实现类不明确类型
public class InterImpl<T> implements Inter<T>{

	@Override
	public void inter(T t) {
		System.out.println("hello,"+t);
	}
	
}

泛型的高级通配符

<?> 当前Object类型/任意Java类型(自定义/jdk提供...)
<? extends E>:向下限定:E类型以及它的子类  
<? super E>:向上限定:E类型以及它的父类

List

List集合的特有功能

List集合的特有功能
	void add(int index,Object element):在指定位置出添加一个新的元素
	Object remove(int index):删除角标对应的元素
获取功能
	Object get(int index):获取指定位置处的元素
	int size():获取集合的范围
	Object set(int index,Object element):在指定位置使用当前元素element替换
	ListIteritor<E> listIterator():List集合的专有遍历方式:列表迭代器

ListIterator listIterator():List集合的专有遍历方式 :列表迭代器

ListIterator:列表迭代器
	ListIterator<E> listIterator()这个方法底层实现:是通过ArrayList里面的成员内部类
	ListItr extends Itr :实现的
正向遍历		
	boolean hasNext():判断是否有下一个元素
	Object next()   :获取下一个元素

逆向遍历
	boolean hasPrevious():判断是否有上一个元素
	Object previous():获取前一个元素

List集合案例实践 — 代码实践

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

/*
 * 需求:
 * 		使用集合(List)存储字符串元素,假设如果元素的内容有"world"元素,给
 * 集合中添加一个新的元素"javaee";
 * 
 * 按照上面的思路:
 * 	存在问题
 * java.util.ConcurrentModificationException:并发修改
 * 当迭代器遍历元素的时候,不能使用集合添加元素!(当前集合中添加一个新的元素,迭代器不知道!)
 * 
 * 解决方案:
 * 		1)要么使用迭代器遍历元素,使用迭代器添加元素!
 * 		2)要么集合遍历遍历元素,使用集合添加元素
 * 
 * 
 * 并发:指的是在一个时间点上同时发生!
 * 并行:指的是在一个时间段内同时发生!
 * 
 * */
public class ListTest2 {
	public static void main(String[] args) {

		//创建List集合,List集合的列表迭代器有添加功能
		List<String> c = new ArrayList<String>() ;
		//给添加元素
		c.add("hello") ;
		c.add("java") ;
		c.add("world") ;
		//方案1:获取列表迭代器
		//迭代器遍历,迭代器添加
		/*
		ListIterator<String> lit = c.listIterator() ;
		while(lit.hasNext()) {
			String s = lit.next() ;
			if("world".equals(s)) {
				lit.add("javaee");
			}
		}
		
		System.out.println(c);
		*/
		//方案2:集合遍历,集合添加
		//集合遍历:size()+get(int index):普通for循环
		for(int x = 0 ; x < c.size() ; x++) {
			String s = c.get(x) ;
			if("world".equals(s)) {
				//集合添加
				c.add("javaee") ;
			}
		}
		System.out.println(c);
	}
}

集合去重 – 案例

//旧集合中有重复元素，需要将集合去重，List集合存储自定义对象，去重重复的自定义对象）
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//定义学生类
public class Student {
	private String name;
	private int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		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;
	}
	//重写toString方法
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	// 重写hashCode方法
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	//重写equals方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//新建存储对象Student
		Student s1 = new Student("knight",21);
		Student s2 = new Student("369",20);
		Student s3 = new Student("knight",21);
		Student s4 = new Student("369",20);
		Student s5 = new Student("kasra",22);
		//创建List集合list并添加元素
		List<Student> list = new ArrayList<Student>();
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);
		//创建一个新的List集合list2
		List<Student> list2 = new ArrayList<Student>();
		//将list遍历
		Iterator<Student> it = list.iterator();
		while(it.hasNext()) {
			Student stu1 = it.next();
			//通过contains方法判断list2是否包含list
			if(!list2.contains(stu1)) {
				//不包含则添加
				list2.add(stu1);
			}
		}
		//遍历list2
		ListIterator<Student> lit = list2.listIterator();
		while(lit.hasNext()) {
			Student stu2 = lit.next();
			System.out.println(stu2.getName()+"----"+stu2.getAge());
		}
	}
}

选择排序思想去重–

	可以利用选择排序思想的特点
  		使用0角标对应的元素依次和后面角标对应的元素对比,如果后面元素重复了,则将
  该角标对应的元素从集合中删除,角标--
    for(int x = 0 ; x < list.size()-1 ; x ++) {
			for(int y = x +1 ; y < list.size() ; y ++) {
				//如果后面的和前面的元素相等,删除后面的元素
				if(list.get(y).equals(list.get(x))) {
					list.remove(y) ;
					y -- ;
				}
			}
		}

增强for遍历

/*
  增强for的格式:
  		for(数据类型 变量名 : 数组对象/集合对象(使用最多)){
  			输出变量名即可
  		}
  
  作用:是替代迭代器使用,简化遍历集合的书写格式!	
  注意事项:
  		1)增强for主要用在集合中,数组一般使用的时候普通for
  		2)前提条件:
  			要使用增强for循环的话,必须保证该集合不能为null,否则就会出现空指针
  					NullPointerException 
  
  		解决方案:
  				针对该对象非空判断即可!
  		if(list !=null) {
			for(String s: list) {
				System.out.println(s);
			}
		}
*/


/*
需求：
  		我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
  		但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
  		而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
 		就是这个样子的：ArrayList<ArrayList<Student>>
		
		自定义一个类：Student  属性姓名和年龄 然后给ArrayList<ArrayList<Student>>添加元素并遍历
*/
public class Test {
	public static void main(String[] args) {
		//新建存储对象Student
		Student s1 = new Student("yuyanjia",21);
		Student s2 = new Student("jackylove",20);
		Student s3 = new Student("knight",21);
		Student s4 = new Student("369",20);
		Student s5 = new Student("kasra",22);
		Student s6 = new Student("bsyy",28);
		//创建List集合并添加学生对象
		List<Student> list1 = new ArrayList<Student>();
		list1.add(s1);
		list1.add(s2);
		list1.add(s3);
		System.out.println("使用for增强循环遍历list1");
		for(Student stu1 : list1) {
			System.out.println(stu1.getName()+"---"+stu1.getAge());
		}
		//创建集合list2 添加学生对象
		List<Student> list2 = new ArrayList<Student>();
		list2.add(s4);
		list2.add(s5);
		list2.add(s6);
		System.out.println("----------------");
		System.out.println("使用for增强循环遍历list2");
		for(Student stu2 : list2) {
			System.out.println(stu2.getName()+"---"+stu2.getAge());
		}
		//创建list集合添加班级对象
		ArrayList<ArrayList<Student>> list3 = new ArrayList<ArrayList<Student>>();
		list3.add((ArrayList<Student>) list1);
		list3.add((ArrayList<Student>) list2);
		System.out.println("----------------");
		System.out.println("使用for增强循环遍历list3");
		for(ArrayList<Student> as : list3) {
				for(Student stu3 : as) {
					System.out.println(stu3.getName()+"-"+stu3.getAge());
				}
		}	
	}
}

list集合遍历的5种方式

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

/*
 *  需求:
 *  遍历List集合,存储自定义对象并遍历<Student>
 *  		5种方式
 * 
 * */
public class ForeachTest {
	
	public static void main(String[] args) {
		//创建一个List集合对象
		List<Student> list = new ArrayList<Student>() ;
        //new ArrayList<Student>() :jdk7以后:泛型推断,建议和前面集合泛型保持一致
		
		//创建几个学生对象
		Student s1 = new Student("文章", 35) ;
		Student s2 = new Student("马伊琍", 44) ;
		Student s3 = new Student("姚笛", 28) ;
		Student s4 = new Student("黄晓明", 35) ;
		Student s5 = new Student("邓超", 37) ;
		
		//添加
		list.add(s1) ;
		list.add(s2) ;
		list.add(s3) ;
		list.add(s4) ;
		list.add(s5) ;
		
		//方式1
		Object[]  objs = list.toArray() ;
		for(int x = 0 ; x < objs.length ; x ++) {
			
			Student s = (Student)objs[x] ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("---------------------------------");
		
		//方式2:Collection的迭代器
		Iterator<Student> it = list.iterator() ;
		while(it.hasNext()) {
			Student s = it.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		System.out.println("--------------------------------");
		
		//方式3:list get方法和size()集合
		for(int x = 0 ; x < list.size() ; x ++) {
			Student s = list.get(x) ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("-------------------------------");
		
		//方式4:列表迭代器
		ListIterator<Student> lit = list.listIterator() ;
		while(lit.hasNext()) {
			Student s = lit.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("-------------------------------");
		//增强for循环
		for(Student s : list) {
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

List三个子实现类的特点:

List三个子实现类的特点:
		ArrayList	
			底层数据结构是可变数组结构: 查询快,增删慢
			
			ArrayList底层可变数组: 
					ArrayList(int initialCapacity) :通过初始化容量构造ArrayList集合
					默认容量大小:capacity:10个
					ArrayList()---->通过初试容量大小判断是否构造一个新Object[] 数组对象
					结论:它的扩容机制 ---1.5倍扩容
			线程角度:
					线程不安全的类----不同步的----执行效率高!	
					单线程程序中,通常没有告诉使用什么集合的时候,优先采用的是ArrayList集合!	
		
		Vector :底层数据数组结构(对象数组)
				查询快,增删慢
			线程角度:
					线程安全的类 ---->同步的----->执行效率低
					多线程程序中要考虑安全问题,使用Vector
		
		LinkedList:
				底层数据结构:链接列表实现(链表)
				
				线程角度:
						线程不安全-----不同步---->执行效率高
					特有功能:
							可以模拟栈结构的:先进后出!

List集合的子实现类ArrayList应用----代码实践

import java.util.ArrayList;
/*
  ArrayList集合实现了List接口!
  	可以存储重复元素,存储和取出一致(有序的)!
  
  ArrayList:单线程程序中考虑执行效率,优先采用!
  应用场景:
  		网络聊天室  查看在线好友列表
  				   张三  (客户端 Socket)   ArrayList<Socket>
  				   李四
  				  
       在一些嵌套中使用
       HashMap<String,ArrayList<String>>  :Map集合嵌套ArrayList
     
       ArrayList<ArrayList<Student>> :ArrayList嵌套ArrayList
       
  	需求:
 		有很多个班级,每一个班级看成ArrayList<Student>,
  这多个班级组成大的集合:ArrayList<ArrayList<Student>>	
  给每一个班级中添加一些学生,遍历	ArrayList<ArrayList<Student>>
*/
public class Test {
	
	public static void main(String[] args) {
		
		//创建一个大的集合
		ArrayList<ArrayList<Student>>  bigList = 
				new ArrayList<ArrayList<Student>>() ;
		
		//三个子集合:ArrayList<Student>
		ArrayList<Student> list1 = new ArrayList<Student>() ;
		
		list1.add(new Student("刘备", 39)) ;
		list1.add(new Student("关羽", 35)) ;
		list1.add(new Student("张飞", 30)) ;
		
		//创建第二个子集合
		ArrayList<Student> list2 = new ArrayList<Student>() ;
		
		list2.add(new Student("曹操",44)) ;
		list2.add(new Student("蒋干",36)) ;
		list2.add(new Student("黄忠",45)) ;
		
		ArrayList<Student> list3 = new ArrayList<Student>() ;
		
		list3.add(new Student("宋江",50)) ;
		list3.add(new Student("林冲",30)) ;
		list3.add(new Student("鲁智深",45)) ;
		
		//将三个集合添加到大集合中
		bigList.add(list1) ;
		bigList.add(list2) ;
		bigList.add(list3) ;
		
		//增强for遍历集合
		//ArrayList<ArrayList<Student>>
		for(ArrayList<Student> list: bigList) {
			for(Student s :list) {
				System.out.println(s.getName()+"\t"+s.getAge());
			}
		}
	}
}

List集合的子实现类Vector应用 — 代码实践

import java.util.Enumeration;
import java.util.Vector;

/*
  Vector集合:
  		底层数组结构:查询快,增删慢
  		线程安全的---->同步的---->执行效率低!
  
  public boolean add(Object e):传统添加元素的方法
  特有功能:
  		public void add(int index, E element):插入元素
  		public Enumeration<Object> elements()--- 相当于:Iterator iterator()
  		该接口有两个方法
  		boolean hasMoreElements():判断是否有下一个元素-----> 相当于:boolean hasNext()
  		Object nextElement():获取一个元素               -----> 相当于:next()
  				
  		public Object elementAt(int index):
  						通过角标获取指定的元素---->相当于:Object get(int index)
  		elementAt()+size() :vector的普通for遍历方式
  Enumeration和Iterator功能是重复的
  应用场景:
  		IO流:合并流 SequenceInputStream 可以将多个文件内容读出来复制到指定文件中!
  					操作的输入流!
*/
public class VectorDemo {
	
	public static void main(String[] args) {
		//创建一个Vector集合对象
		Vector<String> v = new Vector<String>() ;
		
		//传统添加
		v.add("hello") ;
		v.add("world") ;
		v.add("Javaee") ;
		v.add(2, "JavaSE"); //插入
		//System.out.println(v);
		
		//遍历方式:使用Vector集合的特有功能
		//public Enumeration<Object> elements()	
		Enumeration<String> em = v.elements() ;//类似于Iterator
		//遍历
		//boolean hasMoreElements()
		//Object nextElement()
		while(em.hasMoreElements()) { //hasNext()
			String s = em.nextElement() ;//next()
			System.out.println(s);
		}
		System.out.println("-----------------------------");
		//public Object elementAt(int index)
		for(int x = 0 ; x < v.size() ; x ++) {
			String s = v.elementAt(x) ;//相当于: list的get(int index)方法 
			System.out.println(s);
		}
		System.out.println("-----------------------------");
		//增强for
		for(String s: v) {
			System.out.println(s);
		}
	}
}

List集合的子实现类LinkedList的应用 – 代码实践

import java.util.LinkedList;
/*
  LinkedList集合的特点:
  		底层数据结构是链接列表,查询慢,增删快
  		线程不安全的---不同的---->执行效率高!
  应用场景:
  		网站中	记录用户浏览过商品足迹  (Web技术:Cookie/Session)
  特有功能
  	添加
  		public void addFirst(Object e):将该元素添加到列表的开头!
  		public void addLast(Object e):将该元素添加到列表的末尾!
  		
  删除
  		public Object removeFirst():删除列表第一个
  		public Object removeLast():删除列表最后一个
  获取		
  		public Object getFirst():获取第一个
  		public Object getLast() :获取最后一个
 */
public class Test {
		
	public static void main(String[] args) {
		
		//创建LinkedList集合对象
		LinkedList<String> list = new LinkedList<String>();
		//压栈
		list.addFirst(");");
		list.addFirst("world");
		list.addFirst("hello");
		list.addFirst("System.out.println(");
		//非空判断
		while(!list.isEmpty()) {
			//弹栈
			String s = list.removeFirst();
			System.out.print(s);    //System.out.println(helloworld);
		}
	}
	
}

自定义栈集合,模拟压栈弹栈 — LinkedList的特有功能

import java.util.LinkedList;
public class MyStack {
	//link成员变量
	private LinkedList<String> link = null;
	//无参构造
	public MyStack(){
		link = new LinkedList<String>();
	}
	//add方法添加元素  进栈
	public void add(String s) {
		link.addFirst(s);
	}
	//get方法获取元素  弹栈
	public String get() {
		return link.removeFirst();
	}
	//非空判断
	public boolean isEmpty() {
		return link.isEmpty();//使用LinkedList里面的isEmpty()方法
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//1)方法一
		MyStack my = new MyStack();
		my.add("好");
		my.add("你");
		my.add("hello");
		while(!my.isEmpty()) {
			String s = my.get();
			System.out.print(s);
		}
    }
}