1.ArrayList类概述

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

  线程不安全，效率高。


2.ArrayList案例

2.1存储字符串并遍历

package com;

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

public class ArrayListDemo {
	public static void main(String[] args) {
		//创建ArrayList对象
		ArrayList<String> list = new ArrayList<String>();
		
		//添加元素
		list.add("哈哈");
		list.add("呵呵");
		list.add("嘻嘻");
		list.add("笨笨");
		
		//遍历方式一 将ArrayList集合装换为Object[]
		Object[] obj = list.toArray();
		for (int i = 0; i < obj.length; i++) {
			String str = (String) obj[i];
			System.out.println(str);
		}
		
		System.out.println("----------------------");
		
		//遍历方式二 使用Iterator迭代器
		for(Iterator<String> iterator = list.iterator();iterator.hasNext();){
			String str = iterator.next();
			System.out.println(str);
		}
		
		System.out.println("-----------------------");
		
		//遍历方式三 使用ListIterator迭代器
		//顺向遍历
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String str = listIterator.next();
			System.out.println(str);
		}
		
		System.out.println("------------------------");
		
		//逆向遍历
		while(listIterator.hasPrevious()){
			String str = listIterator.previous();
			System.out.println(str);
		}
		
		System.out.println("------------------------");
		
		//遍历方式四 使用size()和get(int index)方法来实现遍历集合元素
		for (int i = 0; i < list.size(); i++) {
			String str = list.get(i);
			System.out.println(str);
		}
		
	}

}

2.2存储自定义对象并遍历

省略


3.Vector类

package com;

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

/**
 * Vector类特有功能
 * 		1.添加功能
 * 			public void addElement(E e)
 *      2.获取功能
 *          public E elementAt(int index)
 *      	public Enumeration elements() 
 *
 */
public class VectorDemo {
	public static void main(String[] args) {
		//创建集合对象
		Vector<String> v = new Vector<String>();
		
		//添加元素
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");
		
		//遍历
		for (int i = 0; i < v.size(); i++) {
			String str = v.elementAt(i);
			System.out.println(str);
		}
		
		System.out.println("------------------");
		
		for (Enumeration<String> enumeration = v.elements(); enumeration.hasMoreElements(); ) {
			String str = enumeration.nextElement();
			System.out.println(str);
		}
	}
}

hello

world

java

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

hello

world

java


4.LinkedList类概述

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

  线程不安全，效率高。


5.LinkedList的特有功能

package com;

import java.util.LinkedList;

/**
 * linkedList的特有功能
 * 		添加功能
 *      	public void addFirst(E e )
 *      	public void addLast(E e)
 *      获取功能
 *      	public E getFirst()
 *      	public E getLast()
 *      删除功能
 *      	public E removeFirst()
 *      	public E removeLast() 
 */
public class LinkedListDemo {
	public static void main(String[] args) {
		//创建集合对象
		LinkedList<String> list = new LinkedList<String>();
		
		//添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		
		System.out.println(list);//[hello, world, java]
		list.addFirst("javaee");
		System.out.println(list);//[javaee, hello, world, java]
		list.addLast("android");
		System.out.println(list);//[javaee, hello, world, java, android]
		
		System.out.println(list.getFirst());//javaee
		System.out.println(list.getLast());//android
		
		System.out.println(list.removeFirst());//javaee
		System.out.println(list);//[hello, world, java, android]
		
		System.out.println(list.removeLast());//android
		System.out.println(list);//[hello, world, java]
	}

}


6.练习

6.1去除集合中字符串的重复值

package com;

import java.util.ArrayList;
import java.util.Iterator;

/*
 * ArrayList
 * 		去除ArrayList集合中字符串重复值(字符串内容相同)
 * 
 * 分析：
 * 		1.创建集合对象
 * 		2.添加多个字符串元素(包含内容相同的)
 * 		3.创建新集合
 * 		4.遍历旧的集合，获取得到每一个元素
 * 		5.拿这个元素到新集合中去找，看有没有
 * 			有：不搭理它
 * 			没有：就添加到新集合中
 * 		6.遍历新集合
 * 
 * 
 */
public class ArrayTest {
	public static void main(String[] args) {
		//创建ArrayList集合对象
		ArrayList<String> listOld = new ArrayList<String>();
		
		//添加元素
		listOld.add("hello");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		
		//创建新集合对象
		ArrayList<String> listNew = new ArrayList<String>();
		
		//遍历旧集合，获得每一个元素
		for (int i = 0; i < listOld.size(); i++) {
			String strOld = listOld.get(i);
			//拿这个元素到新集合中去找
			if(!listNew.contains(strOld)){
				listNew.add(strOld);
			}
		}
		
		//遍历新集合
		for(Iterator<String> iterator = listNew.iterator();iterator.hasNext();){
			String strNew = iterator.next();
			System.out.println(strNew);
		}
	}

}

hello

world

java

package com;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 需求：ArrayList去除集合中字符串的重复值(字符串内容相同)
 * 要求：不能创建新的集合，只能作用于以前的集合
 */
