欢迎访问悦橙教程（wld5.com），关注java教程。悦橙教程  java问答|  每日更新
页面导航 : > > 文章正文

黑马程序员：Java基础——List集合的分支，黑马java

来源： javaer 分享于  点击 28357 次 点评：175

黑马程序员：Java基础——List集合的分支，黑马java


------- Java EE培训、java培训、期待与您交流！ ----------

1.Vector中的枚举

枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举郁郁而终了。

Vector中的方法与List集合中的方法大都相似，而Enumeration枚举是Vector的特有方法。以下是Vector遍历的代码示例：

public class VectorDemo {
    public static void sop(Object obj){
    	System.out.println(obj);
    }
	
	public static void main(String[] args) {
		Vector vec = new Vector();
		vec.add("Java01");
		vec.add("Java02");
		vec.add("Java03");
		vec.add("Java04");
		
		
		for(Enumeration enu = vec.elements();enu.hasMoreElements();){
			sop(enu.nextElement());
		}
	}
}

运行结果可想而知：

Java01

Java02

Java03

Java04

然而Vector现在已经被ArrayList所替代，所以通常我们不使用Vector集合。

2.LinkedList

LinkedList的特有方法：
addFirst();
addLast();

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

removeFirst();
removeLast();
获取元素，会删除元素，如果集合没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法：
offerFirst();
offerLast();

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

获取元素，元素会被删除，如果集合没有元素，返回Null。

以下是示例代码，注意，NoSuchELementException我用try,catch方法抓掉了：

import java.util.LinkedList;
import java.util.NoSuchElementException;

public class LinkedListDemo {

	public static void sop(Object obj) {
		System.out.println(obj);
	}

	public static void main(String[] args) {
		for(int i=0;i<2;i++){
			if(i==0){
				method_6();		
			}else{
				method();
			}
		}
	}

	public static void method() {
		LinkedList lList = new LinkedList();

		lList.add("Java");
		lList.addFirst("Java01");
		lList.addLast("Java02");

		sop("--原有方法--");
		sop("添加后lList集合里有："+lList);

		for(int i=0;i<2;i++){
			if(i==0){
				sop("获取(get)第一个元素："+lList.getFirst());
				sop("获取(get)最后一个元素："+lList.getLast());
				sop("最后剩下："+lList);
				sop("");
			}else{
				sop("获取并移除(remove)第一个元素："+lList.removeFirst());
				sop("获取并移除(remove)最后一个元素："+lList.removeLast());
				sop("最后剩下："+lList);
				
				sop("最后这么搞：");
				sop("连续两次获取并移除(remove)第一个元素："+lList.removeFirst());
				try{
				    sop(lList.removeFirst());
				}catch(NoSuchElementException e){
					sop("这里NoSuchElementException异常抛出，我用try,catch抓了。");
				}
			}
		}
	}
	
	public static void method_6(){
		LinkedList lList = new LinkedList();
		int iNum = 100;
		sop("--1.6新方法--");
		lList.add(iNum);
		sop("offerFirst也可以这么玩："+lList.offerFirst("Java01"));
		lList.offerLast("Java02");
		sop("添加后lList集合里有："+lList);
		
		for(int i=0;i<2;i++){
			if(i==0){
				sop("获取(peek)第一个元素："+lList.peekFirst());
				sop("获取(peek)最后一个元素："+lList.peekLast());
				sop("最后剩下："+lList);
				sop("");
			}else{
				sop("获取并移除(poll)第一个元素："+lList.pollFirst());
				sop("获取并移除(poll)最后一个元素："+lList.pollLast());
				sop("最后剩下："+lList);
				
				sop("最后这么搞：");
				sop("连续两次获取并移除(poll)第一个元素："+lList.pollFirst());
				sop("输出："+lList.pollFirst());
				sop("========================================");
			}
		}
	}
}

输出结果如下：

我们针对LinkedList做个练习，要求如下：

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

堆栈：先进后出 如同一个杯子
队列：先进先出 FIFO(First in First out)如同一个水管

这里是源代码，需要注意的是，有些方法被分装：

public class LinkedListTest {
	public static void main(String[] args) {
		Method med = new Method();		
		Scanner scan = new Scanner(System.in);
		
		Method.sop("请输入要输入的字符串长度：");
		int iFor = scan.nextInt();
		Method.sop("请输入字符串：");
		for(int i=0;i<iFor;i++){
			med.add(scan.next());
		}
		Method.sop("请输入正反向(正向敲1，反向敲2)：");
		int iFlag = scan.nextInt();
		
		Method.sop("结果为：");
		med.result(iFlag);
	}
}

class Method{
	private LinkedList list;
	Method(){
		list=new LinkedList();
	}
	
	public void add(Object obj){
		list.addFirst(obj);
	}
	
	public Object getQueue(){
		return list.removeFirst();
	}
	
	public Object getStack(){
		return list.removeLast();
	}
	
	public Boolean isNull(){
		return list.isEmpty();
	}
	
	public void result(int iFlag){
    		while(!isNull()){
			if(iFlag==1){
				sop(getStack());
			}else{
				sop(getQueue());
			}
    		}
 	}
	
	public static void sop(Object obj){
    		System.out.println(obj);
   	}
}

