目录
目录
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/97214.html
