java集合框架Day2

集合

List接口与实现类

List子接口

• 特点：有序、有下标、元素可以重复
• 方法
  • void add(int index,Object o) //在index位置插入对象o
  • boolean addAll(int index,Collection c) //将一个集合中的元素添加到此集合中的index位置
  • Object get(int index) //返回集合中指定位置的元素
  • List subList(int fromIndex,int toIndex) //返回fromIndex和toIndex之间的集合元素

方法使用（1）

首先我们还是先来创建一个集合对象

//创建集合对象
List list = new ArrayList();

第一步已经很熟了，肯定要先往集合里添加元素

//1.添加元素
list.add("苹果");
list.add("小米");
list.add(0,"华为");//意思是说在第一个位置添加元素“华为”
System.out.println("元素个数："+list.size());
System.out.println(list.toString());

删除元素也就不再赘述了

//2.删除元素
//        list.remove("苹果");
//        list.remove(0);
//        System.out.println("删除之后："+list.size());
//        System.out.println(list.toString());

与Collection父接口有不同的还是遍历部分

List集合实现遍历一共有四种方式，第一种就是我们所熟知的for循环

之前在Collection集合中之所以不能使用for，是由collection自身无序无下标的特性所决定的，而List集合是有序有下标的，这也意味着List是可以使用for的

//(1)使用for遍历
System.out.println("=========================使用for循环==============================");
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));

能使用for，自然也是可以用增强for的

//（2)使用增强for
System.out.println("==========================使用增强for=============================");
for (Object object:
     list) {
    System.out.println(object);
}

还有一种即是刚刚接触到的方式——迭代器

//(3)使用迭代器
System.out.println("==========================使用迭代器==============================");
Iterator it= list.iterator();
while (it.hasNext()){
    System.out.println(it.next());
}

这三种方式的输出结果是一样的

华为
苹果
小米

接下来我们要学习一种新的迭代器，叫做列表迭代器（ListIterator），与通常迭代器不同的是，列表迭代器可以向前或向后遍历，添加，删除，修改元素

先来看看如何从前向后遍历

ListIterator lit=list.listIterator();
System.out.println("====================使用列表迭代器从前往后==========================");
while (lit.hasNext()){
    System.out.println(lit.nextIndex()+":"+lit.next());
}

为令其更清晰，给每个元素之前加上序号，输出为

====================使用列表迭代器从前往后==========================
0:华为
1:苹果
2:小米

如果想要令其从后向前遍历，有一个需要注意的问题，即指针需要从最后一个位置开始，而由于我们刚从前向后遍历过，此时指针就已经处于最后一位了 ，所以直接在下面接着再遍历一遍即可

System.out.println("====================使用列表迭代器从后往前==========================");
while (lit.hasPrevious()){
    System.out.println(lit.previousIndex()+":"+lit.previous());
}

同样给他加上序号，输出为

====================使用列表迭代器从后往前==========================
2:小米
1:苹果
0:华为

还可以再进行判断

//4.判断
System.out.println(list.contains("苹果"));
System.out.println(list.isEmpty());

最后也涉及到一个新操作，获取元素在集合中的位置，如下，我想知道元素“华为”在集合中的什么位置，就可以通过以下来实现

//5.获取位置获取某个元素 在集合中的位置
System.out.println(list.indexOf("华为"));

输出为

0

说明元素“华为”处于集合中第一个元素的位置

完整代码为

package com.assemble.List;

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

