Java集合(简单介绍)

集合

目录

• 集合
  • 1.集合的作用
  • 2.集合类的分类
• Collection
  • Collection方法分类
    • 首先看一下添加操作与批量添加操作
    • 集合删除数据
  • ArrayList
  • LinkedList
  • ArrayList与LinkedList的区别
  • HashMap
  • LinkedHashMap
  • TreeMap(二叉树映射)
  • HashSet(哈希集合)
  • LInkedHashSet(链式哈希集合)
  • TreeSet(二叉树集合)
  • 快速失败(fail-fast)机制
  • ConcurrentHashMap

1.集合的作用

		在java中我们可以使用数组来保存多个对象，但是数组的长度不可变。如果需要保存数量变化的数据，数据就不太合适了。为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），Java 提供了集合类。**集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类**

2.集合类的分类

​ java集合类型分为Collection和Map,它们是 Java 集合的根接口，这两个接口又包含了一些子接口或实现类.

下图为collection接口基本结构

下图为Map接口基本结构

Collection

Collection方法分类

1.修改操作

2.查询操作

3.批量操作

首先看一下添加操作与批量添加操作

定义一个Fruit类，一个Apple类，以及一个Banana类

public class Fruit {
    private String name;

    public Fruit(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return name;
    }
}

public class Apple extends Fruit{
    public Apple(String name) {
        super(name);
    }
}

public class Banana extends Fruit{
    public Banana(String name) {
        super(name);
    }
}

然后在主方法中写一个集合，并向这个集合中国添加数据

