Java集合框架

1、Collection接口

ArrayList与LinkedList对比

Java数组在操作是会遇到一下问题：

1、数组长度固定不变，不能很好地适应元素数量动态变化的情况。

2、通过数组名.length获取数组的长度，却无法直接获取数组中实际存储的元素个数。

3、数组采用在内存中分配连续空间的方式存储，根据元素信息查找时效率比较低，需要多次比较。

针对数组的缺陷，Java提供了比数组更灵活、更实用的集合框架，可大大提高软件的开发效率，并且不同的集合可适用于不同的应用场合。

如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java的集合框架

Java集合框架

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中

Java集合框架包含的内容：

1、Collection接口

Collection接口：存储一组不唯一，无序的对象

List接口：继承Collection接口，存储一组不唯一，有序（插入顺序）的对象

Set接口：存储一组唯一，无序的对象

2、List接口

ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高。他的默认长度是10。

LinkedList采用链表存储方式。插入、删除元素时效率比较高

List接口的常用方法

方法名	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
containsAll	list2是否包含list1的所有元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

语法：boolean add(Object o)

Punguin punguin1 = new Punguin("欧欧","Q仔");
        Punguin punguin2 = new Punguin("亚亚","Q妹");
        Punguin punguin3 = new Punguin("菲菲","Q妹");
        Punguin punguin4 = new Punguin("美美","Q妹");
        Punguin punguin5 = new Punguin("妮妮","Q妹");
        //使用ArrayList存储企鹅信息
        List<Punguin> punguinsList = new ArrayList<>();
        punguinsList.add(punguin1);
        punguinsList.add(punguin2);
        punguinsList.add(punguin3);
        punguinsList.add(punguin4);

语法：void add(int index,Object o)

//添加到数组元素下标为2的位置
punguinsList.add(2,punguin5);

语法：int size()

System.out.println("共计有" + punguinsList.size() + "只企鹅");

语法：Object get(int index)

for (int i = 0; i < punguinsList.size(); i++) {
    System.out.println(punguinsList.get(i).getName());
}

语法：boolean contains(Object o)

System.out.println("是否包含欧欧Q仔？");
    if (punguinsList.contains(punguin1)){
        System.out.println("包含Q仔");
    }else {
        System.out.println("不包含Q仔");
    }

语法：boolean remove(Object o)

punguinsList.remove(punguin2);
punguinsList.remove(punguin3);

语法：Object remove(int index)

punguinsList.remove(2);

实例：

public class Test {
    public static void main(String[] args) {
        //创建对象添加信息
        Punguin punguin1 = new Punguin("欧欧","Q仔");
        Punguin punguin2 = new Punguin("亚亚","Q妹");
        Punguin punguin3 = new Punguin("菲菲","Q妹");
        Punguin punguin4 = new Punguin("美美","Q妹");
        Punguin punguin5 = new Punguin("妮妮","Q妹");
        //使用ArrayList存储企鹅信息
        List<Punguin> punguinsList = new ArrayList<>();
        punguinsList.add(punguin1);
        punguinsList.add(punguin2);
        punguinsList.add(punguin3);
        punguinsList.add(punguin4);
        punguinsList.add(2,punguin5);

        System.out.println("共计有" + punguinsList.size() + "只企鹅");
        System.out.println("分别是：");
        //循环遍历
        System.out.println("**************");
        for (int i = 0; i < punguinsList.size(); i++) {
            System.out.println(punguinsList.get(i).getName());
        }
        //循环遍历
        System.out.println("**************");
        for (Punguin pun : punguinsList) {
            System.out.println(pun.getName() + "\t"+pun.getGender());
        }
        //删除
        punguinsList.remove(punguin2);
        punguinsList.remove(2);

        System.out.println("删除后**************");
        punguinsList.forEach(punguin -> {
            System.out.println(punguin.getName() + "\t"+punguin.getGender());
        });
        //判断是否包含某个值
        System.out.println("是否包含欧欧Q仔？");
        if (punguinsList.contains(punguin1)){
            System.out.println("包含Q仔");
        }else {
            System.out.println("不包含Q仔");
        }
    }
}

使用ArrayList移除、判断元素

语法：

… …		
 dogs.remove(0);    //删除第一个狗狗信息
 dogs.remove(feifeiDog);
  … …
		
 if(dogs.contains(meimeiDog))    //判断是否包含指定狗狗

	System.out.println("\n集合中包含美美的信息");
 else
	System.out.println("\n集合中不包含美美的信息");