/*
List子接口的使用
特点：1.有序 有下标  2.可以重复
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList();

        //1.添加元素
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");//意思是说在第一个位置添加元素“华为”
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());

        //2.删除元素
//        list.remove("苹果");
//        list.remove(0);
//        System.out.println("删除之后："+list.size());
//        System.out.println(list.toString());

        //3.遍历
        //(1)使用for遍历
        System.out.println("=========================使用for循环==============================");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //（2)使用增强for
        System.out.println("==========================使用增强for=============================");
        for (Object object:
             list) {
            System.out.println(object);
        }
        //(3)使用迭代器
        System.out.println("==========================使用迭代器==============================");
        Iterator it= list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //(4)使用列表迭代器,和Iterator的区别：ListIterator可以向前或向后遍历，添加，删除，修改元素
        ListIterator lit=list.listIterator();
        System.out.println("====================使用列表迭代器从前往后==========================");
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("====================使用列表迭代器从后往前==========================");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }

        //4.判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());

        //5.获取位置获取某个元素 在集合中的位置
        System.out.println(list.indexOf("华为"));
    }
}

完整输出结果为

元素个数：3
[华为, 苹果, 小米]
=========================使用for循环==============================
华为
苹果
小米
==========================使用增强for=============================
华为
苹果
小米
==========================使用迭代器==============================
华为
苹果
小米
====================使用列表迭代器从前往后==========================
0:华为
1:苹果
2:小米
====================使用列表迭代器从后往前==========================
2:小米
1:苹果
0:华为
true
false
0

方法使用（2）

创建一个集合

//创建集合
List list=new ArrayList();

与之前不一样的是，这次添加的是数字数据

//1.添加数字数据(在添加基本类型数据时，系统会自动装箱)
list.add(20);//其中的基本数据已经变成了包装类
list.add(30);
list.add(40);
list.add(50);
list.add(60);
System.out.println("元素个数："+list.size());
System.out.println(list.toString());

看起来输入的是基本类型整数，但实际上在添加基本数据类型时，系统会自动进行装箱，即其中的基本数据已经变成了包装类

第二步依然是删除操作，但这次不太一样，如果直接想删除某个数据是做不到的，比如想要删除“20”，如果直接写

list.remove(20);

这样是会报错或结果不符的，原因是remove括号内跟数字指的是删掉角标为20的元素而非元素“20”

正确的做法是强制转化或者写它的包装类，以下分别以删除元素“20”与“40”对两种方式做了示范

//2.删除操作
  list.remove(new Integer(40));
  list.remove((Object) 20);//这里是不能直接写数字的，必须要强制转换或写它的包装类
  System.out.println("剩余元素个数："+list.size());
  System.out.println(list.toString());

遍历的方式已经在之前的例子中演示完毕，因此这里不再赘述，而是拓展一个额外的方法subList——返回子集合

//3.返回子集合，subList
List subList=list.subList(1,3);//需要注意这里的角标范围指的是[1,3)
System.out.println(subList.toString());

这里可以看到新定义了一个集合，即代表其子集合，调用subList方法时，要注意括号中的范围含头不含尾，即为一个左闭右开区间。并且这里的数字代表角标，如果发现取出的子集合与预想的不一样，需要去之前检查是否误删除了元素让角标变化了

List实现类

• ArrayList【重点】

  • 数组结构实现，查询快、增删慢
  • 运行效率快。线程不安全

• Vector

  • 数组结构实现，查询快，增删慢
  • 运行效率慢。线程安全

• LinkedList

  • 链表结构实现，增删快，查询慢

ArrayList使用

创建一个集合

//创建集合
ArrayList arrayList=new ArrayList();

往里面添加元素

//1.添加元素
Student s1=new Student("甦",19);
Student s2=new Student("更生",20);
Student s3=new Student("曹和宇",21);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
System.out.println("元素个数："+arrayList.size());
System.out.println(arrayList.toString());

删除元素这次要多提一嘴，如下，我们重新new一个对象，尽管属性相同，但是因为是两个对象，所以是并不能删除成功的，如果想要达到目的，则需要在Student类中重写equals方法，来达到使两个不同的对象只要属性相同就合并为一个对象的目的

//2.删除元素
  arrayList.remove(new Student("更生",20));//new会在堆中重新开辟空间，因此这样原本是删除不了“更生”这个对象的（因为两个是不同的对象），但通过方法重写即可实现
  System.out.println("剩余元素个数："+arrayList.size());

@Override
public boolean equals(Object obj) {
    if (this==obj){
        return true;
    }
    if (obj==null){
        return false;
    }
    if (obj instanceof Student){
        Student s=(Student) obj;
        if (this.name.equals(s.getName())&&this.age==s.getAge()){
            return true;
        }
    }
    return false;
}

接下来就是遍历元素了，这里还是给出各种方式的实例，但是不再赘述

使用迭代器

//3.遍历元素
//使用迭代器
System.out.println("=================================使用迭代器======================================");
Iterator it=arrayList.iterator();
while (it.hasNext()){
    Student s=(Student) it.next();
    System.out.println(s.toString());
}

使用列表迭代器

从前往后

//使用列表迭代器
System.out.println("=============================使用列表迭代器=======================================");
ListIterator lit=arrayList.listIterator();
//从前往后
while (lit.hasNext()){
    Student s=(Student) lit.next();
    System.out.println(s.toString());

从后往前

//从后往前
while (lit.hasPrevious()){
    Student s=(Student) lit.previous();
    System.out.println(s.toString());
}

接下来进行判断，与删除那里一样，一旦new了新对象，只有重写方法，才能达到想要的目的

//4.判断
System.out.println(arrayList.contains(new Student("更生",20)));
System.out.println(arrayList.isEmpty());

最后演示下查找元素

//5.查找
System.out.println(arrayList.indexOf(new Student("更生",20)));

Student类

package com.assemble.List;

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

    @Override
    public boolean equals(Object obj) {
        if (this==obj){
            return true;
        }
        if (obj==null){
            return false;
        }
        if (obj instanceof Student){
            Student s=(Student) obj;
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
}

测试类完整代码

package com.assemble.List;

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

/*
ArrayList的使用
存储结构：数组，查找遍历速度快、增删慢
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList=new ArrayList();

        //1.添加元素
        Student s1=new Student("甦",19);
        Student s2=new Student("更生",20);
        Student s3=new Student("曹和宇",21);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数："+arrayList.size());
        System.out.println(arrayList.toString());

        //2.删除元素
//        arrayList.remove(new Student("更生",20));//new会在堆中重新开辟空间，因此这样原本是删除不了“更生”这个对象的（因为两个是不同的对象），但通过方法重写即可实现
//        System.out.println("剩余元素个数："+arrayList.size());

        //3.遍历元素
        //使用迭代器
        System.out.println("=================================使用迭代器======================================");
        Iterator it=arrayList.iterator();
        while (it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s.toString());
        }
        //使用列表迭代器
        System.out.println("=============================使用列表迭代器=======================================");
        ListIterator lit=arrayList.listIterator();
        //从前往后
        while (lit.hasNext()){
            Student s=(Student) lit.next();
            System.out.println(s.toString());
        }
        //从后往前
        while (lit.hasPrevious()){
            Student s=(Student) lit.previous();
            System.out.println(s.toString());
        }

        //4.判断
        System.out.println(arrayList.contains(new Student("更生",20)));
        System.out.println(arrayList.isEmpty());

        //5.查找
        System.out.println(arrayList.indexOf(new Student("更生",20)));
    }
}

完整输出结果为

元素个数：3
[Student [name=甦,age=19], Student [name=更生,age=20], Student [name=曹和宇,age=21]]
=================================使用迭代器======================================
Student [name=甦,age=19]
Student [name=更生,age=20]
Student [name=曹和宇,age=21]
=============================使用列表迭代器=======================================
Student [name=甦,age=19]
Student [name=更生,age=20]
Student [name=曹和宇,age=21]
Student [name=曹和宇,age=21]
Student [name=更生,age=20]
Student [name=甦,age=19]
true
false
1