集合(一)~集合概述、List

作者: Anwfly | 来源:发表于2020-04-10 15:46 被阅读0次

List集合序列排序方法
①集合中是简单整型

ArrayList<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(3);
        nums.add(2);

        Collections.sort(nums);

输出为：1 2 3
②集合中为对象

public static void main(String[] args) {
        ArrayList<ProductBean> list = new ArrayList<>();
        list.add(new ProductBean("b", 2));
        list.add(new ProductBean("a", 1));
        list.add(new ProductBean("c", 3));
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName() + ":" + list.get(i).getPrice());
        }
        Collections.sort(list, new Comparator<ProductBean>() {
            @Override
            public int compare(ProductBean o1, ProductBean o2) {
                return o2.getPrice().compareTo(o1.getPrice());
            }
        });

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName() + ":" + list.get(i).getPrice());
        }
    }

实体类要实现Comparable接口

public class ProductBean implements Comparable<ProductBean> {
    private String name;
    private Integer price;

    public ProductBean(String name, Integer price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public int compareTo(ProductBean o) {
        return this.price.compareTo(o.price);
    }
}

集合中顺序打乱

ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
Collections.shuffle(list);

集合中随机获取一个下标，该方法随机出来的整型是左闭右开的

randomPos = (int) (Math.random() * list.size());

集合中随机获取部分数据

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
Collections.shuffle(list);
list = list.subList(0, 2);

最后的list大小是2，可能是123中的任意两个

一、集合概述

1. 集合的由来

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

2. 集合和数组有什么区别

集合长度是可变的,数组长度是不可变的。
数组中可以存储基本数据类型和引用类型，集合只能存储对象
同一个数组只能存储一种引用类型数据，同一个集合可以存储不同引用数据类型(不建议,遍历不方便)

3. 集合的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

4.集合继承体系

Java.util 包中提供了一些集合类，这些集合类又被称为容器，提到容器不难想到数组，集合类与数组的不同之处是，数组的长度是固定的，集合的长度是可变的；数组用来存放基本数据类型和引用类型数据；集合用来存放引用数据类型；常用的集合有List集合、Set集合和Map集合，其中分为两类，单列和双列。单列集合的顶层接口是Collection。List接口和set接口继承Collection。

List和set分别提供了实现类ArrayList、LinkedList、Vector，HashSet、TreeSet、LinkedHashSet等实现类体系。Map是双列集合，键值对的形式存储数据，Map是一个集合顶层接口，常用实现类HashMap，TreeMap，LinkedHashMap等体系。

collection.png

二、Collection接口

Collection接口概述及方法

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

Collection.png

因为 Collection 是一个接口，在使用它的方法的时候，选择其中一个实现类ArrayList来做演示
Collection 接口中的常用方法

1. 添加：