实例：

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //创建对象添加信息
        Punguin punguin1 = new Punguin("欧欧","Q仔");
        Punguin punguin2 = new Punguin("亚亚","Q妹");
        Punguin punguin3 = new Punguin("菲菲","Q妹");
        Punguin punguin4 = new Punguin("美美","Q妹");
        //使用ArrayList存储企鹅信息
        List<Punguin> punguinsList = new ArrayList<>();
        punguinsList.add(punguin1);
        punguinsList.add(punguin2);
        punguinsList.add(punguin3);
        punguinsList.add(punguin4);

        System.out.println("共计有" + punguinsList.size() + "只企鹅");
        System.out.println("分别是：");

        for (Punguin pun : punguinsList) {
            System.out.println(pun.getName() + "\t"+pun.getGender());
        }
        punguinsList.remove(punguin2);
        punguinsList.remove(punguin3);

        System.out.println("删除后**************");
        punguinsList.forEach(punguin -> {
            System.out.println(punguin.getName() + "\t"+punguin.getGender());
        });

        System.out.println("是否包含欧欧Q仔？");
        if (punguinsList.contains(punguin1)){
            System.out.println("包含Q仔");
        }else {
            System.out.println("不包含Q仔");
        }
    }
}

LinkedList集合类

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

实例：

import java.util.LinkedList;

public class TestNews {
    public static void main(String[] args) {
        System.out.println("头条新闻和末条新闻已添加\n");
        //创建对象添加新闻
        News news1 = new News("华为最强芯片980问世");
        News news2 = new News("看看上海怎样垃圾分类");
        News news3 = new News("2019河南本科一批平行志愿正是开档");
        News news4 = new News("美国一意孤行要对中国增加关税");
        //使用LinkedList存储新闻信息
        LinkedList<News> newsLinkedList = new LinkedList<>();
        newsLinkedList.add(news1);
        newsLinkedList.add(news2);
        newsLinkedList.add(news3);
        newsLinkedList.add(news4);

        //打印第一个新闻
        System.out.println(newsLinkedList.getFirst().getNews());

        System.out.println("删除的头条新闻标题为：华为最强芯片980问世" );
        System.out.println("删除的末条新闻标题为：美国一意孤行要对中国增加关税" );
        newsLinkedList.removeFirst();
        newsLinkedList.removeLast();

        System.out.println("删除后剩余的新闻条数为：" + newsLinkedList.size() + "条\n");

        System.out.println("遍历所有新闻标题：");
        newsLinkedList.forEach(news -> {
            System.out.println("新闻标题名称：" + news.getNews());
        });
    }
}

ArrayList与LinkedList对比

	ArrayList	LinkedList
存储方式的区别	ArrayList实现了长度可变的数组，在内存中分配连续的空间。	LinkedList采用链表存储方式
使用场合的区别	ArrayList遍历元素和随机访问元素的效率比较高，插入、删除、修改操作频繁时性能低下。	LinkedList插入、删除、修改元素时效率较高，查找效率较低

3、Set接口

Set 接口存储一组唯一，无序的对象

Set 接口常用的实现类：HashSet

HashSet 集合的特点

1、集合内的元素是无序排列且不允许重复。

2、HashSet集合的查找效率高。

3、允许集合元素值为null。

方法名	说明
boolean add(Object o)	如果Set中尚未包含指定元素o,则添加指定元素o
void clear()	从Set中移除所有元素
int size()	返回Set中的元素个数
boolean isEmpty()	如果Set不包含任何元素，则返回true
boolean contains(Object o)	如果Set包含指定元素o，则返回true
boolean remove(Object o)	如果Set包含指定元素o，则将其移除。

注意：HashSet集合类不存在get方法

语法：boolean add(Object o)

//创建对象添加信息
News news1 = new News("汽车");
News news2 = new News("高考");

//使用HashSet存储新闻信息
Set <News> newsSet = new HashSet<>();
newsSet.add(news1);
newsSet.add(news2);

语法：void clear()

newsSet.clear();

语法：int size()

System.out.println("新闻标题数目为：" + newsSet.size() + "条");

语法：boolean isEmpty()

System.out.println(newsSet.isEmpty());

语法：boolean contains(Object o)

System.out.println("汽车新闻是否存在 ：" + newsSet.contains(news1));

语法：boolean remove(Object o)