public class Demo01 {
    //首先看一下添加操作boolean add(),添加成功返回True，失败返回False
    public static void main(String[] args) {
        List<Fruit> fruits = new ArrayList<>();
        System.out.println(fruits.add(new Apple(\"红富士苹果\")));
        System.out.println(fruits.add(new Apple(\"青苹果\")));
        System.out.println(fruits.add(new Fruit(\"蛇果\")));
        for (Fruit fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

输出：

true
true
true
红富士苹果
青苹果
蛇果 

List fruits = new ArrayList<>();

因为集合中定义的是Fruit，说明该集合只能存储Fruit对象或者Fruit的子类对象

再看一下addall()方法，添加成功返回true，否则返回false

首先定义两个集合，分别为苹果集合和香蕉集合，并向集合中添加数据

public class Demo01 {
    //首先看一下添加操作boolean add(),添加成功返回True，失败返回False
    public static void main(String[] args) {
        List<Apple> apples = new ArrayList<>();
            apples.add(new Apple(\"红富士\"));
            apples.add(new Apple(\"青苹果\"));
            apples.add(new Apple(\"蛇果\"));
        List<Banana> bananas = new ArrayList<>();
        bananas.add(new Banana(\"帝皇蕉\"));
        apples.add(new Apple(\"海南香蕉\"));
        List<Fruit> fruits = new ArrayList<>();
        System.out.println(fruits.addAll(apples));
        System.out.println(fruits.addAll(bananas));
        for (Fruit fruit : fruits) {
            System.out.println(fruit);
        }

    }
    }

集合删除数据

remove()删除单个数据，删除批量数据removeAll，删除符合添加条件的数据，removeIF，删除所有数据clear，即清空数据！

首先先看单个删除操作如何操作的

public class Demo02 {
    public static void main(String[] args) {
        //定义一个数字集合
        List<Integer> numbers = new ArrayList<>();
                numbers.add(1);
                numbers.add(2);
                numbers.add(3);
                numbers.add(4);
                numbers.add(5);
        for (Integer number : numbers) {
            System.out.print(number+\" \");
        }
        System.out.println();
        System.out.println(\"====分===割===线=====\");
              numbers.remove(2);
              numbers.remove(3);
        for (Integer number : numbers) {
            System.out.print(number+\" \");
        }
    }
}

输出：

1 2 3 4 5 
====分===割===线=====
1 2 4 

可以看到，删除我们打印输出的是1，2，4，可以看到他是先删除的下标为2的数字，然后，后面的数字往前进一个，集合中现在的长度为4，我们再取下标3的数，也就是最后一个数5，打印剩下的数就是1.2.4.

1.removeAll()方法

删除要删除数据中的集合，只要有符合的就执行删除操作

代码示例：

public class Demo03 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        List<Integer> num=new ArrayList<>();
        num.add(2);
        num.add(3);
        num.add(5);
        num.add(6);
        numbers.removeAll(num);
        for (Integer number : numbers) {
            System.out.print(number+\" \");
        }
    }

}

输出：

1  4

2.retainAll()方法,指定要保留的数据集合

public class Demo04 {
    public static void main(String[] args) {

        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        List<Integer> nums = new ArrayList<>();
        nums.add(2);
        nums.add(4);
        nums.add(6);
        numbers.retainAll(nums);
        System.out.println(numbers);
    }
}

输出:

[2, 4]

可以看到，我们把要保留的数放在第二个集合中，当在需要操作的集合中能找到相应的数据，就将其保留！

3.removeIf()方法

public class Demo05 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        //指定规则删除集合中的数据
        //Predicate接口主要用来判断一个参数是否符合要求
         boolean result=numbers.removeIf(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                //删除所有偶数
                return integer%2==0;
            }
        });
         //看是否删除成功
        System.out.println(result);
        //遍历集合
        for (Integer number : numbers) {
            System.out.print(number+\" \");
        }
    }

}

输出：

true
1 3 5 

4.clear()方法，清空集合

public class Demo06 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        System.out.println(numbers);
        numbers.clear();
        System.out.println(numbers);
    }
}

输出：

[1, 2, 3, 4, 5]
[]

一些常见的其他方法

public class Demo07 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        //集合的元素数
        System.out.println(numbers.size());
        //集合是否为空
        System.out.println(numbers.isEmpty());
        //集合中是否有元素2
        System.out.println(numbers.contains(2));
    }
}

输出：

5
false
true

更多方法，具体的可以查看一下jdk的帮助文档

ArrayList

​ ArrayLisy不但拥有Collection中的方法，还拥有List中的所有方法

特点：

1. 有序
2. 可重复
3. 数据可为null

优点：查询快

缺点：增删慢

1.ArrayList中的构造方法

​ ArrayList中有三种构造方法

• public ArrayList() 构造一个初始容量为十的空列表。

• public ArrayList(Collection<? extends E> c) 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

• public ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。

2.ArrayList中的常用方法

LinkedList

​ 拥有Collection里面的所有方法，List中的所有方法，Queue中的所有方法，Deque中的所有方法

1.LinkedList中的构造方法

• LinkedList() 构造一个空列表。

• LinkedList(Collection<? extends E> c) 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

特点：

1. 有序
2. 可重复
3. 可为null

优点:增删块

缺点：查询慢

2.LinkedList的常用方法：

ArrayList与LinkedList的区别

HashMap

特点：

​ 1.无序

​ 2.key可以为null，哈希值为0

​ 3.key不可以重复，重复的key，新值会覆盖旧值

优点：增删改查快

缺点：无序

1.HashMap的构造方法：

2.HashMap中常用的方法：

其中put与get方法在hashmap中用的最为频繁，在实际开发中，hashmap多用于缓存数据

LinkedHashMap

特点：

1. 有序
2. key唯一
3. key为null

优点：有序

LInkedHashMap中常用的方法：

TreeMap(二叉树映射)

特点：

1. 对key有序
2. 无序
3. key不可为null
4. key唯一

优点：对key有序

缺点：无序

keymap的常用方法：

HashSet(哈希集合)

特点：

1. 无序
2. 值唯一
3. 值可为null

优点：增删改查快

缺点：无序

1.HashSet的构造方法：

2.HashSet的常用方法

3.HashSet与HashMap的区别

LInkedHashSet(链式哈希集合)

特点：

1. 有序
2. 值唯一
3. 值可位null

优点:有序，增删快

缺点：查询慢

1.LinkedHashSet的常用方法

2.LinkedHahsSet与LinkedHashMap的区别

TreeSet(二叉树集合)

特点：

1. 无序
2. 对值排序
3. 值不可为null
4. 值唯一

优点：对值排序

缺点：无序

1.TreeSet的常用方法：

2.HashSet与TreeSet的对比

快速失败(fail-fast)机制

​ 一种容器保护机制，防止多个线程并发修改同一个容器的内容，如果发生了并发修改的情况就会触发快速失败机制，也就是抛出ConcurrentModificationException(并发修改异常)

eg：

当你在迭代遍历某个容器的过程中国，另一个线程介入其中，并且插入或删除此容器中的某个元素，那么就会出现问题，单线程和多线程同理！

我们看一下代码：

可以看出，我们在下面迭代遍历的同时，进行插入操作

import java.util.ArrayList;
import java.util.Iterator;

public class FailFast {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Iterator<String> iterator = list.iterator();
        list.add(\"1\");
        list.add(\"2\");
        while (iterator.hasNext()){
            System.out.println(iterator.next());}
    }
    }

输出：

Exception in thread \"main\" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.gather.map.FailFast.main(FailFast.java:14)

那么为了防止这类问题出现，java容器类采用了快速失败机制，主要用与监视容器的变化

那么如何避免上述问题：我们只需要采用线程安全的容器即可

代码示例：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class FailFast2 {
    public static void main(String[] args) {
        //创建一个支持并发的集合
        CopyOnWriteArrayList list=new CopyOnWriteArrayList();
        //另一个线程修改器
        new Thread(new Runnable() {
            @Override
            public void run() {
                list.add(\"一个简单的多线程\");
                list.add(\"lingstar\");
            }
        }).start();
         //获取迭代器
        Iterator<String> iterator = list.iterator();
        //遍历集合
        while (iterator.hasNext()){
            //获取元素
            System.out.println(iterator.next());
        }
    }
}

输出：

一个简单的多线程
lingstar

ConcurrentHashMap

特点：

1. 无序
2. key唯一
3. key、value不可为null
4. 线程安全

优点：增删改查快

缺点：无序

1.ConcurrentHashMap的常用方法

2.ConcurrentHashMap与HashMap的区别

本文来自博客园，作者：星余明，转载请注明原文链接：https://www.cnblogs.com/lingstar/p/16499093.html

来源：https://www.cnblogs.com/lingstar/p/16499093.html
本站部分图文来源于网络，如有侵权请联系删除。