本文介绍了Java集合框架中的核心概念，包括数组和集合的区别，重点讲解了Collection集合中的List和Set集合，如ArrayList、Vector、LinkedList、HashSet、TreeSet及其特点与遍历方式。还探讨了Map集合如HashMap、TreeMap和LinkedHashMap以及泛型的基本使用。
文章目录
1.数组和集合
共同点： 都是用来存储一组数据的对象容器。
不同点：
- 长度：数组的长度是固定的，集合的长度可以改变（增加元素和删除元素）
- 类型：数组的元素可以是任何类型，集合的每个元素都是引用数据类型（基本数据类型可以转为包装类的对象）
2.集合框架
集合分类 ：Collection和Map（所在包：java.util*）
3.Collection集合（List集合和Set集合）
（1） Collection 接口
（2） 不能实例化
（3） 常用的抽象方法
1.List集合（ArrayList、Vector、LinkedList）
（1） List接口
（2） 继承至Collection接口
（3） 不能实例化（没有构造器）
（4） 特点：和数组一样是有序，可以存储重复的元素。
（5） 抽象方法：继承自Collection接口的抽象方法
List集合下除了继承Collection接口的抽象方法之外，自己扩展的常用的方法：
实现类
（1）ArrayList和Vector和LinkedList
ArrayList和Vector和LinkedList
只要会ArrayList一样，其他两个都和ArrayList一样
注：在这里不在细说Vector和LinkedList实现类
区别： ArrayList和Vector 都是采用的数组结构的存储数据，查询和修改的速度很快，但是插入和删除比较慢。
LinkedList 采用的是链表结构存储数据，查询和修改速度慢，删除和插入比较快。
ArrayList 是线程不安全的，但是速度快。
Vector 是线程不安全的。
ArrayList的使用
// 创建一个集合对象
ArrayList list=new ArrayList();
// 获取集合的元素个数，即长度。
System.out.println(list.size());
// 判断是否是集合
System.out.println(list.isEmpty());
// 添加元素
list.add(97);
list.add(94);
list.add(93);
list.add(90);
list.add(94);
list.add(94);
// 获取集合的元素个数，即长度。
System.out.println(list.size());
// 判断是否是集合
System.out.println(list.isEmpty());
// 删除元素
// list.remove(4);//根据下标删除
list.remove(new Integer(94));//根据元素删除
// 获取集合的元素个数，即长度。
System.out.println(list.size());
// 清空集合
// list.clear();
// 获取集合的元素个数，即长度。
// System.out.println(list.size());
// 是否包含指定的元素
boolean bl=list.contains(95);
System.out.println(bl);
// 获取指定的元素
Object o1=list.get(1);
System.out.println(o1);
// 修改指定的元素
list.set(1, 100);
Object o11=list.get(1);
System.out.println(o11);
// 获取指定元素第一次出现的下标
int index1=list.indexOf(94);
System.out.println(index1);
// 获取指定元素最后一次出现的下标
int index2=list.lastIndexOf(94);
System.out.println(index2);
// 截取子集合
List list2=list.subList(1, 4);
System.out.println(list2.size());
（2）List集合的四种遍历
// List集合遍历：4种方式
List list=new ArrayList();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("aa");
list.add("dd");
System.out.println(list.size());
方式1:for i
// for (int i = 0; i < list.size(); i++) {
// Object e=list.get(i);
// System.out.println(e);
// }
方式2:增强for
// for(Object e:list) {
// System.out.println(e);
// }
方式3：迭代器
// 通过集合对象获取对应的迭代器
Iterator it=list.iterator();
// 通过迭代器遍历集合
// 判断是否有下一个
// while(it.hasNext()) {
取出下一个
// Object e=it.next();
// System.out.println(e);
// }
方式4：forEach,jdk1.8开始支持的新语法，箭头函数
int a=10;
list.forEach((e)->{
System.out.println(e);
int c=a;
System.out.println(c);
c=18;
});
// a=18;
2.Set集合
（1）HashSet和TreeSet和HashTable
Set接口没有扩展新方法，但是对add方法进行限制，不允许插入重复元素。
HashSet重复元素的判断：
如果两个对象的hashCode值相等，且使用equals方法比较相等，那么这两个对象事重复的元素。
HashSet、LinkedHashSet、TreeSet
区别：
==HashSet有以下特点 ==
1.不能保证元素的排列顺序，顺序有可能发生变化
2.是同步的
3.集合元素可以是null,但只能放入一个null
4.当向HashSet结合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。
简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相等
LinkedHashSet集合：
同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。
TreeSet：
是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
（2）Set集合的三种遍历
创建set集合
HashSet set=new HashSet();
// 添加元素（不允许插入重复的元素）
set.add("aaa");
set.add("bbb");
set.add("ccc");
set.add("ddd");
set.add("aaa");
set.add("aaa");
set.add("aaa");
遍历
// 方式1：增强for
// for(Object o:set) {
// System.out.println(o);
// }
// 方式2：迭代器
// Iterator it=set.iterator();
// while(it.hasNext()) {
// Object o=it.next();
// System.out.println(o);
// }
// 方式3：forEach
set.forEach((o)->{
System.out.println(o);
});
4.Map集合（HashMap和TreeMap和LinkedHashMap）
（1） java.util.map接口
（2） 不能实例化
（3）特点
每个元素是一个键值对
每个元素的键不可重复，也就是唯一的
Map接口中的抽象方法：
Map集合的三种遍历
创建map集合
Map m=new HashMap();
// 添加元素
m.put("1001", "张三");
m.put("1002", "李四");
m.put("1003", "王五");
m.put("1004", "马六");
m.put("1005", "赵琦");
m.put("1006", "王八");
遍历
// 方式1
// m.forEach((k,v)->{
// System.out.println(k+"="+v);
// });
// 方式2:
// Set keys=m.keySet();
// for(Object k:keys) {
// Object v=m.get(k);
// System.out.println(k+"="+v);
//
// 方式3：
// Set entrys=m.entrySet();
// for(Object entry:entrys) {
// Map.Entry kv=(Map.Entry)entry;
// System.out.println(kv.getKey()+"="+kv.getValue());
// }
获取所有元素的值
Collection cvs=m.values();
for(Object v:cvs) {
System.out.println(v);
}
面试题：
List、Set、Map集合有什么区别：
List和Set集合都属于Collection集合，每个元素都是一个值。
List是有序的集合，可以存储重复的元素。
Set集合是无序的集合，不可以存储重复的元素
Map每个元素是一个键值对。
5.泛型
（1） 它是所有引用数据类型的一种表示，参数化动态数据类型。
（2） 泛型一般情况，使用26个大写字母表示。
（3） 泛型类的定义
public class Stu<G,V> {
private G no;
private V sex;
public void setNo(G no) {
this.no=no;
}
public G getNo() {
return no;
}
public void setSex(V sex) {
this.sex = sex;
}
public V getSex() {
return sex;
}
}
（4） 泛型的指定
没有指定，默认代表Object
// G=Object,V=Object
Stu s1=new Stu();
Object no1=s1.getNo();
Object sex1=s1.getSex();
指定G=String，V=Character
Stu<String,Character> s2=new Stu<String,Character>();
String no2=s2.getNo();
Character sex2=s2.getSex();
指定G=Integer，V=String
Stu<Integer,String> s3=new Stu<Integer,String>();
Integer no3=s3.getNo();
String sex3=s3.getSex();
（5）集合中泛型的使用
作用：避免类型转换操作。
List list1=new ArrayList();
list1.add("aa");
list1.add("bb");
list1.add("cc");
for(Object o:list1) {
String so=(String)o;
System.out.println(so.substring(1));
}
List<String> list2=new ArrayList<>();
list2.add("aa");
list2.add("bb");
list2.add("cc");
list2.add("dd");
for(String s:list2) {
System.out.println(s.substring(1));
}
Set<String> set1=new HashSet<>();
set1.add("aa");
set1.add("bb");
for(String s:set1) {
System.out.println(s.substring(1));
}
Map<String,Integer> m=new HashMap<>();
m.put("aa",123);
m.put("bb",456);
Set<String> keys=m.keySet();
for (String key:keys) {
Integer value=m.get(key);
System.out.println(key+"="+value);
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
