集合List:
1.List集合是Collection集合的子接口，就直接可以使用迭代器遍历List也是一个抽象类，不能直接实例化
List集合：里面存储的元素是可以重复的，并且有序的（什么是有序的？）
里面的元素有序：指的是存储和取出一致
Set集合：不允许重复的（唯一的）
2.List集合的特有功能
void add(int index,Object element)：指定位置插入一个指定的元素
Object remove(int index)移除列表中指定位置的元素
Object get(int index)返回列表中指定位置的元素
Object set(int index,Object element)用指定元素替换列表中指定位置的元素
ListIterator listIterator()列表迭代器
代码：
import java.awt.List;
import java.util.ArrayList;
public class ListDemo2 {
public static void main(String[] args) {
ArrayList list=new ArrayList();
//添加元素
list.add("java");
list.add("hello");
list.add("world");
// void add(int index,Object element)：指定位置插入一个指定的元素
list.add(1 ,"hahh");
//Object remove(int index)移除列表中指定位置的元素
// System.out.println("remove:"+list.remove(2));
//Object get(int index)返回列表中指定位置的元素
// System.out.println("get:"+list.get(3));
//Object set(int index,Object element)用指定元素替换列表中指定位置的元素
System.out.println("set:"+list.set(2, "xixi"));
System.out.println(list);
}
}
3.List集合的另一种遍历方式：
通过get(int index)方法：获取指定索引处的元素
普通for循环遍历：size()和get()相结合
代码：
import java.util.ArrayList;
import java.util.List;
public class ListDemo3 {
public static void main(String[] args) {
//创建集合对象
List list=new ArrayList();
//给集合添加元素
list.add("hello");
list.add("world");
list.add("java");
for(int x=0;x<list.size();x++){
String s=(String) list.get(x);
System.out.println(s);
}
}
}
4. List集合专有的迭代遍历方式:
ListIterator listIterator():列表迭代器(单独讲)
返回的是ListIterator接口,而该接口又继承自Iterator接口,所以该列表迭代器中就有hasNext()/next()
boolean hasNext():正向遍历
Object next()
boolean hasPrevious():逆向遍历
Object previous();
注意:
如果想要逆向遍历,前提必须有正向遍历,逆向遍历一般不使用,没有意义!
代码：
public class ListIteratorDemo {
public static void main(String[] args) {
//创建List集合对象
List list = new ArrayList() ;
//给集合中添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//正向遍历:获取列表迭代器对象
ListIterator lit = list.listIterator() ;
while(lit.hasNext()){
String s = (String) lit.next() ;
System.out.println(s);
}
System.out.println("-----------------------");
while(lit.hasPrevious()){
String s = (String) lit.previous() ;
System.out.println(s);
}
}
}
5.java.util.ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
并发修改异常:
出现的异常的原因:当我们用迭代器去遍历的元素,最终添加元素用集合添加元素,迭代器并不知道,这个产生这个异常
这个异常的描述:当我们用迭代器去遍历元素,不能使用集合进行操作(添加或者删除或者修改)!
解决并发修改异常的方式:
1)迭代器遍历,迭代器添加元素
2)集合遍历,普通for循环遍历,集合进行添加
代码：
import java.awt.List;
import java.util.ArrayList;
import java.util.ListIterator;
/*
* 我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，
* 如果有，我就添加一个"javaee"元素，请写代码实现
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList list=new ArrayList();
//给集合添加元素
list.add("hello");
list.add("world");
list.add("java");
//方法一：使用迭代器遍历数组
//ListIterator lit = list.listIterator() ;
//while(lit.hasNext()){
// String s=(String) lit.next();
// if("world".equals(s)){
// lit.add("javaee");
// }
//
//System.out.println(list);
//}
//}
//方法二：使用集合遍历
for(int x=0;x<list.size();x++){
String s=(String)list.get(x);
if("world".equals(s)){
list.add("javaee");
}
}
System.out.println(list);
}
}
6.常见的数据结构
a.栈，先进后出 进栈的方式：压栈 ；出栈的方式：弹栈 举例：子弹的弹夹
b.队列：先进先出，从左到右进行存储
c.底层数据结构是数组：查询快，增删慢
d.链表：查询慢，增删快
7.面试题：
List接口下子实现类的特点
A:ArrayList集合:
ArrayList集合的底层数据结构是数组:查询快,增删慢, 从线程角度:线程不安全,不同步,效率高
B:Vector集合:
底层数据结构也是数组:查询快,增删慢,从线程角度:线程安全,同步,效率低!
C:LinkedList集合:
底层数据结构是链表:查询慢,增删快,从线程角度:线程不安全,不同步,效率高
8.List集合练习
1）ArrayList
练习一：
要求： 使用ArrayList存储自定义对象
代码：
package arraylist;
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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 String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
//测试类
package arraylist;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.concurrent.SynchronousQueue;
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList<Student> al=new ArrayList<Student>();
Student s1=new Student("小红",22);
Student s2=new Student("小名",27);
Student s3=new Student("小军",24);
al.add(s1);
al.add(s2);
al.add(s3);
//使用迭代器遍历
Iterator<Student> it=al.iterator();
while(it.hasNext()){
Student s= it.next();
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("----------");
//使用普通for遍历
for(int x=0;x<al.size();x++){
Student s= al.get(x);
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("-----------");
//使用列表迭代器
ListIterator<Student> li=al.listIterator();
while(li.hasNext()){
Student s = li.next();
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("-------------");
//使用增强for遍历
for(Student s:al){
System.out.println(s.getName()+","+s.getAge());
}
}
}
练习二：
方法一：
ArrayList去除集合中字符串的重复值(字符串的内容相同)
package jihe;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 分析:
* 1)创建ArrayList集合
* 2)给集合中添加元素(包括字符串重复元素)
* 3)创建一个新的集合
* 4)遍历旧集合
* 获取到每一个元素
* 判断:判断新集合中是否包含旧集合中的元素,
* 包含:说明重复了,就不搭理
* 不包含:说明不重复,给集合中添加元素
*
* 5)遍历新集合
* */
public class ArrayListTest {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList array = new ArrayList() ;
//给集合中天剑元素:包括重复元素
array.add("haha") ;
array.add("ninhao") ;
array.add("java") ;
array.add("haha") ;
array.add("javaee") ;
array.add("xixi") ;
array.add("javaweb") ;
array.add("javaee") ;
array.add("android") ;
array.add("java") ;
//创建一个新的集合
ArrayList newArray = new ArrayList() ;
//遍历旧集合
Iterator it = array.iterator() ;
while(it.hasNext()){
String s = (String) it.next() ;//获取到了旧就集合中的所有元素
//判断集合中是否包含就集合中的元素
if(!newArray.contains(s)){
newArray.add(s) ;
}
}
//遍历新集合
Iterator it2 = newArray.iterator() ;
while(it2.hasNext()){
String s = (String) it2.next() ;
System.out.println(s);
}
}
方法二：
package jihe;
import java.util.ArrayList;
import java.util.Iterator;
/**
* ArrayList去除集合中字符串的重复值(字符串的内容相同)
*
* 附加条件:不能创建新集合进行实现!
* */ class ArrayListTest2 {
public static void main(String[] args) {
ArrayList al=new ArrayList();
//给集合添加元素:包括重复元素
al.add("haha") ;
al.add("ninhao") ;
al.add("java") ;
al.add("haha") ;
al.add("javaee") ;
al.add("xixi") ;
al.add("javaweb") ;
al.add("javaee") ;
al.add("android") ;
al.add("java") ;
/**
* 使用选择排序的做法:
* 拿0索引的对应的元素依次和后面索引对应的进行比较,如果后面重复的元素,删掉后面索引的应的元素
* 拿1索引......同理其他一样
* */
for(int i=0;i<al.size()-1;i++){
for(int j=i+1;j<al.size();j++){
if(al.get(i).equals (al.get(j))){
al.remove(j);
j--;
}
}
}
//遍历
Iterator it=al.iterator();
while(it.hasNext()){
String s=(String) it.next();
System.out.println(s);
}
}
}
2）Vector
Vector集合:
底层数据结构也是数组:查询快,增删慢,从线程角度:线程安全,同步,效率低!
特有功能:
public void addElement(E obj) ----相当于add()
public Enumeration elements() -----相当于迭代器:Iterator iterator()
boolean hasMoreElements() ---->相当于hasNext()方法
Object nextElement() ---->相当于next()方法
public Object elementAt(int index) ------->List集合中的get(int index)
代码:
public class VectorDemo {
public static void main(String[] args) {
//创建Vector集合的对象
Vector v = new Vector() ;
//给集合集合中添加元素
//public void addElement(E obj) ----相当于add()
v.addElement("hello");
v.addElement("world");
v.addElement("java");
//遍历
// public Enumeration elements()
Enumeration elem = v.elements() ;
while(elem.hasMoreElements()){
String s = (String) elem.nextElement() ;
System.out.println(s);
}
System.out.println("---------------");
for(int x = 0 ; x < v.size() ; x ++){
String s = (String) v.elementAt(x) ;
System.out.println(s);
}
}
}
3)LinkedList
LinkedList集合:
底层数据结构是链表:查询慢,增删快
从线程角度:线程不安全,不同步,效率高
特有功能:
添加相关的:
public void addFirst(Object e)
public void addLast(Object e)
删除相关的:
public Object removeFirst()
public Object removeLast()
获取相关的:
public Object getFirst()
public Object getLast()
*
使用LinkedList集合模拟栈的特点:
我们需要自定义一个集合类,在该类中使用LinkedList中的特有功能继续模拟
栈的特点:先进后出，LinkedList里面有一个特有功能:addFirst()
代码：
public class MyStack {
//定义一个成员变量
private LinkedList link ;
//无参构造
public MyStack(){
link = new LinkedList() ;
}
//添加
public void add(Object obj){
link.addFirst(obj) ;
}
//获取
public Object get(){
return link.removeFirst() ;
}
//判断
public boolean isEmpty(){
return link.isEmpty() ;
}
}
//栈集合类的测试类
public class MyStackDemo {
public static void main(String[] args) {
//创建MyStack类对象
MyStack ms = new MyStack() ;//实质是创建了一个LinkedList集合对象
//给栈集合中添加元素
ms.add("hello") ;
ms.add("world") ;
ms.add("java") ;
//给对象做一个判断
while(!ms.isEmpty()){//ms不为空的时候
//获取元素
System.out.println(ms.get());
}
}
}
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