 // 向集合中添加一个元素
 // e表示要向集合中添加的对象, 添加成功返回true, 添加失败返回false
boolean add(E e)

案例：

Collection coll = new ArrayList<>();//创建集合
coll.add("hello");//给集合添加一个元素 
coll.add("world");//给集合再添加一个元素
System.out.println(coll);// 显示 [hello, world]

2. 移除：

// 移除集合中指定的元素
// o 表示要从集合中删除的对象  删除成功返回true 返回失败(集合中把本来就没有这个对象)发挥false
boolean remove(Object o)

Collection coll = new ArrayList<>();//创建集合
coll.add("hello");//给集合 添加一个元素
coll.add("world");//给集合再添加一个元素
System.out.println(coll);// 显示 [hello, world]
coll.remove("hello");// 删除 集合中 hello 这个//元素
System.out.println(coll);// [world]

3. 清除

//清除集合中的元素, 集合会还原回刚创建的状态
void clear()

案例：

Collection coll = new ArrayList<>();//创建集合
coll.add("hello");//给集合 添加一个元素
coll.add("world");//给集合再添加一个元素
System.out.println(coll);// 显示 [hello, world]
coll.clear();;// 删除 集合中所有元素
System.out.println(coll);// [] 所有数据都删除了

4. 是否包含

//集合中是否包含该元素
//判断集合中是否包含o对象 如果集合中含有o对象,返回true; 如果不含有o对象,返回false
boolean contains(Object o)

案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合再 添加一个元素
System.out.println(coll);// [hello,world]
boolean contains1 = coll.contains("hello");//集合中是否包含该元素
System.out.println(contains1);//true  包含 
boolean contains2 = coll.contains("张三");//集合中是否包含该元素
System.out.println(contains2);//false 不包含

5. 集合是否为空

// 判断集合是否为空, 如果集合中没有数据返回true, 如果有数据返回false
boolean isEmpty()

案例：

Collection coll = new ArrayList<>();//创建一个集合
System.out.println(coll.isEmpty());//  false  集合 没有元素
coll.add("hello");//给集合中  添加一个元素
System.out.println(coll.isEmpty());// true  集合有元素  不为 空

6. 集合大小

//  获取集合存有几个元素  如果集合中存储有5个元素,则返回5
int size()

案例：

Collection coll = new ArrayList<>();//创建一个集合
System.out.println(coll.size());// 0  集合 没有元素
coll.add("hello");//给集合中  添加一个元素
System.out.println(coll.size());// 1  集合有1个元素
coll.add("world");//给集合中  添加一个元素
System.out.println(coll.size());// 2  集合有2个元素

7. 将该集合中的元素添加到另一个集合中

//将该集合中的元素添加到另一个集合中
//把集合c中的所有数据加入到集合中, 添加成功返回true 添加失败返回false
boolean addAll(Collection c)

案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
Collection coll2 = new ArrayList<>();//创建一个集合
System.out.println(coll2);//[]
coll2.add(coll); // 将  集合   coll 中的元素  都添加到   集合  coll2中
System.out.println(coll2);//[[hello, world]] 把集合coll的元素都添加进入了coll2

8. 移除另一个集合中包含该集合的元素

//移除另一个集合中包含该集合的元素
//如果本集合中有的对象,另外一个集合中也存在,则把这些对象删除, 如果删除了数据返回true; 没有删除数据返回false
boolean removeAll(Collection c)

案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
System.out.println("coll: "+coll);
Collection coll2 = new ArrayList<>();//创建一个集合
coll2.add("hello");//给集合中  添加一个元素
coll2.add("world");// 给集合  添加一个元素
coll2.add("java");// 给集合  添加一个元素
System.out.println("coll2: "+coll2);
coll2.removeAll(coll); //从集合  coll2  中 移除 与 集合 coll 相同的元素
System.out.println("coll2删除以后: "+coll2);//[java]

9.另一个集合是否包含指定的集合

//另一个集合是否包含指定的集合
//判断集合中是否包含有c集合中的所有元素,如果包含返回true,否则返回false
boolean containsAll(Collection c)

案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
Collection coll2 = new ArrayList<>();//创建一个集合
coll2.add("hello");//给集合中  添加一个元素
coll2.add("world");// 给集合  添加一个元素
coll2.add("java");// 给集合  添加一个元素
boolean b = coll2.containsAll(coll); //集合  coll2  是否包含  集合  coll 
System.out.println(b);//true  包含

10. 移除集合中与指定集合不同的元素

// 移除 集合中与指定集合不同的元素
//找到两个集合中不相同的元素删除 有删除的数据返回true ,否则为false
boolean retainAll(Collection c)

案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
Collection coll2 = new ArrayList<>();//创建一个集合
coll2.add("hello");//给集合中  添加一个元素
coll2.add("world");// 给集合  添加一个元素
coll2.add("java");// 给集合  添加一个元素
coll2.retainAll(coll); // 移除  集合 coll2  与   集合  coll  不同的元素
System.out.println(coll2);//[hello, world]

11. 把集合转成数组，可以实现集合的遍历

//把集合转成数组，可以实现集合的遍历
//把集合转换成存储相同元素的数组
Object[] toArray()

案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
Object[] array = coll.toArray(); // 转成   Object  数组
for (int i = 0; i < array.length; i++) {
    // 存入的是  字符串   
    // 所有要将  object  转成  string
    System.out.println((String)array[i]);   
}

三、Iterator接口

1. Iterator接口概述及使用

迭代器，集合的专用遍历方式，对 collection 进行迭代的迭代器，依赖于集合而存在
Iterator接口的成员方法:

//如果仍有元素可以迭代，则返回 true。
boolean hasNext():
//获取元素,并移动到下一个位置。
Object next():
//没有这样的元素，因为你已经找到最后了。
NoSuchElementException()：

实际使用案例：

Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素

//获得迭代器
Iterator iterator = coll.iterator();
while(iterator.hasNext()){// 如果有下一个元素   
    Object next = iterator.next();// 获取下一个元素
    // 存入的是  字符串   
    // 所有要将  object  转成  string
    System.out.println((String)next);
}

四、List接口

List接口概述及方法

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素，存取元素有序。

List接口的特殊成员方法（根据索引进行操作）

1. 添加

//添加指定元素 把要添加进集合的element对象,添加到指定索引位置index
void add(int index,E element)

案例：

List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
System.out.println(coll);// [hello, world]

2.移除指定元素

// 移除指定元素 删除集合中指定index位置处元素对象
E remove(int index)

案例：

List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
coll.remove(1);// 移除 1 这个位置的 元素，集合元素也是从 0 开始计算索引
System.out.println(coll);//[hello]

3. 获取指定位置的元素

// 获取 指定位置的元素 
//index 集合索引值,从0开始,不能大于等于集合中元素个数
E get(int index)

案例：

List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
System.out.println(coll.get(1));//world   获取指定位置的元素

3. 修改指定位置的元素

// 修改指定位置的元素
// index 要修改元素的索引值
// element 此对象会替换掉原来集合中制定索引位置的元素对象
E set(int index,E element)

案例：

List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
System.out.println(coll);//[hello, world]
coll.set(1, "java");// 把 1 位置的 元素  设置成  java
System.out.println(coll);//[hello, java]

4. 获得专用迭代器

//  获得专用迭代器
ListIterator listIterator()

案例：

List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中  添加一个元素
coll.add("world");// 给集合  添加一个元素
ListIterator listIterator = coll.listIterator();//获取 迭代器
while(listIterator.hasNext()){// 如果有下一个  返回 true
    //获取下一个元素
    Object next = listIterator.next();
    System.out.println((String)next);
}

五、ListIterator接口

1. ListIterator概述及使用

系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
ListIterator接口的成员方法:

// 是否有上一个元素
boolean hasPrevious() 
// 获取上一个元素
E previous()

使用以上两个方法时先使用迭代器正向遍历(使位置移动到最后一个), 无法循环获取因为位置就在第一个的前面

六、ConcurrentModificationException（异常）简介及处理

1. 简介及处理

ConcurrentModificationException: 不允许这种修改时，抛出此异常

*为什么出现此异常:
在迭代时候, 使用集合对象去修改集合中的元素出现的这种异常；
在迭代过程中修改集合元素时迭代器不知道集合被修改发生错误。

ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//把指针移到集合最后
ListIterator<Integer> it = list.listIterator();
list.add(7);//当获取listIterator对象后修改了集合
while(it.hasNext()){
    //如果再使用it对象获取元素,导致ConcurrentModificationException异常
    System.out.println(it.next());
}

运行效果:

Concurrent_1.PNG

如何去解决此异常:
使用 ListIterator 迭代集合并且使用 ListIterator 对象去修改集合元素
ListIterator 提供了对应的添加方法

ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//把指针移到集合最后
ListIterator<Integer> it = list.listIterator();
//  list.add(7);
while(it.hasNext()){
    System.out.println(it.next());
}
it.add(7);//
//逆向遍历列表
while(it.hasPrevious()){
    System.out.println(it.previous());
}

八、ArrayList 类

1. ArrayList类的概述

底层数据结构是数组，查询快，增删慢
线程不安全，效率高，有序的,可重复

2. ArrayList的使用

构造方法摘要 :

//构造一个初始容量为 10 的空列表。
ArrayList() 
//构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList(Collection<? extends E> c) 
//构造一个具有指定初始容量的空列表。
ArrayList(int initialCapacity)

常用方法参考List(使用方式几乎一致)

//创建  ArrayList  集合 对象
ArrayList  arr = new ArrayList();
arr.add("hello1");// 给集合添加一个元素
arr.add("hello2");// 给集合添加一个元素

3. ArrayList的常用案例-添加整数遍历集合

ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//把指针移到集合最后
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

4. ArrayList的常用案例-添加字符串遍历集合

ArrayList<String> list=new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
//把指针移到集合最后
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

5. ArrayList的常用案例-添加对象遍历集合

Student.java

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

Test.java

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(new Student("张三", 18, "男"));
        list.add(new Student("李四", 11, "女"));
        list.add(new Student("王五", 19, "男"));
        list.add(new Student("赵六", 21, "女"));
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

九、Vector 类

1. Vector类概述及使用

底层数据结构是数组，查询快，增删慢, 线程安全，效率低

*Vector类特有功能 :

1. 添加

//添加一个元素
//把obj对象添加进入集合 等效add(E e)方法
public void addElement(E obj)

案例

//创建  Vector  集合 对象    在集合中存入 字符串
Vector  v = new Vector();
System.out.println(v);//[]
v.add("hello");
System.out.println(v);//[hello]

2. 获取指定位置的元素

//获取指定位置的元素
//index 制定位置索引值
//返回值为得到制定索引位置的集合元素
public E elementAt(int index)

案例

//创建  Vector  集合 对象    在集合中存入 字符串
Vector  v = new Vector();
v.add("hello");
v.add("world");
v.add("java");
// 获取  1 这个位置的  元素  并输出在控制台
System.out.println(v.get(1));//world

3. 获取指定位置的元素

// 获取Vector 迭代器
public Enumeration elements()

案例

//创建  Vector  集合 对象    在集合中存入 字符串
Vector  v = new Vector();
v.add("hello");
v.add("world");
v.add("java");
//获取迭代器
Enumeration elements = v.elements();
//有没有下一个元素  与 ListIterator 用法一样
while(elements.hasMoreElements()){
    // 获取下一个元素
    Object nextElement = elements.nextElement();
    System.out.println((String)nextElement);
}

*Vector的常用案例:

案例1：Vector存入String对象

// 创建 Vector 集合 对象 在集合中存入 字符串
Vector v = new Vector();

v.add("hello");
v.add("world");
v.add("java");
// 普通for遍历
for (int i = 0; i < v.size(); i++) {
    // 多态 向下转型
    System.out.println((String) v.get(i));
}

案例2：Vector存入自定义对象

Vector  v = new Vector();
v.add(new Student("赵云",18,"男"));// 给集合添加一个元素
v.add(new Student("张飞",19,"女"));// 给集合添加一个元素
v.add(new Student("关于",20,"男"));// 给集合添加一个元素
v.add(new Student("刘备",21,"女"));// 给集合添加一个元素
//普通for遍历  集合
for (int i = 0; i < v.size(); i++) {
    //获取的时候   获取的是  object对象  父类接收子类   多态
    Object object = v.get(i);// 集合中的一个元素  是一个  Student 对象
    //多态  向下转型
    Student s = (Student)object;
    System.out.println(s.getName()+"---"+s.getAge());
}

十、 LinkedList类

LinkedList类概述

底层数据结构是链表，查询慢，增删快
线程不安全，效率高

LinkedList类的特有功能

1. 在集合的开始位置插入一条数据

//在集合的开始位置插入一条数据
//e表示要插入集合最开始位置的元素
public void addFirst(E e)
//在集合的末尾添加元素
//e表示要添加进入集合中的元素
addLast(E e)

案例

//创建  LinkedList 对象
LinkedList link = new LinkedList();
link.add("hello");//添加一个元素
link.add("world");
System.out.println(link);//[hello, world]
link.addFirst("java");// 在第一个位置插入  一个元素  
System.out.println(link);//[java, hello, world]
link.addLast("lvoe");//在集合最后的位置加入一个  元素
System.out.println(link);//[java, hello, world, lvoe]

2. 获取集合的第一个元素

//获取集合的第一个元素
public E getFirst()
//获取集合的最后一个元素
public E getLast()

案例

//创建  LinkedList 对象
LinkedList link = new LinkedList();
link.add("hello");//添加一个元素
link.add("world");
link.add("java");
//获取集合中  第一个元素    hello
System.out.println(link.getFirst());
//获取集合中  最后一个元素   java
System.out.println(link.getLast());

3. 获取集合的第一个元素

//删除集合中的第一个元素
public E removeFirst()
//删除集合中的最后一个元素
public E removeLast()

案例

//创建  LinkedList 对象
LinkedList link = new LinkedList();
link.add("hello");//添加一个元素
link.add("world");
link.add("java");
//移除第一个元素  并得到该元素
Object removeFirst = link.removeFirst();                                        System.out.println(removeFirst);//  hello
System.out.println(link);//  [world, java]
//移除最后一个元素  并得到该元素
Object removeLast = link.removeLast();                                      System.out.println(removeLast);//java
System.out.println(link);//[world]

案例一、LinkedList类的常用案例-首尾添加

LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.addFirst(0);//在最前面添加
list.addLast(5);//在最后添加 等价add()方法
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

案例二、 LinkedList类的常用案例-指定位置插

LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(1,12);//在索引为1的位置插入一个12
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

案例三、 LinkedList类的常用案例-首尾删除

LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}
System.out.println("-------------删除以后效果------------------");
list.removeFirst();//删除第一个元素
list.removeLast();//删除最后一个元素
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