public class ArrayListTest {
	public static void main(String[] args) {
		//创建ArrayList集合对象
		ArrayList<String> listOld = new ArrayList<String>();
		
		//添加元素
		listOld.add("hello");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		
		/**
		 * 由选择排序思想引入，我们就可以用选择排序思想来做这个题目
		 * 拿0索引的依次和后面的比较，如果后面有和0索引位置上的元素相同就移除
		 * 同理拿1索引的一次和后面的比较，如果后面有和1索引位置上的元素相同就移除
		 */
		for (int i = 0; i < listOld.size()-1; i++) {
			for (int j = i+1; j < listOld.size(); j++) {
				if(listOld.get(i).equals(listOld.get(j))){
					listOld.remove(j);
				}
			}
		}
		
		//遍历集合
		for(Iterator<String> iterator = listOld.iterator();iterator.hasNext();){
			String str = iterator.next();
			System.out.println(str);
		}
		
	}

}

hello

world

java

world

java

为什么会出现这种结果呢？我的思路应该是正确的呀，原因就在于比如你0索引上的元素是world，3索引和4索引上的元素也是world，当遍历的时候会判断3索引上的元素值和0索引上的是不是相等，是相等。ok，那就将3索引上的元素干掉，同时4索引以及5等等索引上的元素向前移动，但是之后我是0索引上的元素和4索引上的比较的，因为我3已近比较过了，但是很遗憾的是，这个时候的3索引上的恰恰也是world，哎，漏网之鱼啊，那怎么修改程序呢？看下面

package com;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 需求：ArrayList去除集合中字符串的重复值(字符串内容相同)
 * 要求：不能创建新的集合，只能作用于以前的集合
 */
public class ArrayListTest {
	public static void main(String[] args) {
		//创建ArrayList集合对象
		ArrayList<String> listOld = new ArrayList<String>();
		
		//添加元素
		listOld.add("hello");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		listOld.add("world");
		listOld.add("java");
		
		/**
		 * 由选择排序思想引入，我们就可以用选择排序思想来做这个题目
		 * 拿0索引的依次和后面的比较，如果后面有和0索引位置上的元素相同就移除
		 * 同理拿1索引的一次和后面的比较，如果后面有和1索引位置上的元素相同就移除
		 */
		for (int i = 0; i < listOld.size()-1; i++) {
			for (int j = i+1; j < listOld.size(); j++) {
				if(listOld.get(i).equals(listOld.get(j))){
					listOld.remove(j);
					j--;//添加j--，目的是让i上的元素和上一次被删除元素索引上的新元素比较
				}
			}
		}
		
		//遍历集合
		for(Iterator<String> iterator = listOld.iterator();iterator.hasNext();){
			String str = iterator.next();
			System.out.println(str);
		}
		
	}

}


6.2去除集合中自定义对象的重复值(对象的成员变量相同)

其实很简单，和上面的类似，只要在Student类中重写equals()方法即可。

package com;

public class Student {
	private String name;
	private int age;
	
	public Student(){}
	public Student(String name,int age){
		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;
	}
	
	@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;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	

}
package com;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 去除集合中自定义对象重复值(对象的成员变量值相同)
 */
public class ArrayListTest2 {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<Student> list = new ArrayList<Student>();
		
		//创建学生对象
		Student s1 = new Student("林志玲",28);
		Student s2 = new Student("凤姐",19);
		Student s3 = new Student("苍老师",18);
		Student s4 = new Student("芙蓉姐姐",80);
		Student s5 = new Student("林志玲",28);
		Student s6 = new Student("凤姐",28);
		Student s7 = new Student("林志玲",28);
		Student s8 = new Student("凤姐",19);
		Student s9 = new Student("林志玲",28);
		Student s10 = new Student("芙蓉姐姐",80);
		
		//添加元素值
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);
		list.add(s6);
		list.add(s7);
		list.add(s8);
		list.add(s9);
		list.add(s10);
		
		//通过选择排序思想
		for (int i = 0; i < list.size()-1; i++) {
			for(int j = i+1;j<list.size();j++){
				if(list.get(i).equals(list.get(j))){
					list.remove(j);
					j--;
				}
			}
		}
		
		//遍历集合
		for(Iterator<Student> iterator = list.iterator();iterator.hasNext();){
			Student stu = iterator.next();
			System.out.println(stu);
		}	
	}
}


7.使用LinkedList模拟数据结构--栈

package com;

import java.util.LinkedList;

/**
 * 使用LinkedList模拟数据结构--栈
 */
public class MyStack {
	private LinkedList<Object> list;
	
	public MyStack(){
		list = new LinkedList<Object>();
	}
	/**
	 * 增加元素
	 * @param obj
	 */
	public void add(Object obj){
		list.add(obj);
	}
	/**
	 * 获取元素
	 * @return
	 */
	public Object get(){
		return list.removeLast();//移除当前元素 并返回被删除的元素
	}
	/**
	 * 判断内部集合元素是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return list.isEmpty();
	}

}
package com;
/**
 * 自定义数据结构--栈测试
 */
public class MyStackTest {
	public static void main(String[] args) {
		MyStack stack = new MyStack();
		
		stack.add("hello");
		stack.add("world");
		stack.add("java");
		
		while(!stack.isEmpty()){
			System.out.println(stack.get());
		}
	}

}

java

world

hello