------- 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是线程同步的
在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());
}
}
}