黑马程序员——集合框架-List

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

 

List集合

List集合中元素是有顺序的, 元素师可以有重复的

遍历方式有3种

1.      Iterator()方法获得迭代器, 循环得到每个元素

2.      循环集合用get(index)方法得到每个元素

3.      listIterator()方法获得迭代器, 实现了双向遍历

List接口特有的方法

1.      add重载方法

声明: public void add(int index, E element)

作用: 在指定位置添加指定的元素

注意: 继承自Collection接口的add()方法返回值是boolean, 这个重载方法没有返回值

 

2.      addAll重载方法

声明: public boolean addAll(int index, Collection c)

作用: 将指定集合的全部元素添加到指定位置

        

3.      get方法

声明: public Object get(int index)

作用: 返回集合中指定位置的元素

        

4.      set方法

声明: public Object set(int index, Object obj)

作用: 用指定元素替换集合中指定位置的元素

        

5.      listIterator方法(重点)

声明: public ListIterator listIterator()

作用: 放回集合元素的迭代器

注意: 比较Iterator功能增强了, 可以双向遍历, 可以get, set

5.1  ListIterator接口

这个接口继承自Iterator接口

特有的方法:

public void add(Object obj)

将指定元素插入集合

public boolean hasPrevious()

判断迭代器中是否有前一个元素, 有返回true, 否则false

public Object previous()

返回迭代器前一个元素

public void set(Object obj)

将指定元素跟当前迭代元素替换

public int previousIndex()

返回迭代器后续调用元素的的索引

        

ArrayList类

1.      ArrayList特点

1)      底层是Object[]

2)      每一次添加元素数组会扩充50%

3)      它是线程不同步的

 

ArrayList代码示例

1.      ArrayList代码示例

import java.util.*;

class ArrListTest {
	public static void main(String[] args) {
		// 创建ArrayList对象
		ArrayList list = new ArrayList();
		// 向list中添加2个元素
		list.add('a');
		list.add('b');

		// 将'c'插入到list的第二个位置
		list.add(1, 'c');
		System.out.println(list); // 打印结果: [a, c, b]

		// 替换list中的第二个元素
		list.set(1, "d");
		System.out.println(list); // 打印结果: [a, d, b]

		// 获得指定元素
		Object obj = list.get(1);
		System.out.println(obj); // 打印结果: d

		// 将指定集合中的所有元素添加到当前集合指定位置
		ArrayList c = new ArrayList();
		c.add('e');
		c.add('f');
		c.add('g');
		list.add(1, c);
		System.out.println(list); // 打印结果: [a, [e, f, g], d, b]

		// 利用listIterator将指定元素替换
		ListIterator iter = list.listIterator();
		while (iter.hasNext()) {
			// 替换指定元素
			if (iter.next() == 'b') {
				iter.set('A');
			}
		}
		System.out.println(list); // 打印结果: [a, [e, f, g], d, A]

		// 利用listIterator往前一个遍历
		while (iter.hasPrevious()) {
			System.out.println(iter.previous());
		} // 打印结果:
		/*
		 * A d [e, f, g] a
		 */

	}
}

 

2.      ArrayList应用

书有书名, 作者, 单价三个属性, 将三本书存入集合并且按价格顺序排列

输入书名, 输出这本书的详细信息

import java.util.*;

class BookTest {
	public static void main(String[] args) {
		// 创建三个book对象
		Books book1 = new Books("一本书", "二牛", 17.5);
		Books book2 = new Books("两本书", "吴六", 28.3);
		Books book3 = new Books("武侠", "赵四", 14.9);

		// 创建一个ArrayList对象
		ArrayList list = new ArrayList();
		list.add(book1);
		list.add(book3);
		list.add(1, book2);

		priceSort(list);

		print(list);

		Scanner scan = new Scanner(System.in);

		Books books = new Books();

		System.out.println("请输入书名");
		String name = scan.nextLine();

		books.name = name;

		int index = list.indexOf(books);

		if (index != -1) {
			System.out.println(list.get(index));
		} else {
			System.out.println("查无此书");
		}

	}

	// 按照价格排序的方法
	public static void priceSort(ArrayList list) {
		// 循环比较价格排序
		for (int i = 0; i < list.size(); i++) {
			for (int j = i + 1; j < list.size(); j++) {
				// 定义两个变量用于比较价格
				Books ab = (Books) list.get(i);
				Books bb = (Books) list.get(j);

				double a = ab.price;
				double b = bb.price;
				// 如果当前价格比下一个大, 互换
				if (a > b) {
					Books temp = ab;
					list.set(i, bb);
					list.set(j, ab);
				}

			}
		}
	}

	// 打印方法
	public static void print(ArrayList list) {
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

// 定义一个书类
class Books {
	// 书有三个属性
	String name;
	String author;
	double price;

	Books() {
	}

	// 构造方法传入书的信息
	Books(String name, String author, double price) {
		this.name = name;
		this.author = author;
		this.price = price;
	}

	public String toString() {
		StringBuilder s = new StringBuilder();
		s.append("书名: " + this.name + "  ");
		s.append("作者: " + this.author + "  ");
		s.append("价格: " + this.price + "  ");
		return s.toString();
	}

	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}

		if (obj instanceof Books) {
			Books b = (Books) obj;
			return this.name.equals(b.name);
		}

		return false;
	}
}

 

