Java集合的用法及特点
2020-05-16 本文已影响0人
魏皇子
单列LIst集合
单列列表集合：
- 集合的由来
长度是固定的，当添加的元素超过了多个的长度时需要对分段重新定义，太麻烦了，java内部给我们提供了集合类，能存储任意对象，长度是可以改变的，通过元素的增加而增加，通过元素的减少而减少
副本和集合的区别：
区别1：
#数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值
集合只能存储引用数据类型（对象）集合中也可以存储基本数据类型，但在存储的时候会自动装箱变成对象
区别2：
分布长度是固定的，不能自动增长*集合的长度的是可变的，可以根据元素的增加而增长1 2 3 C：复制和集合什么时候用
数组和集合什么时候用：
-
如果元素个数是固定的推荐用堆叠
-
如果元素个数不是固定的推荐用集合
Collection集合的基本功能用法
public static void main(String[] args) {
Collection c = new ArrayList(); //创建集合对象
c.add("a"); //添加元素，返回值为boolean
c.remove("a"); //删除元素，返回值为boolean
c.clear(); //清空集合，无返回值
boolean pd = c.contains("a"); //判断是否包含元素，包含则返回true
boolean pd = c.isEmpty(); //判断集合是否为空，为空返回true
int num = c.size(); //获取集合中元素的个数，返回值为int
}
Collection集合的带All功能用法
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Collection c2 = new ArrayList();
c2.addAll(c1); //c1全部赋值给c2集合
c1.removeAll(c2); //删除c1内与c2交集的部分,返回值为boolean
boolean b = c1.containsAll(c2);//判断调用的集合是否包含传入的集合
boolean c = c1.retainAll(c2);//取c1和c2的交集，存入c1
//如果调用的集合改变就返回true，注意：如果c2无值则c1也将变为无值
System.out.println(c1);
System.out.println(c2);
}
集合的遍历之集合转数组遍历
public static void main(String[] args) {
Collection c = new ArrayList(); //创建集合对象
c.add("a");
c.add("b");
c.add(new Student("王欢", 28)); //创建对象存入数组
Object[] arr = c.toArray(); //将集合转换为数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
集合的遍历之迭代器遍历
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Iterator it = c1.iterator();//获取c1集合的迭代器
while (it.hasNext()) { //判断集合中是否有元素
System.out.println(it.next()); //获取元素
}
Collection c2 = new ArrayList();
c2.add(new Student("张三", 23));
c2.add(new Student("李四", 18));
Iterator it2 = c2.iterator();//获取c2集合的迭代器
while (it2.hasNext()) {
Student s = (Student)it2.next(); //向下转型
System.out.println(s.getName());
}
}
List集合的特有功能
public static void main(String[] args) {
List c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
c1.add(1, "e");//指定索引位置添加元素
Object obj = c1.remove(1);//通过索引删除元素并返回删除的元素
Object obj2 = c1.get(0); //通过索引获取指定元素
c1.set(0, "z"); //将指定位置的元素修改
System.out.println(obj2);
System.out.println(c1);
}
List集合特有迭代器
该迭代器可以在遍历的同时向集合内添加元素
public static void main(String[] args) {
List c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("nan");
c1.add("c");
c1.add("d");
ListIterator it = c1.listIterator();//List集合特有迭代器
while (it.hasNext()) {
String str = (String) it.next();
if ("nan".equals(str)) { //当集合中存在nan时则添加元素
it.add("zzzzzzz"); //通过迭代器添加元素
}
}
System.out.println(c1);
}
Vector的特有功能概述和测试【注意：Vector已被完全替代，请勿再使用】
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
v.addElement("d");
Enumeration en = v.elements();//获取枚举
while (en.hasMoreElements()) {//判断集合中是否有元素
System.out.println(en.nextElement());//获取集合中的元素
}
}
List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
Vector和ArrayList的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
共同点:都是数组实现的
ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的
注意：线程不安全可以通过工具类改为安全的
如何选择：
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList
#### 案例：ArrayList去除集合中字符串的重复值
```java
public class CeShi {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("b");
ArrayList abc = JiHeFF(list);
System.out.println(abc);
}
public static ArrayList JiHeFF(ArrayList list) {
ArrayList newList = new ArrayList(); //创建一个新集合
Iterator it = list.iterator(); //获取迭代器
while (it.hasNext()) { //判断老集合中是否有元素，遍历老集合
Object obj = it.next(); //将每一个元素临时记录住
if (!newList.contains(obj)) { //如果新集合中不包含该元素
newList.add(obj); //将该元素添加到新集合中
}
}
return newList; //将新集合返回
}
}
案例：ArrayList去除集合重复自定义对象元素
注意：需要重写类的equals()方法
public class CeShi {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("李四", 23));
list.add(new Student("李四", 23));
list.add(new Student("李四", 23));
ArrayList newList = JiHeFF(list);
System.out.println(newList);
}
public static ArrayList JiHeFF(ArrayList list) {
ArrayList newList = new ArrayList(); //创建一个新集合
Iterator it = list.iterator(); //获取迭代器
while (it.hasNext()) { //判断老集合中是否有元素，遍历老集合
Object obj = it.next(); //将每一个元素临时记录住
if (!newList.contains(obj)) { //如果新集合中不包含该元素
newList.add(obj); //将该元素添加到新集合中
}
}
return newList; //将新集合返回
}
}
//重写Student类的equals()方法，可以通过IDEA快速生成
@Override
public boolean equals(Object o) {
Student s = (Student) o;
return this.name.equals(s.name) && this.age == s.age;
}
案例：ArrayList通过迭代器获取自定义对象指定属性值
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<Person>();
list.add(new Person("张三", 23));
list.add(new Person("李四", 24));
Iterator<Person> it = list.iterator(); //获取迭代器
while(it.hasNext()) {
//System.out.println(it.next().getName() + "..." + it.next().getAge());//next方法只能调用一次,如果调用多次会将指针向后移动多次
Person p = it.next(); //声明对象并将数据存入
System.out.println(p.getName() + "..." + p.getAge()); //打印所需要的属性
}
}
LinkedList的特有功能
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.addFirst("a"); //往头添加元素
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e"); //往尾添加元素
//System.out.println(list.getFirst());//获取第一个
//System.out.println(list.getLast());//获取最后一个
//System.out.println(list.removeFirst());//删除第一个
//System.out.println(list.removeLast());//删除最后一个
System.out.println(list.get(1));//获取索引位置的元素，其实并不是靠索引，因为是链表结构，靠的是挨个查询
System.out.println(list);
}
增强for的功能概述和测试(foreach)
-
A:增强for概述
- 简化数组和Collection集合的遍历
-
B:格式：
- for(元素数据类型 变量 : 数组或者Collection集合) {使用变量即可，该变量就是元素}
-
C:案例演示
- 数组，集合存储元素用增强for遍历
-
D:好处
简化遍历
增强for循环底层依赖的是迭代器(Iterator)
//增强for功能演示
public class CeShi {
public static void main(String[] args) {
ArrayList<Student> list1 = new ArrayList<>();
list1.add(new Student("张三", 23));
list1.add(new Student("张三", 23));
list1.add(new Student("李四", 23));
list1.add(new Student("李四", 23));
list1.add(new Student("李四", 23));
for (Student i : list1) {
Student s1 = i;
System.out.println(i.getName());
}
System.out.println("==============================");
int[] arr = {11, 22, 33, 44, 55};
for (int i : arr) {
System.out.println(i);
}
}
}
集合元素的三种删除方式测试
-
普通for循环,可以删除,但是索引要–
-
迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
增强for循环不能删除
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
//1,普通for循环删除,索引要--
/*for(int i = 0; i < list.size(); i++) {
if("b".equals(list.get(i))) {
list.remove(i--); //通过索引删除元素
}
}*/
//2,迭代器删除
/*Iterator<String> it = list.iterator();
while(it.hasNext()) {
if("b".equals(it.next())) {
//list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it.remove();
}
}*/
/*for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
if("b".equals(it2.next())) {
//list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it2.remove();
}
}*/
//3,增强for循环,增强for循环不能删除,只能遍历
for (String string : list) {
if("b".equals(string)) {
list.remove("b");
}
}
System.out.println(list);
}
单列Set集合：
//Set集合,无索引,不可以重复,无序(存取不一致)
//注意：存储类对象则需要修改类对象的equals和hashCode方法，否则可以存储重复对象
//定义HashSet
HashSet<Student> hs = new HashSet<>();
hs.add(new Student("张三", 23));
//定义LinkedHashSet，底层是链表实现的,是set集合中唯一一个能保证怎么存就怎么取的集合对象
LinkedHashSet<String> lhs = new LinkedHashSet<>();
lhs.add("a");
//定义TreeSet，用来对象元素进行排序,同样他也可以保证元素的唯一
TreeSet<Integer> ts = new TreeSet<>();
ts.add(3);
双列Map集合：
-
Map接口和Collection接口的不同
-
Map是双列的,Collection是单列的
-
Map的键唯一,Collection的子体系Set是唯一的
-
Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
A:Map集合的功能概述
-
a:添加功能
-
V put(K key,V value):添加元素。
-
如果键是第一次存储，就直接存储元素，返回null
-
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
-
b:删除功能
-
void clear():移除所有的键值对元素
-
V remove(Object key)：根据键删除键值对元素，并把值返回
-
c:判断功能
-
boolean containsKey(Object key)：判断集合是否包含指定的键
-
boolean containsValue(Object value):判断集合是否包含指定的值
-
boolean isEmpty()：判断集合是否为空
-
d:获取功能
-
Set<Map.Entry<K,V>> entrySet():
-
V get(Object key):根据键获取值
-
Set keySet():获取集合中所有键的集合
-
Collection values():获取集合中所有值的集合
-
e:长度功能
-
int size()：返回集合中的键值对的个数
Map<String, Integer> map = new HashMap<>();
Integer i1 = map.put("张三", 23);//添加
Integer value = map.remove("张三"); //根据键删除元素,返回键对应的值
System.out.println(map.containsKey("张三")); //判断是否包含传入的键
System.out.println(map.containsValue(100)); //判断是否包含传入的值
第一种迭代方式
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
Integer i = map.get("张三"); //根据键获取值
//获取所有的键
Set<String> keySet = map.keySet(); //获取所有键的集合
Iterator<String> it = keySet.iterator();//获取迭代器
while (it.hasNext()) {
String key = it.next(); //获取每一个键
Integer value = map.get(key);//根据键获取值
System.out.println(key + "=" + value);
}
System.out.println("=======================================");
//使用增强for循环遍历
for (String key : map.keySet()) { //map.keySet()是所有键的集合
System.out.println(key + "=" + map.get(key));
}
}
第二种迭代方式
/**
* Map集合的第二种迭代,根据键值对对象,获取键和值
* A:键值对对象找键和值思路：
* 获取所有键值对对象的集合
* 遍历键值对对象的集合，获取到每一个键值对对象
* 根据键值对对象找键和值
*/
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
//Map.Entry说明Entry是Map的内部接口,将键和值封装成了Entry对象,并存储在Set集合中
/*Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
//获取每一个对象
Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
while(it.hasNext()) {
//获取每一个Entry对象
Map.Entry<String, Integer> en = it.next(); //父类引用指向子类对象
//Entry<String, Integer> en = it.next(); //直接获取的是子类对象
String key = en.getKey(); //根据键值对对象获取键
Integer value = en.getValue(); //根据键值对对象获取值
System.out.println(key + "=" + value);
}*/
for(Entry<String, Integer> en : map.entrySet()) {
System.out.println(en.getKey() + "=" + en.getValue());
}
}
案例：用HashMap统计字符串中每个字符出现的次数
public class CeShi {
public static void main(String[] args) {
//1,定义一个需要被统计字符的字符串
String s = "abbccddddddcccbbaa";
//2,将字符串转换为字符数组
char[] arr = s.toCharArray();
//3,定义双列集合,存储字符串中字符以及字符出现的次数
HashMap<Character, Integer> hm = new HashMap<>();
//4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
for (char c : arr) {
//5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
/*if (!hm.containsKey(c)) {//如果不包含这个键
hm.put(c, 1);
} else {
hm.put(c, hm.get(c) + 1);
} */
hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
}
//6,打印双列集合获取字符出现的次数
for (Character key : hm.keySet()) { //hm.keySet()代表所有键的集合
System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值
}
}
}
集合总结：
Collection（单列集合）
List(存取有序,有索引,可以重复)
ArrayList
底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
LinkedList
底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢
Vector
底层是数组实现的,线程安全的,无论增删改查都慢
* 如果查找和修改多,用ArrayList
* 如果增和删多,用LinkedList
* 如果都多,用ArrayList
Set(存取无序,无索引,不可以重复)
HashSet
底层是哈希算法实现
LinkedHashSet
底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样
TreeSet
底层是二叉树算法实现
*一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高
* TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别
Map（双列集合）
HashMap
底层是哈希算法,针对键
LinkedHashMap
底层是链表,针对键
TreeMap
底层是二叉树算法,针对键
*开发中用HashMap比较多