集合(一)~集合概述、List

一、集合概述

1. 集合的由来

2. 集合和数组有什么区别

3. 集合的特点

4.集合继承体系

二、Collection接口

Collection接口概述及方法

三、Iterator接口

1. Iterator接口概述及使用

四、List接口

List接口概述及方法

1. 添加

2.移除指定元素

3. 获取 指定位置的元素

3. 修改指定位置的元素

4. 获得专用迭代器

五、ListIterator接口

1. ListIterator概述及使用

六、ConcurrentModificationException（异常）简介及处理

1. 简介及处理

八、ArrayList 类

1. ArrayList类的概述

2. ArrayList的使用

3. ArrayList的常用案例-添加整数遍历集合

4. ArrayList的常用案例-添加字符串遍历集合

5. ArrayList的常用案例-添加对象遍历集合

九、Vector 类

1. Vector类概述及使用

1. 添加

2. 获取指定位置的元素

3. 获取指定位置的元素

十、 LinkedList类

LinkedList类概述

LinkedList类的特有功能

1. 在集合的开始位置插入一条数据

2. 获取集合的第一个元素

3. 获取集合的第一个元素

案例一、LinkedList类的常用案例-首尾添加

案例二、 LinkedList类的常用案例-指定位置插

案例三、 LinkedList类的常用案例-首尾删除

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

3. 获取指定位置的元素