- 容器
- Collection
- List
- Set
- Map
一、容器概念
数组是相同数据类型的有序集合，可以在其中放置对象或基本数据类型。数组是一种简单的线性序列，可以快速的访问数组元素，效率高。
但是数组有一个问题，那就是一旦长度确定就不能改变，因此不灵活。所以出现了容器（数组也是一种容器），容器的长度可以随着元素的个数增加或减少。
- Collection接口是一组允许重复的对象
- List接口继承Collection，有序允许重复，以元素安插的次序来放置元素，不会重新排序。
- Set接口继承Collection，无序不允许重复，使用自己内部的一个排列机制。
- Map接口时一组成对的键值对象。Map中不能有重复的Key，拥有自己的内部排列机制
- 元素中的元素类型都为引用类型，不能放置原生数据类型(自动装箱)，使用泛型保留类型
二、Collection接口
该接口有两个子接口：
-
List中的数据有顺序，可重复
-
Set中的数组没有顺序，不可重复
1、常用方法
| 方法 | 返回值 | 作用 |
|---|---|---|
| add(E e) | boolean | 添加元素 |
| size() | int | 返回容器大小 |
| contains(Object o) | boolean | 包含(引用类型重写equals) |
| isEmpty() | boolean | 容器是否为空 |
| equals(Object o) | boolean | 删除元素(重写equals) |
| clear() | void | 清空容器 |
| toArray() | Object[] | 所有元素存放数组中 |
| toArray(T[] a) | <T>T[] | 所有元素存放数组中(泛型) |
| retainAll(Collection c) | boolean | 求两个容器的交集 |
| iterator() | Iterator | 遍历 |
2、<>泛型
在运行时才确定类型
泛型的好处
- 增强程序的可读性和稳定性
- 使用泛型，保留了容器中元素的类型，安全省心的使用容器。注意：没必要引用泛型的复杂性。
3、stream流
JDK8之后添加了一个新的抽象称为流stream
Collection中提供了一个stream()方法，用来获取集合的流
三、List接口
List接口，位置有序允许元素重复。多了一些关于位置（顺序）的方法
1、ArrayList
ArrayList 是 List 的子类，它和 HashSet 想法，允许存放重复元素，因此有序。集合中元 素被访问的顺序取决于集合的类型。如果对 ArrayList 进行访问，迭代器将从索引 0 开始， 每迭代一次，索引值加 1。然而，如果访问HashSet 中的元素，每个元素将会按照某种随机 的次序出 现。虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元 素被访问的次序。
扫描二维码关注公众号，回复：
11717283 查看本文章
1.1、构建方式
List<String> list = new ArrayList<>();
ArrayList<String> list1 = new ArrayList<>();
1.2、常用方法
List<String> list = new ArrayList<>();
list.add("张三"); // 添加元素
list.add("李四"); // 添加元素
list.add("王二"); // 添加元素
list.add("麻子"); // 添加元素
list.add(0,"啊哈哈"); // 指定位置添加元素
System.out.println(list.get(0)); // 获取指定位置的元素
System.out.println(list.indexOf("张三")); // 元素第一次出现的位置
System.out.println(list.lastIndexOf("张三")); // 元素最后第一次出现的位置
System.out.println(list.set(1, "张三三")); // 修改指定位置的元素，并返回修改前的元素
System.out.println(list.remove(1)); // 删除指定位置的元素，并返回删除前的元素
List<String> lists = list.subList(1, 3); // 获取子集合
System.out.println(lists);
System.out.println(list.contains("张三")); // 是否存在某个元素
| 运行结果 |
|---|
| 啊哈哈 1 1 张三 张三三 [李四, 王二] false |
1.3、List集合遍历
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王二");
list.add("麻子");
list.add(0,"啊哈哈");
// 方式一
for(int i=0;i<list.size();i++) {
System.out.print(list.get(i)+"\t");
}
System.out.println();
// 方式二
for(String str:list) {
System.out.print(str+"\t");
}
System.out.println();
// 方式三
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.print(it.next()+"\t");
}
System.out.println();
// 方式四
list.stream().forEach((x)->System.out.print(x+"\t"));
| 运行结果 |
|---|
| 啊哈哈 张三 李四 王二 麻子 啊哈哈 张三 李四 王二 麻子 啊哈哈 张三 李四 王二 麻子 啊哈哈 张三 李四 王二 麻子 |
2、LinkedList
2.1、构建方式
List<String> list = new LinkedList<>();
LinkedList<String> list1 = new LinkedList<>();
2.2、常用方法
List<String> list = new LinkedList<>();
list.add("张三"); // 添加元素
list.add("李四"); // 添加元素
list.add("王二"); // 添加元素
list.add("麻子"); // 添加元素
list.add(0,"啊哈哈"); // 指定位置添加元素
System.out.println(list.get(0)); // 获取指定位置的元素
System.out.println(list.indexOf("张三")); // 元素第一次出现的位置
System.out.println(list.lastIndexOf("张三")); // 元素最后第一次出现的位置
System.out.println(list.set(1, "张三三")); // 修改指定位置的元素，并返回修改前的元素
System.out.println(list.remove(1)); // 删除指定位置的元素，并返回删除前的元素
List<String> lists = list.subList(1, 3); // 获取子集合
System.out.println(lists);
System.out.println(list.contains("张三")); // 是否存在某个元素
| 运行结果 |
|---|
| 啊哈哈 1 1 张三 张三三 [李四, 王二] false |
2.3、遍历
List<String> list = new LinkedList<>();
list.add("张三");
list.add("李四");
list.add("王二");
list.add("麻子");
list.add(0,"啊哈哈");
// 方式一
for(int i=0;i<list.size();i++) {
System.out.print(list.get(i)+"\t");
}
System.out.println();
// 方式二
for(String str:list) {
System.out.print(str+"\t");
}
System.out.println();
// 方式三
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.print(it.next()+"\t");
}
System.out.println();
// 方式四
list.stream().forEach((x)->System.out.print(x+"\t"));
| 运行结果 |
|---|
| 啊哈哈 张三 李四 王二 麻子 啊哈哈 张三 李四 王二 麻子 啊哈哈 张三 李四 王二 麻子 啊哈哈 张三 李四 王二 麻子 |
3、LIst集合中存放自定义类型
public class Person {
private String name;
public Person() {
}
Person(String name){
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Test4 {
public static void main(String[] args) {
List<Person> list = new ArrayList<>();
list.add(new Person("张三"));
list.add(new Person("李四"));
}
}
自定义的类需要重写hashCode()和equals()方法
四、Set接口
HashSet是 Set 接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散 列的存储方法，所以没有顺序。这里所说的没有顺序是指：元素插入的顺序与输出的顺序不 一致。 使用重写 equals 和 hashcode 来实现自定义的类型的去重。
1、构建方式
Set<Integer> set = new HashSet<Integer>();
2、特点
public static void main(String[] args) {
Set<Integer> set = new HashSet<Integer>();
set.add(3);
set.add(9);
set.add(6);
set.add(1);
set.add(2);
set.add(4);
set.add(4);
System.out.println(set);
}
| 运行结果 |
|---|
| [1, 2, 3, 4, 6, 9] |
set集合是无序的，且不能重复
3、常用方法
Set<Integer> set = new HashSet<Integer>();
set.add(3);
set.add(9);
set.add(6);
set.add(1);
set.add(2);
set.add(4);
set.add(4);
set.remove(4); // 删除元素
System.out.println(set);
System.out.println(set.contains(4)); // 是否存在元素
System.out.println(set.size()); // 集合长度
set.clear(); // 清空集合
4、遍历
Set<Integer> set = new HashSet<Integer>();
set.add(3);
set.add(9);
set.add(6);
set.add(1);
set.add(2);
set.add(4);
set.add(4);
// 方式一
for(int i:set) {
System.out.print(i+"\t");
}
System.out.println();
// 方式二
Iterator<Integer> i = set.iterator();
while(i.hasNext()) {
System.out.print(i.next()+"\t");
}
System.out.println();
// 方式三
set.stream().forEach((x)->System.out.print(x+"\t"));
| 运行结果 |
|---|
| 1 2 3 4 6 9 1 2 3 4 6 9 1 2 3 4 6 9 |
5、存放自定义类型
public static void main(String[] args) {
Set<Person> set = new HashSet<Person>();
set.add(new Person("张三"));
set.add(new Person("李四"));
}
五、Map接口
实现Map接口的类用来存储键(key)－值(value) 对。
Map 接口的实现类有HashMap和TreeMap等。
Map类中存储的键－值对通过键来标识，所以键值不能重复。
HashMap: 线程不安全，效率高. 允许key或value为null
**HashTable:**线程安全，效率低. 不允许key或value为null
Properties: HashTable的子类，key和value都是string
1、构建方式
Map<String,String> map = new HashMap<>();
2、常用方法
Map<String,String> map = new HashMap<>();
map.put("a", "张三"); // 添加键值对
map.put("b", "李四");
System.out.println(map);
map.remove("a"); // 通过key删除键值对
System.out.println(map.get("b")); // 通过key获取value值
| 运行结果 |
|---|
| {a=张三, b=李四} 李四 |
3、遍历
Map<String,String> map = new HashMap<>();
map.put(“a”, “AA”);
map.put(“b”, “BB”);
map.put(“c”, “CC”);
map.put(“d”, “DD”);
map.put(“e”, “EE”);
map.put(“f”, “FF”);
// 方式一
Set<String> set = map.keySet(); // 和set一样
for(String str:set) {
System.out.print(map.get(str)+"\t");
}
System.out.println();
// 方式二
Collection<String> values = map.values(); // 另外两小种：iterator()、stream()
for(String str:values) {
System.out.print(str+"\t");
}
System.out.println();
// 方式三
Set<Entry<String, String>> set1 = map.entrySet();
for(Entry<String, String> s:set1) {
System.out.println(s.getKey()+"--->"+s.getValue());
}
| 运行结果 |
|---|
| AA BB CC DD EE FF AA BB CC DD EE FF a—>AA b—>BB c—>CC d—>DD e—>EE f—>FF |
4、Properties
Properties为Hashtable的子类，要求键与值只能为字符串 ，不能为null，长与 配置文件(与外界交互 的信息) 即内存与存储介质(文件、数据库、网络、服务器内存等)交互。
userName=root
userPwd=123456
user=\u554A\u54C8\u54C8
public class Demo004 {
public static void main(String[] args) throws IOException {
Properties pro = new Properties();
pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
System.out.println(pro.get("userName"));
System.out.println(pro.get("userPwd"));
System.out.println(pro.get("user"));
}
}
| 运行结果 |
|---|
| root 123456 啊哈哈 |