集合框架—01—List

最新推荐文章于 2025-04-24 23:10:09 发布

麦豆东东

最新推荐文章于 2025-04-24 23:10:09 发布

阅读量500

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/pb_love_java/article/details/8867563

/*
1，add方法的参数类型是Object。以便于接收任意类型对象
2，集合中存储的都是对象的引用（地址）

什么是迭代器呢？
其实就是集合的取出元素的方式。

*/
import java.util.*;
class CollectionDemo
{
	public static void main(String[] args)
	{
		method_get();
		
  }
  
  public static void method_get()
  {
  	ArrayList a1 = new ArrayList();
		
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");
		
//		Iterator it = a1.iterator();//获取迭代器，用于取出集合中的元素
//		while(it.hasNext())
//		{
//			sop(it.next());
//		}
		
		for(Iterator it = a1.iterator(); it.hasNext(); )
		{
			sop(it.next());	
		}
  }
  
  public static void method_2()
  {
  	ArrayList a1 = new ArrayList();
		
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");
		
		ArrayList a2 = new ArrayList();
		
		a2.add("java03");
		a2.add("java04");
		a2.add("java05");
		a2.add("java06");
		
		//a1.retainAll(a2);//去交集，a1中只会保留与a2相同的元素
		a1.removeAll(a2);
		
		sop(a1);
		sop(a2);
  }
  
  public static void base_method()
  {
  	//创建一个集合容器，使用Collection接口的子类。ArrayList
		ArrayList a1 = new ArrayList();
		
		//1，添加元素
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");
		
		//打印集合
		sop(a1);
		
		//3,删除元素
		//a1.remove("java02");
		//a1.clear();//清空集合
		
		//判断元素
		sop(a1.contains("java03"));
		sop(a1.isEmpty());
		
		//2，获取个数，集合长度。
		sop("size: "+a1.size());
		
		sop(a1);
  }
  
  public static void sop(Object obj)
  {
  	System.out.println(obj);	
  }
	
}

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

/*
Collection
	|--List:元素是有序的，元素可以重复，因为该集合体系有索引
	|		|--ArrayList:底层的数据结构使用的是数组结构，特点：查找速度快，增删慢，线程不同步
	|		|--LinkedList:底层使用的是链表数据结构，特点：增删快，查询慢
	|		|--Vector:底层是数组数据结构。线程同步，被ArrayList替代了。
	|--Set：元素是无序(存入和取出的顺序不一定一致)的，元素不可以重复。

List: 特有方法：凡是可以操作角标的方法都是该体系特有的方法。
增：add(index, element);
		addAll(index, Collection);

删: remove(index);

改: set(index, element);

查: get(index);
		subList(from, to);
		listIterator();

List集合体育的迭代器，ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的方法操作元素，可以
Iterator方法是有限的，只能对元素进行判断，取出，删除
的操作，如果想要其他的操作，如：添加、修改等，就需要
使用其子接口，ListIterator.

该接口只能通过List集合的ListIterator方法获取。
*/
import java.util.*;
class ListDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}
	public static void method()
	{
		ArrayList al = new ArrayList();
		
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		
		sop("原集合："+al);
		//在指定位置添加元素
		//al.add(1,"java09");
		
		//删除指定位置元素
		//al.remove(2);
		
		//修改元素
		al.set(2,"java007");
		
		//通过角标获取元素
		sop("get(1): "+al.get(1));
		
		sop(al);
		
		//获取所有元素
		for(int x=0; x<al.size(); x++)
		{
			System.out.println(al.get(x));	
		}
		
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			sop(it.next());	
		}
		
		//通过indexOf获取对象的位置
		sop("index= "+al.indexOf("java02"));
		
		List sub = al.subList(1,3);
		
		sop("sub= "+sub);
	}
	
	public static void main(String[] args)
	{
		//演示列表迭代器
		ArrayList al = new ArrayList();
		
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		ListIterator li = al.listIterator();
		
		while(li.hasNext())
		{
			Object obj = li.next();
			
			if(obj.equals("java02"))
				//li.add("java009");
				li.set("java006");	
		}
		while(li.hasPrevious())
		{
			sop(li.previous());	
		}
		
		sop("hasNext(): "+li.hasNext());
		sop("hasPrevious(): "+li.hasPrevious());
		
		sop(al);
		
		/*
		//在迭代过程中添加或者删除元素
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(obj.equals("java02"))
				//al.add("java008");
			it.remove();//将java02的引用从集合中删除了
				
			sop(obj);	
		}
		*/
		//sop(al);
		
	}	
}

/*
去除ArrayList集合中的重复元素。
*/
import java.util.*;

class ArrayListTest
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();
		
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java03");
		
		sop(al);
		
		sop(singleElement(al));
	}
	
	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		
		Iterator it = al.iterator();
		
		while(it.hasNext())
		{
			Object obj = it.next();
			
			if(!newAl.contains(obj))	
				newAl.add(obj);
		}
		return newAl;	
	}
	
}

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象，同姓名同年龄，视为同一个人。为重复元素。
思路：
1，对人描述，将数据封装进人对象
2，定义容器，将人存入
3，取出

List集合判断元素是否相同，依据的是元素的equals方法
*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;	
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;	
			
		Person p = (Person)obj;
		System.out.println(this.name+"..."+p.name);
		
		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;	
	}
	public int getAge()
	{
		return age;	
	}
}

class ArrayListTest2
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();
		al.add(new Person("lisi01",30));//al.add(Object obj); Object obj = new Person("lisi01",30); 类型提升，向上转型
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi03",33));
		al.add(new Person("lisi04",35));
		al.add(new Person("lisi04",35));
		
		al = singleElement(al);//调用方法
		
		Iterator it = al.iterator();
		
		while(it.hasNext())
		{
			Object obj = it.next();
			Person p = (Person)obj;//向下转型，可以简化为Perosn p = (Person)it.next()
			sop(p.getName()+"："+p.getAge());	
		}
	}
	
	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		
		Iterator it = al.iterator();
		
		while(it.hasNext())
		{
			Object obj = it.next();
			
			if(!newAl.contains(obj))	
				newAl.add(obj);
		}
		return newAl;	
	}
}

/*
LinkedList特有方法：
addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementsException

removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementsException

在JDK1.6出现了替代方法。
offerFirst();
offerLast();
添加元素

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
*/
import java.util.*;
class LinkedListDemo
{
	public static void main(String[] args)
	{
		LinkedList link = new LinkedList();
		
		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");
		
//		sop(link);
//		
//		sop(link.getFirst());
//		sop(link.getLast());
//		
//		sop(link.removeFirst());
//		sop(link.size());

			while(!link.isEmpty())
			{
				sop(link.removeLast());	
			}
			
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}
	
	
}

/*
使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出
队列：先进后出
*/
import java.util.*;
class DuiLie
{
	private LinkedList link;
	
	DuiLie()
	{
		link = new LinkedList();	
	}	
	
	public void myAdd(Object obj)
	{
		link.addFirst(obj);	
	}
	public Object myGet()
	{
		return link.removeLast();	
	}
	public boolean isNull()
	{
		return link.isEmpty();	
	}
}

class LinkedListTest
{
	public static void main(String[] args)
	{
		DuiLie dl = new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
		
		while(!dl.isNull())
		{
			System.out.println(dl.myGet());
		}
	}	
}

/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了
*/
import java.util.*;
class VectorDemo
{
	public static void main(String[] args)
	{
		Vector v = new Vector();
		
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		
		Enumeration en = v.elements();
		
		while(en.hasMoreElements())
		{
			System.out.println(en.nextElement());
		}
		
	}
}

个人总结：