LinkedList类

1.      LinkedList特点

1)      底层实现是双向链表, 每个元素都会存储前一个和后一个元素的地址

2)      它是线程同步的

 

2.      特性方法

1)      addFirst和addLast方法

声明: public void addFirst(Object obj)

作用: 将元素添加到集合中的第一个位置

声明: public void addLast(Object obj)

作用: 将元素添加到集合中的最后一个位置

注意: 在jdk1.6以后添加了替代的方法offerFirst和offerLast方法, 返回值是boolean

2)      getFirst和getLast方法

声明: public Object getFirst()

作用: 得到集合中的第一个元素

声明: public Object getLast()

作用: 得到集合中的最后一个元素

注意: 如果当前集合为空, 会出现NoSuchElementException异常, 在jdk1.6以后提供了替代的方法, peekFirst(), peekLast(), 如果集合回空, 它们会返回一个null

3)      removeFirst和removeLast方法

声明: public Object removeFirst()

作用: 删除并返回集合中的第一个元素

声明: public Object removeLast()

作用: 删除并返回集合中的最后一个元素

注意: 如果当前集合为空, 会出现NoSuchElementException异常, 在jdk1.6以后提供了替代的方法, pollFirst(), pollLast(), 如果集合回空, 它们会返回一个null

 

LinkedList代码示例

1.      模拟堆栈和序列

/*
	分析: 
			1. 堆栈是后进先出, addLast(), removLast()或者 addFirst(), removeFirst()
			2. 队列是先进先出, addLast(), removeFirst
	
*/
import java.util.*;

class Test {
	public static void main(String[] args) {
		System.out.println("模拟堆栈后进先出");
		method1();
		System.out.println("模拟队列先进先出");
		method2();
	}
	
	//StackTest
	public static void method1() {
		//创建LinkedList对象, 添加5个元素
		LinkedList list = new LinkedList();
		list.add('a');
		list.add('b');
		list.add('c');
		list.add('d');
		list.add('e');
		
		//创建一个模拟堆栈的对象
		StackTest stack = new StackTest();
		//获取打印
		stack.getElements(list);
	}
	
	//QueneTest
	public static void method2() {
		LinkedList list = new LinkedList();
		list.add('a');
		list.add('b');
		list.add('c');
		list.add('d');
		list.add('e');
		
		//创建一个模拟队列的对象
		QueneTest quene = new QueneTest();
		//获取打印
		quene.getElements(list);
	}
}

class StackTest {
	
	public void getElements(LinkedList list) {
		System.out.println(list);
		//如果集合大小大于0, 将最后一个元素删除并打印
		for (; list.size() > 0;) {
			System.out.println(list.removeLast());
		}
	}
}

class QueneTest {
	
	public void getElements(LinkedList list) {
		System.out.println(list);
		for (; list.size() > 0;) {
			//如果集合大小大于0, 将第一个元素删除并打印
			System.out.println(list.removeFirst());
		}
	}
}

 

Vector类

1.      Vector特点

Vector是早期应用集合时所使用的类

ArrayList是Vector的替代类

Vector没添加一个元素容量会增加100%

Vector是线程同步的

        

2.      Enumeration 枚举

在Vector类中有一个返回Enumeration类型对象的方法, 这个对象也是用于迭代用的, 它有两个方法

1)      声明: public boolean hasMoreElements()

作用: 判断是否有下一个元素

2)      声明: public Object nextElement()

作用: 返回迭代的下一个元素

 

      Vector类代码示例

Vector代码示例

import java.util.*;
class VectorTest {
	public static void main(String[] args) {
		//创建一个Vector对象
		Vector list = new Vector();
		//添加元素
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}

		System.out.println(list);					//打印结果: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

		//利用Enumeration遍历输出
		Enumeration enu = list.elements();
		while (enu.hasMoreElements()) {
			System.out.println(enu.nextElement());
		}	
	}
}

 

总结 List

1.      ArrayList

1)      底层是数组实现的

2)      每次添加元素容量会扩充50%

3)      查询元素的效率高, 但是删除修改元素的效率低

4)      线程不安全

2.      LinkedList

1)      底层是链表实现的

2)      删除修改元素效率高, 查询效率低

3)      线程不安全

3.      Vector

1)      底层是数组实现的

2)      每次添加元素容量会扩充100%

3)      效率低

4)      线程是安全的

 

List便利方式代码

以Vector为例的遍历代码

import java.util.*;
class ListLoop {
	public static void main(String[] args) {
		System.out.println("List...........");

		Vector list = new Vector();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
	
		System.out.println("方式一: iterator()");
		for (Iterator iter = list.iterator(); iter.hasNext(); ) {
			System.out.println(iter.next());
		}

		System.out.println("方式二: listIterator()");
		ListIterator iter = list.listIterator();
		for ( ; iter.hasNext(); ) {
			System.out.println(iter.next());
		}
		System.out.println("上面是从头找下一个, 下面是从尾找前一个");
		for ( ; iter.hasPrevious(); ) {
			System.out.println(iter.previous());
		}
		
		System.out.println("方式三: get(index)");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		System.out.println("Vector独有的便利方式");
		for (Enumeration enu = list.elements(); enu.hasMoreElements(); ) {
			System.out.println(enu.nextElement());
		}

	}
}