System.out.println("汽车对象已删除");
newsSet.remove(news1);

实现元素输出有两种方式：

方式1：使用增强型for循环

// 1、创建四个狗狗对象
		Dog ououDog = new Dog("欧欧", "雪娜瑞");
		Dog yayaDog = new Dog("亚亚", "拉布拉多");
		Dog meimeiDog = new Dog("美美", "雪娜瑞");
		Dog feifeiDog = new Dog("菲菲", "拉布拉多");
		// 2、创建HashSet集合对象并把四个狗狗对象放入其中
		Set dogs = new HashSet();
		dogs.add(ououDog);
		dogs.add(yayaDog);
		dogs.add(meimeiDog);
		dogs.add(feifeiDog);
		// 3、使用for增强语法遍历HashSet
		for (Object obj : dogs) {
			Dog dog=(Dog)obj;
			System.out.println(dog.getName()+"\t"+dog.getStrain());
		}

方式2：通过迭代器Iterator实现遍历

// 1、创建四个狗狗对象
        //  省略创建狗狗对象的代码
	    // 2、创建HashSet集合对象并把四个狗狗对象放入其中
		Set dogs = new HashSet();
		dogs.add(ououDog);
		dogs.add(yayaDog);
		dogs.add(meimeiDog);
		dogs.add(feifeiDog);
		// 3、使用iterator()获取Iterator对象
		Iterator iterator = dogs.iterator();
		// 4、使用Iterator遍历集合
		while (iterator.hasNext()) {
			Dog dog = (Dog) iterator.next();
		System.out.println(dog.getName() + "\t" + dog.getStrain());
		}

4、Map接口

Map接口存储一组键值对象，提供key到value的映射。

Map接口常用的实现类HashMap。

HashMap类的特点：

1、不保证映射的顺序，特别是不保证顺序的恒久不变。

2、数据添加到HashMap集合后，所有的数据类型将转化为Object类型，所以从其中获取数据时需要进行强制类型转换。

Map接口的常用方法