以下是运行结果：

3.ArrayList

关于ArrayList呢，我们前面已经见过了，这里就直接做练习：

练习1：去除ArrayList集合中的重复元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListTest {

	public static void main(String[] args) {
		ArrayList aList = new ArrayList();
		aList.add("Java01");
		aList.add("Java02");
		aList.add("Java03");
		aList.add("Java01");
		aList.add("Java02");
		aList.add("Java01");
		
		sop(aList);
		aList = simpleElement(aList);
		sop(aList);
	}
	
	public static ArrayList simpleElement(ArrayList al){
		ArrayList newAl = new ArrayList();//new一个新的数组
		//进行遍历判断，并写入新的数组
		for(Iterator it = al.iterator();it.hasNext();){
			Object object = it.next();
			if(!newAl.contains(object)){
				newAl.add(object);
			}
		}
		return newAl;  //返回到主函数
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

运行结果为：

[Java01, Java02, Java03, Java01, Java02, Java01]

[Java01,Java02,Java03]

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

依照思路一步一步来，我们得到以下代码：

public class ArrayListPersonTest{
    public static void main(String[] args) {
    	
    	ArrayList aList = new ArrayList();
		
		
		aList.add(new Person("ZhangSan",17));
		aList.add(new Person("LiSi",21));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("ZhangSan",17));
		
		aList = simpleElement(aList);
		
		for(Iterator it = aList.iterator();it.hasNext();){
			Person p = (Person)it.next();   //it.next()是Object类，需要进行强转
			sop("姓名："+p.getsName()+"，年龄："+p.getiAge());  //调用get方法来获取包装内容
		}
	}
    
    public static void sop(Object obj){
    	System.out.println(obj);
    }
    
    public static ArrayList simpleElement(ArrayList aList){
    	//新建一个缓存数组来进行比较
    	ArrayList temp = new ArrayList();
    	
    	for(Iterator it = aList.iterator();it.hasNext();){
    		Object obj = it.next();
    		//判断缓存数组里面是否已经包含obj所含内容
    		if(!temp.contains(obj)){
    			temp.add(obj);
    		}
    	}
    	return temp;
    }
}

class Person{
	private String sName;
	private int iAge;
	
	Person(){}
	Person(String sName,int iAge){
		this.sName=sName;
		this.iAge=iAge;
	}
		
	public String getsName() {
		return sName;
	}
	public void setsName(String sName) {
		this.sName = sName;
	}
	public int getiAge() {
		return iAge;
	}
	public void setiAge(int iAge) {
		this.iAge = iAge;
	}
}

通过运行我们发现结果令人出乎意料——相同的项目并没有被删除，也就是说我们的去除重复是失败的。

这时，我们需要重写equals方法

以下是重写后的全部代码：

public class ArrayListPersonTest{
    public static void main(String[] args) {
    	
    	ArrayList aList = new ArrayList();
		
		
		aList.add(new Person("ZhangSan",17));
		aList.add(new Person("LiSi",21));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("ZhangSan",17));
		
		aList = simpleElement(aList);
		
		for(Iterator it = aList.iterator();it.hasNext();){
			Person p = (Person)it.next();   //it.next()是Object类，需要进行强转
			sop("姓名："+p.getsName()+"，年龄："+p.getiAge());  //调用get方法来获取包装内容
		}
	}
    
    public static void sop(Object obj){
    	System.out.println(obj);
    }
    
    public static ArrayList simpleElement(ArrayList aList){
    	//新建一个缓存数组来进行比较
    	ArrayList temp = new ArrayList();
    	
    	for(Iterator it = aList.iterator();it.hasNext();){
    		Object obj = it.next();
    		//判断缓存数组里面是否已经包含obj所含内容
    		if(!temp.contains(obj)){
    			temp.add(obj);
    		}
    	}
    	return temp;
    }
}

class Person{
	private String sName;
	private int iAge;
	
	Person(){}
	Person(String sName,int iAge){
		this.sName=sName;
		this.iAge=iAge;
	}
	
	//这里需要重写Object类中的equals方法
	public boolean equals(Object obj){
//java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例。
//instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
		if(!(obj instanceof Person)){   
			return false;
		}
		Person p = (Person)obj;
		//System.out.println(this.sName+"...."+p.sName);
		//调用String的equals对比
		return this.sName.equals(p.sName) && this.iAge==p.iAge;
	}
	
	public String getsName() {
		return sName;
	}
	public void setsName(String sName) {
		this.sName = sName;
	}
	public int getiAge() {
		return iAge;
	}
	public void setiAge(int iAge) {
		this.iAge = iAge;
	}
}

通过运行，我们发现重复的去掉了，这是为什么呢？

因为List集合判断元素是否相同（无论是contains还是remove），依据是元素的equals方法。而在我们重写之前，equals比的是Person的地址，因为Person是一个Object，每一个Person的地址都是new过的，地址值是不可能相同的。我们重写的目的就是要调用String的equals来比较其值是否相同。

我们把

System.out.println(this.sName+"...."+p.sName);

的注释取消掉。

结果为下图：


可以发现，值与值在挨个比较，直到找到相同的为止。



相关文章

    暂无相关文章
相关栏目：

相关文章

用户点评