方法名	说明
Object put(Object key, Object val)	以“键–值对”的方式进行存储
Object get (Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove (Object key)	删除由指定的键映射的“键–值对”
int size()	返回元素个数
Set keySet ()	返回键的集合
Collection values ()	返回值的集合
boolean containsKey (Object key)	如果存在由指定的键映射的“键–值对”，返回true

实例：

创建Map对象添加信息

//创建Map对象添加信息
Map<String ,String> dogMap = new HashMap<>();

使用Map存储狗狗信息

dogMap.put("欧欧","雪瑞纳");
dogMap.put("亚亚","拉布拉多");
dogMap.put("菲菲","哈士奇");
dogMap.put("美美","泰迪");

查找指定对象

System.out.println("欧欧\t\t" + dogMap.get("欧欧"));

删除狗狗欧欧

dogMap.remove("欧欧");

查看元素个数

System.out.println("Map中有" + dogMap.size() + "个狗狗\n");

返回键的集合

//显示所有key
System.out.println("---------------------------");
Set<String> keySet = dogMap.keySet();
System.out.println(keySet);

返回值的集合

//显示所有values
System.out.println("---------------------------");
Collection<String> valueCollection = dogMap.values();
System.out.println(valueCollection);

查看指定的键映射的“键–值对是否存在”，存在返回true

System.out.println((dogMap.containsKey("欧欧") ? "true":"false"));

5、泛型

认识泛型

泛型是JDK1.5的新特性。

泛型的本质是参数化类型：将所操作的数据类型指定为一个参数，使代码可以应用于多种类型。

泛型的定义：将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性。

泛型的优点：

1、所有强制转换都是自动和隐式进行的，安全简单。

2、提高了代码的重用率

泛型集合

JDK1.5中使用泛型改写了集合框架中的所有接口和类，也就是泛型集合

典型的泛型集合ArrayList<E>、HashMap<K,V>

<E>、<K,V>表示该泛型集合中的元素类型

实例：

使用MAP创建对象信息时

//创建狗狗对象时，指定狗狗的属性为String类型
Map<String ,String> dogMap = new HashMap<>();

使用List创建对象时

//使用ArrayList存储新闻信息
//定义为News类型
List<News> newsList = new ArrayList<>();

使用LinkedList创建对象时

//使用LinkedList存储新闻信息
//定义为News类型
LinkedList<News> newsLinkedList = new LinkedList<>();

使用Set创建对象时

//使用HashSet存储新闻信息
定义为News类型
Set <News> newsSet = new HashSet<>();

泛型集合中的数据不再转换为Object

泛型集合的优点

存储数据时进行严格类型审查，确保只有合适类型的对象才能存储在集合中。

从集合中检索对象时，减少了强制类型转换。

综合实例：

import java.util.*;

public class PetMap {
    public static void main(String[] args) {
        //创建Map对象添加信息
        Map<String ,String> dogMap = new HashMap<>();
        //使用Map存储狗狗信息
        dogMap.put("欧欧","雪瑞纳");
        dogMap.put("亚亚","拉布拉多");
        dogMap.put("菲菲","哈士奇");
        dogMap.put("美美","泰迪");

        //显示所有键值对
        System.out.println(dogMap);

        //显示所有key
        System.out.println(dogMap.keySet());
        //显示所有values
        System.out.println(dogMap.values());
        //查询数据
        System.out.println("Map中有" + dogMap.size() + "个狗狗\n");

        System.out.println("Map中存在指定对象，对象信息如下：");
        System.out.println("欧欧\t\t" + dogMap.get("欧欧"));

        System.out.println("---------------------------");
        dogMap.forEach((name,type) -> System.out.println(name + "\t" + type));

        System.out.println("---------------------------");
        System.out.println("Map中存在指定对象，对象信息如下：");
        dogMap.forEach((key,value) -> {
            if ("欧欧".equals(key)){
                System.out.println(key + "\t" + value);
            }
        });

        //删除欧欧
        System.out.println("---------------------------");
        dogMap.remove("欧欧");
        System.out.println("删除后还有" + dogMap.size() + "条狗狗");
        dogMap.forEach((key,value) -> {
            System.out.println(key + "\t" + value);
        });

        System.out.println("---------------------------");
        //增强for循环
        if (dogMap != null && !dogMap.isEmpty()){
            for (String key:dogMap.keySet()) {
                System.out.println(key + "\t" + dogMap.get(key));
            }
        }

        //显示所有key
        System.out.println(dogMap.keySet());

        //显示所有values
        System.out.println(dogMap.values());

        //显示所有key
        System.out.println("---------------------------");
        Set<String> keySet = dogMap.keySet();
        System.out.println(keySet);

        System.out.println("---------------------------");
        //显示所有信息
        for (String s : keySet) {
            System.out.println(s + "\t" + dogMap.get(s));
        }

        //显示所有values
        System.out.println("---------------------------");
        Collection<String> valueCollection = dogMap.values();
        System.out.println(valueCollection);
        //判断欧欧是否存在
        System.out.println((dogMap.containsKey("欧欧") ? "true":"false"));
    }
}

6、Collections类

Collections类是Java提供的一个集合操作工具类。

Collections类定义了一系列用于操作集合的静态方法，用于实现对集合元素的排序、查找和替换等操作。

Collections和Collection是不同的，前者是集合的操作类，后者是集合接口

Collections的常用方法（不是所有的方法）

1、sort():排序

2、binarySearch()：查找

3、max()\min():查找最大\最小值

Collections排序

1、实现一个类的对象之间比较大小，该类要实现Comparable<T>接口

2、重写 public int compareTo(T o)方法。

3、如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

实例：

创建学生类继承Comparable接口

public class Student implements Comparable{
    //学号
    private int no;
    //年龄
    private int age;
    //姓名
    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public Student() {
    }

    public Student(int no, int age, String name) {
        this.no = no;
        this.age = age;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public int compareTo(Object o) {
        Student student = (Student)o;
        if(this.getAge()<student.getAge()){
            return -1;
        }else if(this.getAge()>student.getAge()){
            return 1;
        }
        return 0;
    }
}

测试类：

public class CollectionsMethod {
    public static void main(String[] args) {
        Student stu1 = new Student(1,18,"张三");
        Student stu2 = new Student(4,17,"李四");
        Student stu3 = new Student(2,20,"王五");
        Student stu4 = new Student(3,19,"赵六");
        List<Student> studentList = new ArrayList<>();
        studentList.add(stu1);
        studentList.add(stu2);
        studentList.add(stu3);
        studentList.add(stu4);
        System.out.println("排序前:");
        studentList.forEach(System.out::println);
        Collections.sort(studentList);
        System.out.println("排序后:");
        studentList.forEach(System.out::println);
    }
}

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/93377.html